Java Code Examples for android.view.ScaleGestureDetector#getFocusX()

@Override
public boolean onScale(ScaleGestureDetector detector) {
    if (!scaling) {
        return true;
    }
    currentScale = detector.getCurrentSpan() / firstSpan;

    float focusX = detector.getFocusX();
    float focusY = detector.getFocusY();

    this.mapView.setScale(currentScale);
    this.mapView.getController().offsetDeltaScroll(lastFocusX - focusX, lastFocusY - focusY);
    this.mapView.getController().panBy(lastFocusX - focusX, lastFocusY - focusY, true);

    lastFocusX = focusX;
    lastFocusY = focusY;
    return true;
}
 

@SuppressWarnings("WeakerAccess") // Public API (can be overridden)
protected boolean onScale(ScaleGestureDetector detector) {
    if (!settings.isZoomEnabled() || isAnimatingState()) {
        return false; // Ignoring scroll if animation is in progress
    }

    final float scaleFactor = detector.getScaleFactor();

    boolean scaleConsumed = exitController.onScale(scaleFactor);
    if (scaleConsumed) {
        return true;
    }

    pivotX = detector.getFocusX();
    pivotY = detector.getFocusY();
    state.zoomBy(scaleFactor, pivotX, pivotY);
    isStateChangedDuringTouch = true;

    return true;
}
 

@Override
@TargetApi(Build.VERSION_CODES.HONEYCOMB)
public boolean onScale(ScaleGestureDetector detector) {
    RectF rect = mCropWindowHandler.getRect();

    float x = detector.getFocusX();
    float y = detector.getFocusY();
    float dY = detector.getCurrentSpanY() / 2;
    float dX = detector.getCurrentSpanX() / 2;

    float newTop = y - dY;
    float newLeft = x - dX;
    float newRight = x + dX;
    float newBottom = y + dY;

    if (newLeft < newRight && newTop <= newBottom && newLeft >= 0 && newRight <= mCropWindowHandler.getMaxCropWidth() && newTop >= 0 && newBottom <= mCropWindowHandler.getMaxCropHeight()) {

        rect.set(newLeft, newTop, newRight, newBottom);
        mCropWindowHandler.setRect(rect);
        invalidate();
    }

    return true;
}
 

@Override
public boolean onScale(ScaleGestureDetector detector) {
    //拿到缩放比例
    float scale = getScale();
    float scaleFactor = detector.getScaleFactor();
    //拿到缩放中心
    float focusX = detector.getFocusX();
    float focusY = detector.getFocusY();
    //默认不能缩放至屏幕控件大小
    if (mIsLimitBroad) {
        if (scale * scaleFactor < mDeflautScale) {
            //重新复制，让它逼近于最小值
            scaleFactor = mDeflautScale / scale;
        }
        if (scale * scaleFactor > mMaxScale) {
            scaleFactor = mMaxScale / scale;
        }
    }
    mMatrix.postScale(scaleFactor,scaleFactor,focusX,focusY);
    checkBroad();
    setImageMatrix(mMatrix);
    return true;
}
 

@Override
  public boolean onScale(ScaleGestureDetector detector) {
      zoomFactor *= detector.getScaleFactor();

      // Don't let the object get too small or too large.
      zoomFactor = Math.max(1.0f, Math.min(zoomFactor, 8.0f));
      
TouchEvent touchEvent = touchEventPool.newObject();
touchEvent.type = TouchEvent.TOUCH_SCALE;
touchEvent.x2 = (int) ((detector.getFocusX() - offsetX) * scaleX);
touchEvent.y2 = (int) ((detector.getFocusY() - offsetY) * scaleY);
touchEvent.zoomFactor = zoomFactor;
touchEventsBuffer.add(touchEvent);

      return true;
  }
 

public boolean onScale(ScaleGestureDetector detector)
{
	//  new scale factor
	float previousScale = mScale;
	mScale = Math.min(Math.max(mScale * detector.getScaleFactor(), MIN_SCALE), MAX_SCALE);

	//  did we really scale?
	if (mScale == previousScale)
		return true;

	//  scale children
	scaleChildren();

	//  maintain focus while scaling
	double scale = mScale / previousScale;
	double currentFocusX = detector.getFocusX();
	double currentFocusY = detector.getFocusY();
	double viewFocusX = (int) currentFocusX + getScrollX();
	double viewFocusY = (int) currentFocusY + getScrollY();
	int diffX = (int) (viewFocusX * (1 - scale));
	int diffY = (int) (viewFocusY * (1 - scale));
	mXScroll += diffX;
	mYScroll += diffY;

	requestLayout();

	return true;
}
 

@Override
@TargetApi(Build.VERSION_CODES.HONEYCOMB)
public boolean onScale(ScaleGestureDetector detector) {
    RectF rect = mCropWindowHandler.getRect();

    float x = detector.getFocusX();
    float y = detector.getFocusY();
    float dY = detector.getCurrentSpanY() / 2;
    float dX = detector.getCurrentSpanX() / 2;

    float newTop = y - dY;
    float newLeft = x - dX;
    float newRight = x + dX;
    float newBottom = y + dY;

    if (newLeft < newRight
            && newTop <= newBottom
            && newLeft >= 0
            && newRight <= mCropWindowHandler.getMaxCropWidth()
            && newTop >= 0
            && newBottom <= mCropWindowHandler.getMaxCropHeight()) {

        rect.set(newLeft, newTop, newRight, newBottom);
        mCropWindowHandler.setRect(rect);
        invalidate();
    }

    return true;
}
 

public boolean onScale(ScaleGestureDetector detector) {
	float previousScale = mScale;
	mScale = Math.min(Math.max(mScale * detector.getScaleFactor(), MIN_SCALE), MAX_SCALE);

	{
		float factor = mScale/previousScale;

		View v = mChildViews.get(mCurrent);
		if (v != null) {
			float currentFocusX = detector.getFocusX();
			float currentFocusY = detector.getFocusY();
			// Work out the focus point relative to the view top left
			int viewFocusX = (int)currentFocusX - (v.getLeft() + mXScroll);
			int viewFocusY = (int)currentFocusY - (v.getTop() + mYScroll);
			// Scroll to maintain the focus point
			mXScroll += viewFocusX - viewFocusX * factor;
			mYScroll += viewFocusY - viewFocusY * factor;

			if (mLastScaleFocusX>=0)
				mXScroll+=currentFocusX-mLastScaleFocusX;
			if (mLastScaleFocusY>=0)
				mYScroll+=currentFocusY-mLastScaleFocusY;

			mLastScaleFocusX=currentFocusX;
			mLastScaleFocusY=currentFocusY;
			requestLayout();
		}
	}
	return true;
}
 

@Override
public boolean onScale(ScaleGestureDetector scaleGestureDetector) {

    mIsInteracting = true;

    Matrix transformationMatrix = new Matrix();
    float focusX = scaleGestureDetector.getFocusX();
    float focusY = scaleGestureDetector.getFocusY();

    float scaleX = ScaleGestureDetectorCompat.getCurrentSpanX(scaleGestureDetector) / ScaleGestureDetectorCompat.getPreviousSpanX(scaleGestureDetector);
    float scaleY = ScaleGestureDetectorCompat.getCurrentSpanY(scaleGestureDetector) / ScaleGestureDetectorCompat.getPreviousSpanY(scaleGestureDetector);

    //Zoom focus is where the fingers are centered,
    transformationMatrix.postTranslate(-focusX, -focusY);
    transformationMatrix.postScale(scaleX, scaleY);

    float focusShiftX = focusX - mLastFocusX;
    float focusShiftY = focusY - mLastFocusY;
    transformationMatrix.postTranslate(focusX + focusShiftX, focusY + focusShiftY);
    mDrawMatrix.postConcat(transformationMatrix);

    constrainView();

    recalculateXCoordinates(mGraphWidth * mDrawMatrixValues[0]);
    if(calculateLegendBounds())
        Utils.calculateLegendInformation(mSeries.get(0).getSeries(), 0, mGraphWidth * mDrawMatrixValues[0], mLegendPaint);

    mLastFocusX = focusX;
    mLastFocusY = focusY;

    if(mFocusedPoint != null) {
        calculateValueTextHeight();
    }
    invalidateGlobal();

    return true;
}
 

@Override
public boolean onScaleBegin(ScaleGestureDetector detector) {
    lastFocusX = detector.getFocusX();
    lastFocusY = detector.getFocusY();
    firstSpan = detector.getCurrentSpan();
    currentScale = 1.0f;
    if (!this.mapView.isAnimating()) {
        this.mapView.setIsAnimating(true);
        this.mapView.getController().aboutToStartAnimation(lastFocusX, lastFocusY);
        scaling = true;
    }
    return true;
}
 

@Override
public boolean onScale(ScaleGestureDetector detector) {
    mScaleFactor *= detector.getScaleFactor();
    mScalePointX = detector.getFocusX();
    mScalePointY = detector.getFocusY();

    // Don't let the object get too small or too large.
    mScaleFactor = Math.max(0.1f, Math.min(mScaleFactor, 5.0f));

    invalidate();
    return true;
}
 

@Override
@TargetApi(Build.VERSION_CODES.HONEYCOMB)
public boolean onScale(ScaleGestureDetector detector) {
  RectF rect = mCropWindowHandler.getRect();

  float x = detector.getFocusX();
  float y = detector.getFocusY();
  float dY = detector.getCurrentSpanY() / 2;
  float dX = detector.getCurrentSpanX() / 2;

  float newTop = y - dY;
  float newLeft = x - dX;
  float newRight = x + dX;
  float newBottom = y + dY;

  if (newLeft < newRight
      && newTop <= newBottom
      && newLeft >= 0
      && newRight <= mCropWindowHandler.getMaxCropWidth()
      && newTop >= 0
      && newBottom <= mCropWindowHandler.getMaxCropHeight()) {

    rect.set(newLeft, newTop, newRight, newBottom);
    mCropWindowHandler.setRect(rect);
    invalidate();
  }

  return true;
}
 

@Override
public boolean onScale(ScaleGestureDetector scaleGestureDetector) {

    if (!mScaleXEnable) return false;
    if (!mScaleGestureEnable) return super.onScale(scaleGestureDetector);

    float spanX = scaleGestureDetector.getCurrentSpanX();

    float newWidth = lastSpanX / spanX * mCurrentViewport.width();

    if (newWidth < mCurrentViewport.width() && mCurrentViewport.width() < 0.001) {
        return true;
    }

    float focusX = scaleGestureDetector.getFocusX();
    float focusY = scaleGestureDetector.getFocusY();
    hitTest(focusX, focusY, viewportFocus);

    mCurrentViewport.left = viewportFocus.x
            - newWidth * (focusX - mContentRect.left)
            / mContentRect.width();

    mCurrentViewport.right = mCurrentViewport.left + newWidth;
    mCurrentViewport.constrainViewport();
    triggerViewportChange();
    lastSpanX = spanX;

    return true;
}
 

public boolean onScale(ScaleGestureDetector detector) {
	float previousScale = mScale;
	mScale = Math.min(Math.max(mScale * detector.getScaleFactor(), MIN_SCALE), MAX_SCALE);

	{
		float factor = mScale/previousScale;

		View v = mChildViews.get(mCurrent);
		if (v != null) {
			float currentFocusX = detector.getFocusX();
			float currentFocusY = detector.getFocusY();
			// Work out the focus point relative to the view top left
			int viewFocusX = (int)currentFocusX - (v.getLeft() + mXScroll);
			int viewFocusY = (int)currentFocusY - (v.getTop() + mYScroll);
			// Scroll to maintain the focus point
			mXScroll += viewFocusX - viewFocusX * factor;
			mYScroll += viewFocusY - viewFocusY * factor;

			if (mLastScaleFocusX>=0)
				mXScroll+=currentFocusX-mLastScaleFocusX;
			if (mLastScaleFocusY>=0)
				mYScroll+=currentFocusY-mLastScaleFocusY;

			mLastScaleFocusX=currentFocusX;
			mLastScaleFocusY=currentFocusY;
			requestLayout();
		}
	}
	return true;
}
 

public boolean onScale(ScaleGestureDetector detector) {
    float previousScale = mScale;
    mScale = Math.min(Math.max(mScale * detector.getScaleFactor(), MIN_SCALE), MAX_SCALE);

    {
        float factor = mScale / previousScale;

        View v = mChildViews.get(mCurrent);
        if (v != null) {
            float currentFocusX = detector.getFocusX();
            float currentFocusY = detector.getFocusY();
            // Work out the focus point relative to the view top left
            int viewFocusX = (int) currentFocusX - (v.getLeft() + mXScroll);
            int viewFocusY = (int) currentFocusY - (v.getTop() + mYScroll);
            // Scroll to maintain the focus point
            mXScroll += viewFocusX - viewFocusX * factor;
            mYScroll += viewFocusY - viewFocusY * factor;

            if (mLastScaleFocusX >= 0)
                mXScroll += currentFocusX - mLastScaleFocusX;
            if (mLastScaleFocusY >= 0)
                mYScroll += currentFocusY - mLastScaleFocusY;

            mLastScaleFocusX = currentFocusX;
            mLastScaleFocusY = currentFocusY;
            requestLayout();
        }
    }
    return true;
}
 

public boolean onScale(ScaleGestureDetector detector) {
	float previousScale = mScale;
	mScale = Math.min(Math.max(mScale * detector.getScaleFactor(), MIN_SCALE), MAX_SCALE);

	{
		float factor = mScale / previousScale;

		View v = mChildViews.get(mCurrent);
		if (v != null) {
			float currentFocusX = detector.getFocusX();
			float currentFocusY = detector.getFocusY();
			// Work out the focus point relative to the view top left
			int viewFocusX = (int)currentFocusX - (v.getLeft() + mXScroll);
			int viewFocusY = (int)currentFocusY - (v.getTop() + mYScroll);
			// Scroll to maintain the focus point
			mXScroll += viewFocusX - viewFocusX * factor;
			mYScroll += viewFocusY - viewFocusY * factor;

			if (mLastScaleFocusX >= 0)
				mXScroll += currentFocusX - mLastScaleFocusX;
			if (mLastScaleFocusY >= 0)
				mYScroll += currentFocusY - mLastScaleFocusY;

			mLastScaleFocusX = currentFocusX;
			mLastScaleFocusY = currentFocusY;
			requestLayout();
		}
	}
	return true;
}
 

public boolean onScale(ScaleGestureDetector detector) {
    LogUtils.d(TAG, "ReaderView onScale　detector.getScaleFactor()＝"+detector.getScaleFactor());
    float previousScale = mScale;
    float scale_factor = 1.0f;
    float min_scale = MIN_SCALE * scale_factor;
    float max_scale = MAX_SCALE * scale_factor;
    mScale = Math.min(Math.max(mScale * detector.getScaleFactor(), min_scale), max_scale);
    mScaleCache.addFirst(detector.getScaleFactor());

    float factor = mScale / previousScale;
    View v = mChildViews.get(mCurrent);
    if (v != null) {
        float currentFocusX = detector.getFocusX();
        float currentFocusY = detector.getFocusY();
        // Work out the focus point relative to the view top left
        int viewFocusX = (int) currentFocusX - (v.getLeft() + mXScroll);
        int viewFocusY = (int) currentFocusY - (v.getTop() + mYScroll);
        LogUtils.d(TAG, "previousScale=" + previousScale + " mScale=" + mScale + " factor=" + factor + " currentFocusX=" + currentFocusX + " currentFocusY=" + currentFocusY
                + " mXScroll=" + mXScroll + " mYScroll=" + mYScroll + " viewFocusX=" + viewFocusX + " viewFocusY=" + viewFocusY + " mLastScaleFocusX=" + mLastScaleFocusX + " mLastScaleFocusY=" + mLastScaleFocusY
        );
        // Scroll to maintain the focus point
        mXScroll += viewFocusX - viewFocusX * factor;
        mYScroll += viewFocusY - viewFocusY * factor;

        if (mLastScaleFocusX >= 0)
            mXScroll += currentFocusX - mLastScaleFocusX;
        if (mLastScaleFocusY >= 0)
            mYScroll += currentFocusY - mLastScaleFocusY;

        mLastScaleFocusX = currentFocusX;
        mLastScaleFocusY = currentFocusY;
        requestLayout();
    }

    return true;
}
 

@Override
@TargetApi(Build.VERSION_CODES.HONEYCOMB)
public boolean onScale(ScaleGestureDetector detector) {
  RectF rect = mCropWindowHandler.getRect();

  float x = detector.getFocusX();
  float y = detector.getFocusY();
  float dY = detector.getCurrentSpanY() / 2;
  float dX = detector.getCurrentSpanX() / 2;

  float newTop = y - dY;
  float newLeft = x - dX;
  float newRight = x + dX;
  float newBottom = y + dY;

  if (newLeft < newRight
      && newTop <= newBottom
      && newLeft >= 0
      && newRight <= mCropWindowHandler.getMaxCropWidth()
      && newTop >= 0
      && newBottom <= mCropWindowHandler.getMaxCropHeight()) {

    rect.set(newLeft, newTop, newRight, newBottom);
    mCropWindowHandler.setRect(rect);
    invalidate();
  }

  return true;
}
 

@Override
public boolean onScaleBegin(ScaleGestureDetector detector) {
    mLastFocusX = detector.getFocusX();
    mLastFocusY = detector.getFocusY();
    return true;
}
 

@Override public boolean onScaleBegin(ScaleGestureDetector detector) {
  scaleFocusX = detector.getFocusX();
  return super.onScaleBegin(detector);
}