Code example for PointF

Methods: set

0
		pts[0] = point.x;
		pts[1] = point.y;
		invertedMatrix.mapPoints(pts);
		point.x = pts[0];
		point.y = pts[1];
		ObjectRelation.addRelation(this, point);
	} 
 
	/** Map rectangle from model to screen coordinates **/ 
	public void mapRect(RectF rect){
		matrix.mapRect(rect);
		ObjectRelation.addRelation(this, rect);
	} 
	 
	/** Map rectangle from screen to model coordinates **/ 
	public void unmapRect(RectF rect){
		matrix.invert(invertedMatrix);
		invertedMatrix.mapRect(rect);
		ObjectRelation.addRelation(this, rect);
	} 
 
	/** Setup view rect and content size  
	 * @param updateMatrix **/ 
	public void setViewRect(float newContentWidth, float newContentHeight, RectF newDisplayRect){
		contentWidth = newContentWidth;
		contentHeight = newContentHeight;
		if(displayRect!=null){
			matrix.postTranslate((newDisplayRect.width()-displayRect.width())/2, (newDisplayRect.height()-displayRect.height())/2);
		} 
		displayRect = newDisplayRect;
		// calculate zoom bounds 
		maxScale = 2.0f * density;
		minScale = Math.min(displayRect.width()/contentWidth, displayRect.height()/contentHeight);
		adjustScale(); 
		adjustPan(); 
		listener.setPositionAndScaleMatrix(matrix);
		ObjectRelation.addRelation(this, newDisplayRect);
	} 
	 
	public boolean onMultiTouchEvent(MotionEvent rawEvent) {
		ObjectRelation.addRelation(this, rawEvent);
		if(mode == MODE_ANIMATION){
			return false; 
		} 
		MotionEventWrapper event = MotionEventWrapper.create(rawEvent);
		if(!initialized){
			matrix.set(listener.getPositionAndScaleMatrix());
			initialized = true;
		} 
		int action = event.getAction();
		boolean handled = true;
		if(action == MotionEvent.ACTION_DOWN){
			handled = doActionDown(event);
		}else if (action == MotionEventWrapper.ACTION_POINTER_DOWN){
			handled = doActionPointerDown(event);
		}else if(action == MotionEvent.ACTION_UP || action == MotionEventWrapper.ACTION_POINTER_UP){
			handled = doActionUp(event);
		}else if(action == MotionEvent.ACTION_CANCEL ){
			handled = doActionCancel(event);
		}else if(action == MotionEvent.ACTION_MOVE){
			handled = doActionMove(event);
		} 
		listener.setPositionAndScaleMatrix(matrix);
		return handled;
	} 
 
	private boolean doActionDown(MotionEventWrapper event){
		if (!scroller.isFinished()) {
			scroller.abortAnimation();
			setControllerMode(MODE_DRAG_START);
		} else { 
			setControllerMode(MODE_INIT);
		} 
		if (mode == MODE_INIT) {
			privateHandler.sendEmptyMessageDelayed(MSG_SWITCH_TO_SHORTPRESS, ViewConfiguration.getTapTimeout());
		} 
		velocityTracker = VelocityTracker.obtain();
		savedMatrix.set(matrix);
		touchStartPoint.set(event.getX(), event.getY());
		touchStartTime = event.getEventTime();
		ObjectRelation.addRelation(this, event);
		return true; 
	} 
	 
	private boolean doActionPointerDown(MotionEventWrapper event){
		zoomBase = distance(event);
		//Log.d(TAG, "oldDist=" + zoomBase); 
		if (zoomBase > 10f) {
			if (!scroller.isFinished()) {
				scroller.abortAnimation();
			} 
			savedMatrix.set(matrix);
			float x = event.getX(0) + event.getX(1);
			float y = event.getY(0) + event.getY(1);
			zoomCenter.set(x / 2, y / 2);
			setControllerMode( MODE_ZOOM );
		}			 
		ObjectRelation.addRelation(this, event);
		return true; 
	} 
	 
	private boolean doActionMove(MotionEventWrapper event){
		ObjectRelation.addRelation(this, event);
		if (mode == MODE_NONE || mode == MODE_LONGPRESS_START) {
			// no dragging during scroll zoom animation or while long press is not released 
			return false;  
		} else if (mode == MODE_ZOOM) {
			float newDist = distance(event);
			if (newDist > 10f) {
				matrix.set(savedMatrix);
				float scale = newDist / zoomBase;
 
				matrix.getValues(matrixValues);
				float currentScale = matrixValues[Matrix.MSCALE_X];
 
				// limit zoom 
				if (scale * currentScale > maxScale) {
					scale = maxScale / currentScale;
				} else if (scale * currentScale < minScale) {
					scale = minScale / currentScale;
				} 
				matrix.postScale(scale, scale, zoomCenter.x, zoomCenter.y);
				adjustPan(); 
			} 
			return true; 
		} 
		velocityTracker.addMovement(event.getEvent());
 
		if (mode != MODE_DRAG) {
			int deltaX = (int) (touchStartPoint.x - event.getX());
			int deltaY = (int) (touchStartPoint.y - event.getY());
 
			if ((deltaX * deltaX + deltaY * deltaY) < touchSlopSquare) {
				return false; 
			} 
			if (mode == MODE_SHORTPRESS_MODE || mode == MODE_SHORTPRESS_START) {
				privateHandler.removeMessages(MSG_SWITCH_TO_LONGPRESS);
			} else if (mode == MODE_INIT) {
				privateHandler.removeMessages(MSG_SWITCH_TO_SHORTPRESS);
			} 
			setControllerMode(MODE_DRAG);
		} 
		matrix.set(savedMatrix);
		float dx = event.getX() - touchStartPoint.x;
		float dy = event.getY() - touchStartPoint.y;
		matrix.postTranslate(dx, dy);
		adjustPan(); 
		return true; 
	} 
	 
	private boolean doActionUp(MotionEventWrapper event){
		ObjectRelation.addRelation(this, event);
		switch (mode) {
		case MODE_INIT: // tap
		case MODE_SHORTPRESS_START:
		case MODE_SHORTPRESS_MODE:
			privateHandler.removeMessages(MSG_SWITCH_TO_SHORTPRESS);
			privateHandler.removeMessages(MSG_SWITCH_TO_LONGPRESS);
			if (velocityTracker != null) {
				velocityTracker.recycle();
				velocityTracker = null;
			} 
			setControllerMode(MODE_NONE);
			performClick(); 
			return true; 
		case MODE_LONGPRESS_START:
			// do nothing 
			break; 
		case MODE_DRAG:
		case MODE_DRAG_START:
			// if the user waits a while w/o moving before the 
			// up, we don't want to do a fling 
			if ((event.getEventTime() - touchStartTime) <= MIN_FLING_TIME) {
				velocityTracker.addMovement(event.getEvent());
				velocityTracker.computeCurrentVelocity(1000);
				 
				matrix.getValues(matrixValues);
				float currentY = matrixValues[Matrix.MTRANS_Y];
				float currentX = matrixValues[Matrix.MTRANS_X];
				float currentScale = matrixValues[Matrix.MSCALE_X];
				float currentHeight = contentHeight * currentScale;
				float currentWidth = contentWidth * currentScale;
				 
				int vx = (int) -velocityTracker.getXVelocity() / 2;
				int vy = (int) -velocityTracker.getYVelocity() / 2;
				int maxX = (int) Math.max(currentWidth - displayRect.width(), 0);
				int maxY = (int) Math.max(currentHeight - displayRect.height(), 0);
				scroller.fling((int) -currentX, (int) -currentY, vx, vy, 0, maxX, 0, maxY);
				privateHandler.sendEmptyMessage(MSG_PROCESS_FLING);
				break; 
			} 
			break; 
		case MODE_ZOOM:
			// ??? 
		case MODE_NONE:
			// do nothing 
		} 
		if (velocityTracker != null) {
			velocityTracker.recycle();
			velocityTracker = null;
		} 
		setControllerMode(MODE_NONE);
		return true; 
	} 
	 
	private boolean doActionCancel(MotionEventWrapper event){
        privateHandler.removeMessages(MSG_SWITCH_TO_SHORTPRESS);
        privateHandler.removeMessages(MSG_SWITCH_TO_LONGPRESS);
		setControllerMode( MODE_NONE );
		ObjectRelation.addRelation(this, event);
		return true; 
	} 
	 
	/*package*/ void setControllerMode(int newMode){
		boolean fireUpdate = mode != newMode;
		mode = newMode;
		if(fireUpdate){
			listener.onTouchModeChanged(newMode);
		} 
	} 
	 
	public int getControllerMode(){ 
		return mode;
	} 
	 
	/** adjust map position to prevent zoom to outside of map **/ 
	private void adjustScale() { 
		matrix.getValues(matrixValues);
		float currentScale = matrixValues[Matrix.MSCALE_X];
		if(currentScale<minScale){
			matrix.setScale(minScale, minScale);
		} 
	} 
	 
	/** adjust map position to prevent pan to outside of map **/ 
	private void adjustPan(){ 
		matrix.getValues(matrixValues);
		float currentY = matrixValues[Matrix.MTRANS_Y];
		float currentX = matrixValues[Matrix.MTRANS_X];
		float currentScale = matrixValues[Matrix.MSCALE_X];
		float currentHeight = contentHeight * currentScale;
		float currentWidth = contentWidth * currentScale;
		float newX = currentX;
		float newY = currentY;
 
		RectF drawingRect = new RectF(newX, newY, newX + currentWidth,
				newY + currentHeight);
		float diffUp = Math.min(displayRect.bottom - drawingRect.bottom,
				displayRect.top - drawingRect.top);
		float diffDown = Math.max(displayRect.bottom - drawingRect.bottom,
				displayRect.top - drawingRect.top);
		float diffLeft = Math.min(displayRect.left - drawingRect.left,
				displayRect.right - drawingRect.right);
		float diffRight = Math.max(displayRect.left - drawingRect.left,
				displayRect.right - drawingRect.right);
		float dx=0, dy=0;
		if (diffUp > 0) {
			dy += diffUp;
		} 
		if (diffDown < 0) {
			dy += diffDown;
		} 
		if (diffLeft > 0) {
			dx += diffLeft;
		} 
		if (diffRight < 0) {
			dx += diffRight;
		} 
		if(currentWidth<displayRect.width()){
			dx = -currentX + (displayRect.width() - currentWidth)/2;
		} 
		if(currentHeight<displayRect.height()){
			dy = -currentY + (displayRect.height() - currentHeight)/2;
		} 
		matrix.postTranslate(dx, dy);
	} 
	 
	/** Determine the distance between the first two fingers */ 
	private float distance(MotionEventWrapper event) {
		float x = event.getX(0) - event.getX(1);
		float y = event.getY(0) - event.getY(1);
		ObjectRelation.addRelation(this, event);
		return FloatMath.sqrt(x * x + y * y);
	} 
 
	boolean computeScroll() { 
		boolean more = scroller.computeScrollOffset();
		if (more) {
			float x = scroller.getCurrX();
			float y = scroller.getCurrY();
 
			matrix.getValues(matrixValues);
			float currentY = -matrixValues[Matrix.MTRANS_Y];
			float currentX = -matrixValues[Matrix.MTRANS_X];
			float dx = currentX - x;
			float dy = currentY - y;
			 
			matrix.postTranslate(dx, dy);
			adjustPan(); 
			listener.setPositionAndScaleMatrix(matrix);
		} 
		return more;
	} 
	 
	boolean computeAnimation(){ 
		if(mode == MODE_ANIMATION){
			animationInterpolator.next();
			if(animationInterpolator.hasScale()){
				float scale = animationInterpolator.getScale() / getScale();
				matrix.postScale(scale, scale);
			} 
			if(animationInterpolator.hasScroll()){
				PointF newCenter = animationInterpolator.getPoint();
				mapPoint(newCenter);
				float dx = newCenter.x - displayRect.width()/2;
				float dy = newCenter.y - displayRect.height()/2;
				matrix.postTranslate(-dx, -dy);
			} 
			adjustScale(); 
			adjustPan(); 
			listener.setPositionAndScaleMatrix(matrix);
			return animationInterpolator.more();
		} 
		return false; 
	} 
	 
	public PointF getScreenTouchPoint(){
		return new PointF(touchStartPoint.x, touchStartPoint.y);
	} 
	 
	/** Return last touch point in model coordinates **/ 
	public PointF getTouchPoint(){
		PointF p = new PointF();
		p.set(touchStartPoint);
		unmapPoint(p);
		//Log.w(TAG,"point=" + touchStartPoint.x + "," + touchStartPoint.y); 
		return p;
	} 
	 
	public float getScale(){ 
		matrix.getValues(matrixValues);
		return matrixValues[Matrix.MSCALE_X];
	} 
	 
	public float getTouchRadius(){ 
		return touchSlopSquare;
	} 
 
	public float getPositionAndScale(PointF position) {
		matrix.getValues(matrixValues);
		float scale = matrixValues[Matrix.MSCALE_X];
		if(position!=null){
			position.set(-matrixValues[Matrix.MTRANS_X]/scale, -matrixValues[Matrix.MTRANS_Y]/scale);
		} 
		ObjectRelation.addRelation(this, position);
		return scale;
	} 
	 
	public void setPositionAndScale(PointF position, float scale) {
		matrix.setScale(scale, scale);
		matrix.postTranslate(-position.x * scale, -position.y * scale);
		adjustScale(); 
		adjustPan(); 
		listener.setPositionAndScaleMatrix(matrix);
		ObjectRelation.addRelation(this, position);
	} 
 
	public float getMaxScale() { 
		return maxScale;
	} 
    
	public float getMinScale() { 
		return minScale;
	} 
	 
	public void performLongClick() { 
		listener.onPerformLongClick(getTouchPoint());
	} 
 
	public void performClick() { 
		listener.onPerformClick(getTouchPoint());
	}