remoting/android/java/src/org/chromium/chromoting/TrackingInputHandler.java - platform/external/chromium_org - Git at Google

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 package org.chromium.chromoting;

 import android.content.Context;
 import android.graphics.Matrix;
 import android.graphics.PointF;
 import android.view.GestureDetector;
 import android.view.MotionEvent;
 import android.view.ScaleGestureDetector;
 import android.widget.Scroller;

 /**
  * This class implements the cursor-tracking behavior and gestures.
  */
 public class TrackingInputHandler implements TouchInputHandler {
     /**
      * Minimum change to the scaling factor to be recognized as a zoom gesture. Setting lower
      * values here will result in more frequent canvas redraws during zooming.
      */
     private static final double MIN_ZOOM_DELTA = 0.05;

     /**
      * Maximum allowed zoom level - see {@link #repositionImageWithZoom()}.
      */
     private static final float MAX_ZOOM_FACTOR = 100.0f;

     private DesktopViewInterface mViewer;
     private RenderData mRenderData;

     private GestureDetector mScroller;
     private ScaleGestureDetector mZoomer;
     private TapGestureDetector mTapDetector;

     /** Used to calculate the physics for flinging the cursor. */
     private Scroller mFlingScroller;

     /** Used to disambiguate a 2-finger gesture as a swipe or a pinch. */
     private SwipePinchDetector mSwipePinchDetector;

     /**
      * The current cursor position is stored here as floats, so that the desktop image can be
      * positioned with sub-pixel accuracy, to give a smoother panning animation at high zoom levels.
      */
     private PointF mCursorPosition;

     /**
      * Used for tracking swipe gestures. Only the Y-direction is needed for responding to swipe-up
      * or swipe-down.
      */
     private float mTotalMotionY = 0;

     /**
      * Distance in pixels beyond which a motion gesture is considered to be a swipe. This is
      * initialized using the Context passed into the ctor.
      */
     private float mSwipeThreshold;

     /** Mouse-button currently held down, or BUTTON_UNDEFINED otherwise. */
     private int mHeldButton = BUTTON_UNDEFINED;

     /**
      * Set to true to prevent any further movement of the cursor, for example, when showing the
      * keyboard to prevent the cursor wandering from the area where keystrokes should be sent.
      */
     private boolean mSuppressCursorMovement = false;

     /**
      * Set to true to suppress the fling animation at the end of a gesture, for example, when
      * dragging whilst a button is held down.
      */
     private boolean mSuppressFling = false;

     /**
      * Set to true when 3-finger swipe gesture is complete, so that further movement doesn't
      * trigger more swipe actions.
      */
     private boolean mSwipeCompleted = false;

     public TrackingInputHandler(DesktopViewInterface viewer, Context context,
                                 RenderData renderData) {
         mViewer = viewer;
         mRenderData = renderData;

         GestureListener listener = new GestureListener();
         mScroller = new GestureDetector(context, listener, null, false);

         // If long-press is enabled, the gesture-detector will not emit any further onScroll
         // notifications after the onLongPress notification. Since onScroll is being used for
         // moving the cursor, it means that the cursor would become stuck if the finger were held
         // down too long.
         mScroller.setIsLongpressEnabled(false);

         mZoomer = new ScaleGestureDetector(context, listener);
         mTapDetector = new TapGestureDetector(context, listener);
         mFlingScroller = new Scroller(context);
         mSwipePinchDetector = new SwipePinchDetector(context);

         mCursorPosition = new PointF();

         // The threshold needs to be bigger than the ScaledTouchSlop used by the gesture-detectors,
         // so that a gesture cannot be both a tap and a swipe. It also needs to be small enough so
         // that intentional swipes are usually detected.
         float density = context.getResources().getDisplayMetrics().density;
         mSwipeThreshold = 40 * density;
     }

     /**
      * Moves the mouse-cursor, injects a mouse-move event and repositions the image.
      */
     private void moveCursor(float newX, float newY) {
         synchronized (mRenderData) {
             // Constrain cursor to the image area.
             if (newX < 0) newX = 0;
             if (newY < 0) newY = 0;
             if (newX > mRenderData.imageWidth) newX = mRenderData.imageWidth;
             if (newY > mRenderData.imageHeight) newY = mRenderData.imageHeight;
             mCursorPosition.set(newX, newY);
             repositionImage();
         }

         mViewer.injectMouseEvent((int)newX, (int)newY, BUTTON_UNDEFINED, false);
     }

     /**
      * Repositions the image by translating it (without affecting the zoom level) to place the
      * cursor close to the center of the screen.
      */
     private void repositionImage() {
         synchronized (mRenderData) {
             // Get the current cursor position in screen coordinates.
             float[] cursorScreen = {mCursorPosition.x, mCursorPosition.y};
             mRenderData.transform.mapPoints(cursorScreen);

             // Translate so the cursor is displayed in the middle of the screen.
             mRenderData.transform.postTranslate(
                     (float)mRenderData.screenWidth / 2 - cursorScreen[0],
                     (float)mRenderData.screenHeight / 2 - cursorScreen[1]);

             // Now the cursor is displayed in the middle of the screen, see if the image can be
             // panned so that more of it is visible. The primary goal is to show as much of the
             // image as possible. The secondary goal is to keep the cursor in the middle.

             // Get the coordinates of the desktop rectangle (top-left/bottom-right corners) in
             // screen coordinates. Order is: left, top, right, bottom.
             float[] rectScreen = {0, 0, mRenderData.imageWidth, mRenderData.imageHeight};
             mRenderData.transform.mapPoints(rectScreen);

             float leftDelta = rectScreen[0];
             float rightDelta = rectScreen[2] - mRenderData.screenWidth;
             float topDelta = rectScreen[1];
             float bottomDelta = rectScreen[3] - mRenderData.screenHeight;
             float xAdjust = 0;
             float yAdjust = 0;

             if (rectScreen[2] - rectScreen[0] < mRenderData.screenWidth) {
                 // Image is narrower than the screen, so center it.
                 xAdjust = -(rightDelta + leftDelta) / 2;
             } else if (leftDelta > 0 && rightDelta > 0) {
                 // Panning the image left will show more of it.
                 xAdjust = -Math.min(leftDelta, rightDelta);
             } else if (leftDelta < 0 && rightDelta < 0) {
                 // Pan the image right.
                 xAdjust = Math.min(-leftDelta, -rightDelta);
             }

             // Apply similar logic for yAdjust.
             if (rectScreen[3] - rectScreen[1] < mRenderData.screenHeight) {
                 yAdjust = -(bottomDelta + topDelta) / 2;
             } else if (topDelta > 0 && bottomDelta > 0) {
                 yAdjust = -Math.min(topDelta, bottomDelta);
             } else if (topDelta < 0 && bottomDelta < 0) {
                 yAdjust = Math.min(-topDelta, -bottomDelta);
             }

             mRenderData.transform.postTranslate(xAdjust, yAdjust);
         }
         mViewer.transformationChanged();
     }

     /**
      * Repositions the image by translating and zooming it, to keep the zoom level within sensible
      * limits. The minimum zoom level is chosen to avoid black space around all 4 sides. The
      * maximum zoom level is set arbitrarily, so that the user can zoom out again in a reasonable
      * time, and to prevent arithmetic overflow problems from displaying the image.
      */
     private void repositionImageWithZoom() {
         synchronized (mRenderData) {
             // Avoid division by zero in case this gets called before the image size is initialized.
             if (mRenderData.imageWidth == 0 || mRenderData.imageHeight == 0) {
                 return;
             }

             // Zoom out if the zoom level is too high.
             float currentZoomLevel = mRenderData.transform.mapRadius(1.0f);
             if (currentZoomLevel > MAX_ZOOM_FACTOR) {
                 mRenderData.transform.setScale(MAX_ZOOM_FACTOR, MAX_ZOOM_FACTOR);
             }

             // Get image size scaled to screen coordinates.
             float[] imageSize = {(float)mRenderData.imageWidth, (float)mRenderData.imageHeight};
             mRenderData.transform.mapVectors(imageSize);

             if (imageSize[0] < mRenderData.screenWidth && imageSize[1] < mRenderData.screenHeight) {
                 // Displayed image is too small in both directions, so apply the minimum zoom
                 // level needed to fit either the width or height.
                 float scale = Math.min((float)mRenderData.screenWidth / mRenderData.imageWidth,
                                        (float)mRenderData.screenHeight / mRenderData.imageHeight);
                 mRenderData.transform.setScale(scale, scale);
             }

             repositionImage();
         }
     }

     /** Injects a button event using the current cursor location. */
     private void injectButtonEvent(int button, boolean pressed) {
         mViewer.injectMouseEvent((int)mCursorPosition.x, (int)mCursorPosition.y, button, pressed);
     }

     /** Processes a (multi-finger) swipe gesture. */
     private boolean onSwipe() {
         if (mTotalMotionY > mSwipeThreshold) {
             // Swipe down occurred.
             mViewer.showActionBar();
         } else if (mTotalMotionY < -mSwipeThreshold) {
             // Swipe up occurred.
             mViewer.showKeyboard();
         } else {
             return false;
         }

         mSuppressCursorMovement = true;
         mSuppressFling = true;
         mSwipeCompleted = true;
         return true;
     }

     /** Injects a button-up event if the button is currently held down (during a drag event). */
     private void releaseAnyHeldButton() {
         if (mHeldButton != BUTTON_UNDEFINED) {
             injectButtonEvent(mHeldButton, false);
             mHeldButton = BUTTON_UNDEFINED;
         }
     }

     @Override
     public boolean onTouchEvent(MotionEvent event) {
         // Avoid short-circuit logic evaluation - ensure all gesture detectors see all events so
         // that they generate correct notifications.
         boolean handled = mScroller.onTouchEvent(event);
         handled |= mZoomer.onTouchEvent(event);
         handled |= mTapDetector.onTouchEvent(event);
         mSwipePinchDetector.onTouchEvent(event);

         switch (event.getActionMasked()) {
             case MotionEvent.ACTION_DOWN:
                 mViewer.setAnimationEnabled(false);
                 mSuppressCursorMovement = false;
                 mSuppressFling = false;
                 mSwipeCompleted = false;
                 break;

             case MotionEvent.ACTION_POINTER_DOWN:
                 mTotalMotionY = 0;
                 break;

             case MotionEvent.ACTION_UP:
                 releaseAnyHeldButton();
                 break;

             default:
                 break;
         }
         return handled;
     }

     @Override
     public void onScreenConfigurationChanged() {
     }

     @Override
     public void onClientSizeChanged(int width, int height) {
         repositionImageWithZoom();
     }

     @Override
     public void onHostSizeChanged(int width, int height) {
         moveCursor((float)width / 2, (float)height / 2);
         repositionImageWithZoom();
     }

     @Override
     public void processAnimation() {
         int previousX = mFlingScroller.getCurrX();
         int previousY = mFlingScroller.getCurrY();
         if (!mFlingScroller.computeScrollOffset()) {
             mViewer.setAnimationEnabled(false);
             return;
         }
         int deltaX = mFlingScroller.getCurrX() - previousX;
         int deltaY = mFlingScroller.getCurrY() - previousY;
         float delta[] = {(float)deltaX, (float)deltaY};
         synchronized (mRenderData) {
             Matrix canvasToImage = new Matrix();
             mRenderData.transform.invert(canvasToImage);
             canvasToImage.mapVectors(delta);
         }

         moveCursor(mCursorPosition.x + delta[0], mCursorPosition.y + delta[1]);
     }

     /** Responds to touch events filtered by the gesture detectors. */
     private class GestureListener extends GestureDetector.SimpleOnGestureListener
             implements ScaleGestureDetector.OnScaleGestureListener,
                        TapGestureDetector.OnTapListener {
         /**
          * Called when the user drags one or more fingers across the touchscreen.
          */
         @Override
         public boolean onScroll(MotionEvent e1, MotionEvent e2, float distanceX, float distanceY) {
             int pointerCount = e2.getPointerCount();
             if (pointerCount == 3 && !mSwipeCompleted) {
                 // Note that distance values are reversed. For example, dragging a finger in the
                 // direction of increasing Y coordinate (downwards) results in distanceY being
                 // negative.
                 mTotalMotionY -= distanceY;
                 return onSwipe();
             }

             if (pointerCount == 2 && mSwipePinchDetector.isSwiping()) {
                 mViewer.injectMouseWheelDeltaEvent(-(int)distanceX, -(int)distanceY);

                 // Prevent the cursor being moved or flung by the gesture.
                 mSuppressCursorMovement = true;
                 return true;
             }

             if (pointerCount != 1 || mSuppressCursorMovement) {
                 return false;
             }

             float[] delta = {distanceX, distanceY};
             synchronized (mRenderData) {
                 Matrix canvasToImage = new Matrix();
                 mRenderData.transform.invert(canvasToImage);
                 canvasToImage.mapVectors(delta);
             }

             moveCursor(mCursorPosition.x - delta[0], mCursorPosition.y - delta[1]);
             return true;
         }

         /**
          * Called when a fling gesture is recognized.
          */
         @Override
         public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY) {
             // If cursor movement is suppressed, fling also needs to be suppressed, as the
             // gesture-detector will still generate onFling() notifications based on movement of
             // the fingers, which would result in unwanted cursor movement.
             if (mSuppressCursorMovement || mSuppressFling) {
                 return false;
             }

             // The fling physics calculation is based on screen coordinates, so that it will
             // behave consistently at different zoom levels (and will work nicely at high zoom
             // levels, since |mFlingScroller| outputs integer coordinates). However, the desktop
             // will usually be panned as the cursor is moved across the desktop, which means the
             // transformation mapping from screen to desktop coordinates will change. To deal with
             // this, the cursor movement is computed from relative coordinate changes from
             // |mFlingScroller|. This means the fling can be started at (0, 0) with no bounding
             // constraints - the cursor is already constrained by the desktop size.
             mFlingScroller.fling(0, 0, (int)velocityX, (int)velocityY, Integer.MIN_VALUE,
                     Integer.MAX_VALUE, Integer.MIN_VALUE, Integer.MAX_VALUE);
             // Initialize the scroller's current offset coordinates, since they are used for
             // calculating the delta values.
             mFlingScroller.computeScrollOffset();
             mViewer.setAnimationEnabled(true);
             return true;
         }

         /** Called when the user is in the process of pinch-zooming. */
         @Override
         public boolean onScale(ScaleGestureDetector detector) {
             if (!mSwipePinchDetector.isPinching()) {
                 return false;
             }

             if (Math.abs(detector.getScaleFactor() - 1) < MIN_ZOOM_DELTA) {
                 return false;
             }

             float scaleFactor = detector.getScaleFactor();
             synchronized (mRenderData) {
                 mRenderData.transform.postScale(
                         scaleFactor, scaleFactor, detector.getFocusX(), detector.getFocusY());
             }
             repositionImageWithZoom();
             return true;
         }

         /** Called whenever a gesture starts. Always accepts the gesture so it isn't ignored. */
         @Override
         public boolean onDown(MotionEvent e) {
             return true;
         }

         /**
          * Called when the user starts to zoom. Always accepts the zoom so that
          * onScale() can decide whether to respond to it.
          */
         @Override
         public boolean onScaleBegin(ScaleGestureDetector detector) {
             return true;
         }

         /** Called when the user is done zooming. Defers to onScale()'s judgement. */
         @Override
         public void onScaleEnd(ScaleGestureDetector detector) {
             onScale(detector);
         }

         /** Maps the number of fingers in a tap or long-press gesture to a mouse-button. */
         private int mouseButtonFromPointerCount(int pointerCount) {
             switch (pointerCount) {
                 case 1:
                     return BUTTON_LEFT;
                 case 2:
                     return BUTTON_RIGHT;
                 case 3:
                     return BUTTON_MIDDLE;
                 default:
                     return BUTTON_UNDEFINED;
             }
         }

         /** Called when the user taps the screen with one or more fingers. */
         @Override
         public boolean onTap(int pointerCount) {
             int button = mouseButtonFromPointerCount(pointerCount);
             if (button == BUTTON_UNDEFINED) {
                 return false;
             } else {
                 injectButtonEvent(button, true);
                 injectButtonEvent(button, false);
                 return true;
             }
         }

         /** Called when a long-press is triggered for one or more fingers. */
         @Override
         public void onLongPress(int pointerCount) {
             mHeldButton = mouseButtonFromPointerCount(pointerCount);
             if (mHeldButton != BUTTON_UNDEFINED) {
                 injectButtonEvent(mHeldButton, true);
                 mViewer.showLongPressFeedback();
                 mSuppressFling = true;
             }
         }
     }
 }
	// Copyright 2013 The Chromium Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	package org.chromium.chromoting;

	import android.content.Context;
	import android.graphics.Matrix;
	import android.graphics.PointF;
	import android.view.GestureDetector;
	import android.view.MotionEvent;
	import android.view.ScaleGestureDetector;
	import android.widget.Scroller;

	/**
	* This class implements the cursor-tracking behavior and gestures.
	*/
	public class TrackingInputHandler implements TouchInputHandler {
	/**
	* Minimum change to the scaling factor to be recognized as a zoom gesture. Setting lower
	* values here will result in more frequent canvas redraws during zooming.
	*/
	private static final double MIN_ZOOM_DELTA = 0.05;

	/**
	* Maximum allowed zoom level - see {@link #repositionImageWithZoom()}.
	*/
	private static final float MAX_ZOOM_FACTOR = 100.0f;

	private DesktopViewInterface mViewer;
	private RenderData mRenderData;

	private GestureDetector mScroller;
	private ScaleGestureDetector mZoomer;
	private TapGestureDetector mTapDetector;

	/** Used to calculate the physics for flinging the cursor. */
	private Scroller mFlingScroller;

	/** Used to disambiguate a 2-finger gesture as a swipe or a pinch. */
	private SwipePinchDetector mSwipePinchDetector;

	/**
	* The current cursor position is stored here as floats, so that the desktop image can be
	* positioned with sub-pixel accuracy, to give a smoother panning animation at high zoom levels.
	*/
	private PointF mCursorPosition;

	/**
	* Used for tracking swipe gestures. Only the Y-direction is needed for responding to swipe-up
	* or swipe-down.
	*/
	private float mTotalMotionY = 0;

	/**
	* Distance in pixels beyond which a motion gesture is considered to be a swipe. This is
	* initialized using the Context passed into the ctor.
	*/
	private float mSwipeThreshold;

	/** Mouse-button currently held down, or BUTTON_UNDEFINED otherwise. */
	private int mHeldButton = BUTTON_UNDEFINED;

	/**
	* Set to true to prevent any further movement of the cursor, for example, when showing the
	* keyboard to prevent the cursor wandering from the area where keystrokes should be sent.
	*/
	private boolean mSuppressCursorMovement = false;

	/**
	* Set to true to suppress the fling animation at the end of a gesture, for example, when
	* dragging whilst a button is held down.
	*/
	private boolean mSuppressFling = false;

	/**
	* Set to true when 3-finger swipe gesture is complete, so that further movement doesn't
	* trigger more swipe actions.
	*/
	private boolean mSwipeCompleted = false;

	public TrackingInputHandler(DesktopViewInterface viewer, Context context,
	RenderData renderData) {
	mViewer = viewer;
	mRenderData = renderData;

	GestureListener listener = new GestureListener();
	mScroller = new GestureDetector(context, listener, null, false);

	// If long-press is enabled, the gesture-detector will not emit any further onScroll
	// notifications after the onLongPress notification. Since onScroll is being used for
	// moving the cursor, it means that the cursor would become stuck if the finger were held
	// down too long.
	mScroller.setIsLongpressEnabled(false);

	mZoomer = new ScaleGestureDetector(context, listener);
	mTapDetector = new TapGestureDetector(context, listener);
	mFlingScroller = new Scroller(context);
	mSwipePinchDetector = new SwipePinchDetector(context);

	mCursorPosition = new PointF();

	// The threshold needs to be bigger than the ScaledTouchSlop used by the gesture-detectors,
	// so that a gesture cannot be both a tap and a swipe. It also needs to be small enough so
	// that intentional swipes are usually detected.
	float density = context.getResources().getDisplayMetrics().density;
	mSwipeThreshold = 40 * density;
	}

	/**
	* Moves the mouse-cursor, injects a mouse-move event and repositions the image.
	*/
	private void moveCursor(float newX, float newY) {
	synchronized (mRenderData) {
	// Constrain cursor to the image area.
	if (newX < 0) newX = 0;
	if (newY < 0) newY = 0;
	if (newX > mRenderData.imageWidth) newX = mRenderData.imageWidth;
	if (newY > mRenderData.imageHeight) newY = mRenderData.imageHeight;
	mCursorPosition.set(newX, newY);
	repositionImage();
	}

	mViewer.injectMouseEvent((int)newX, (int)newY, BUTTON_UNDEFINED, false);
	}

	/**
	* Repositions the image by translating it (without affecting the zoom level) to place the
	* cursor close to the center of the screen.
	*/
	private void repositionImage() {
	synchronized (mRenderData) {
	// Get the current cursor position in screen coordinates.
	float[] cursorScreen = {mCursorPosition.x, mCursorPosition.y};
	mRenderData.transform.mapPoints(cursorScreen);

	// Translate so the cursor is displayed in the middle of the screen.
	mRenderData.transform.postTranslate(
	(float)mRenderData.screenWidth / 2 - cursorScreen[0],
	(float)mRenderData.screenHeight / 2 - cursorScreen[1]);

	// Now the cursor is displayed in the middle of the screen, see if the image can be
	// panned so that more of it is visible. The primary goal is to show as much of the
	// image as possible. The secondary goal is to keep the cursor in the middle.

	// Get the coordinates of the desktop rectangle (top-left/bottom-right corners) in
	// screen coordinates. Order is: left, top, right, bottom.
	float[] rectScreen = {0, 0, mRenderData.imageWidth, mRenderData.imageHeight};
	mRenderData.transform.mapPoints(rectScreen);

	float leftDelta = rectScreen[0];
	float rightDelta = rectScreen[2] - mRenderData.screenWidth;
	float topDelta = rectScreen[1];
	float bottomDelta = rectScreen[3] - mRenderData.screenHeight;
	float xAdjust = 0;
	float yAdjust = 0;

	if (rectScreen[2] - rectScreen[0] < mRenderData.screenWidth) {
	// Image is narrower than the screen, so center it.
	xAdjust = -(rightDelta + leftDelta) / 2;
	} else if (leftDelta > 0 && rightDelta > 0) {
	// Panning the image left will show more of it.
	xAdjust = -Math.min(leftDelta, rightDelta);
	} else if (leftDelta < 0 && rightDelta < 0) {
	// Pan the image right.
	xAdjust = Math.min(-leftDelta, -rightDelta);
	}

	// Apply similar logic for yAdjust.
	if (rectScreen[3] - rectScreen[1] < mRenderData.screenHeight) {
	yAdjust = -(bottomDelta + topDelta) / 2;
	} else if (topDelta > 0 && bottomDelta > 0) {
	yAdjust = -Math.min(topDelta, bottomDelta);
	} else if (topDelta < 0 && bottomDelta < 0) {
	yAdjust = Math.min(-topDelta, -bottomDelta);
	}

	mRenderData.transform.postTranslate(xAdjust, yAdjust);
	}
	mViewer.transformationChanged();
	}

	/**
	* Repositions the image by translating and zooming it, to keep the zoom level within sensible
	* limits. The minimum zoom level is chosen to avoid black space around all 4 sides. The
	* maximum zoom level is set arbitrarily, so that the user can zoom out again in a reasonable
	* time, and to prevent arithmetic overflow problems from displaying the image.
	*/
	private void repositionImageWithZoom() {
	synchronized (mRenderData) {
	// Avoid division by zero in case this gets called before the image size is initialized.
	if (mRenderData.imageWidth == 0 \|\| mRenderData.imageHeight == 0) {
	return;
	}

	// Zoom out if the zoom level is too high.
	float currentZoomLevel = mRenderData.transform.mapRadius(1.0f);
	if (currentZoomLevel > MAX_ZOOM_FACTOR) {
	mRenderData.transform.setScale(MAX_ZOOM_FACTOR, MAX_ZOOM_FACTOR);
	}

	// Get image size scaled to screen coordinates.
	float[] imageSize = {(float)mRenderData.imageWidth, (float)mRenderData.imageHeight};
	mRenderData.transform.mapVectors(imageSize);

	if (imageSize[0] < mRenderData.screenWidth && imageSize[1] < mRenderData.screenHeight) {
	// Displayed image is too small in both directions, so apply the minimum zoom
	// level needed to fit either the width or height.
	float scale = Math.min((float)mRenderData.screenWidth / mRenderData.imageWidth,
	(float)mRenderData.screenHeight / mRenderData.imageHeight);
	mRenderData.transform.setScale(scale, scale);
	}

	repositionImage();
	}
	}

	/** Injects a button event using the current cursor location. */
	private void injectButtonEvent(int button, boolean pressed) {
	mViewer.injectMouseEvent((int)mCursorPosition.x, (int)mCursorPosition.y, button, pressed);
	}

	/** Processes a (multi-finger) swipe gesture. */
	private boolean onSwipe() {
	if (mTotalMotionY > mSwipeThreshold) {
	// Swipe down occurred.
	mViewer.showActionBar();
	} else if (mTotalMotionY < -mSwipeThreshold) {
	// Swipe up occurred.
	mViewer.showKeyboard();
	} else {
	return false;
	}

	mSuppressCursorMovement = true;
	mSuppressFling = true;
	mSwipeCompleted = true;
	return true;
	}

	/** Injects a button-up event if the button is currently held down (during a drag event). */
	private void releaseAnyHeldButton() {
	if (mHeldButton != BUTTON_UNDEFINED) {
	injectButtonEvent(mHeldButton, false);
	mHeldButton = BUTTON_UNDEFINED;
	}
	}

	@Override
	public boolean onTouchEvent(MotionEvent event) {
	// Avoid short-circuit logic evaluation - ensure all gesture detectors see all events so
	// that they generate correct notifications.
	boolean handled = mScroller.onTouchEvent(event);
	handled \|= mZoomer.onTouchEvent(event);
	handled \|= mTapDetector.onTouchEvent(event);
	mSwipePinchDetector.onTouchEvent(event);

	switch (event.getActionMasked()) {
	case MotionEvent.ACTION_DOWN:
	mViewer.setAnimationEnabled(false);
	mSuppressCursorMovement = false;
	mSuppressFling = false;
	mSwipeCompleted = false;
	break;

	case MotionEvent.ACTION_POINTER_DOWN:
	mTotalMotionY = 0;
	break;

	case MotionEvent.ACTION_UP:
	releaseAnyHeldButton();
	break;

	default:
	break;
	}
	return handled;
	}

	@Override
	public void onScreenConfigurationChanged() {
	}

	@Override
	public void onClientSizeChanged(int width, int height) {
	repositionImageWithZoom();
	}

	@Override
	public void onHostSizeChanged(int width, int height) {
	moveCursor((float)width / 2, (float)height / 2);
	repositionImageWithZoom();
	}

	@Override
	public void processAnimation() {
	int previousX = mFlingScroller.getCurrX();
	int previousY = mFlingScroller.getCurrY();
	if (!mFlingScroller.computeScrollOffset()) {
	mViewer.setAnimationEnabled(false);
	return;
	}
	int deltaX = mFlingScroller.getCurrX() - previousX;
	int deltaY = mFlingScroller.getCurrY() - previousY;
	float delta[] = {(float)deltaX, (float)deltaY};
	synchronized (mRenderData) {
	Matrix canvasToImage = new Matrix();
	mRenderData.transform.invert(canvasToImage);
	canvasToImage.mapVectors(delta);
	}

	moveCursor(mCursorPosition.x + delta[0], mCursorPosition.y + delta[1]);
	}

	/** Responds to touch events filtered by the gesture detectors. */
	private class GestureListener extends GestureDetector.SimpleOnGestureListener
	implements ScaleGestureDetector.OnScaleGestureListener,
	TapGestureDetector.OnTapListener {
	/**
	* Called when the user drags one or more fingers across the touchscreen.
	*/
	@Override
	public boolean onScroll(MotionEvent e1, MotionEvent e2, float distanceX, float distanceY) {
	int pointerCount = e2.getPointerCount();
	if (pointerCount == 3 && !mSwipeCompleted) {
	// Note that distance values are reversed. For example, dragging a finger in the
	// direction of increasing Y coordinate (downwards) results in distanceY being
	// negative.
	mTotalMotionY -= distanceY;
	return onSwipe();
	}

	if (pointerCount == 2 && mSwipePinchDetector.isSwiping()) {
	mViewer.injectMouseWheelDeltaEvent(-(int)distanceX, -(int)distanceY);

	// Prevent the cursor being moved or flung by the gesture.
	mSuppressCursorMovement = true;
	return true;
	}

	if (pointerCount != 1 \|\| mSuppressCursorMovement) {
	return false;
	}

	float[] delta = {distanceX, distanceY};
	synchronized (mRenderData) {
	Matrix canvasToImage = new Matrix();
	mRenderData.transform.invert(canvasToImage);
	canvasToImage.mapVectors(delta);
	}

	moveCursor(mCursorPosition.x - delta[0], mCursorPosition.y - delta[1]);
	return true;
	}

	/**
	* Called when a fling gesture is recognized.
	*/
	@Override
	public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY) {
	// If cursor movement is suppressed, fling also needs to be suppressed, as the
	// gesture-detector will still generate onFling() notifications based on movement of
	// the fingers, which would result in unwanted cursor movement.
	if (mSuppressCursorMovement \|\| mSuppressFling) {
	return false;
	}

	// The fling physics calculation is based on screen coordinates, so that it will
	// behave consistently at different zoom levels (and will work nicely at high zoom
	// levels, since \|mFlingScroller\| outputs integer coordinates). However, the desktop
	// will usually be panned as the cursor is moved across the desktop, which means the
	// transformation mapping from screen to desktop coordinates will change. To deal with
	// this, the cursor movement is computed from relative coordinate changes from
	// \|mFlingScroller\|. This means the fling can be started at (0, 0) with no bounding
	// constraints - the cursor is already constrained by the desktop size.
	mFlingScroller.fling(0, 0, (int)velocityX, (int)velocityY, Integer.MIN_VALUE,
	Integer.MAX_VALUE, Integer.MIN_VALUE, Integer.MAX_VALUE);
	// Initialize the scroller's current offset coordinates, since they are used for
	// calculating the delta values.
	mFlingScroller.computeScrollOffset();
	mViewer.setAnimationEnabled(true);
	return true;
	}

	/** Called when the user is in the process of pinch-zooming. */
	@Override
	public boolean onScale(ScaleGestureDetector detector) {
	if (!mSwipePinchDetector.isPinching()) {
	return false;
	}

	if (Math.abs(detector.getScaleFactor() - 1) < MIN_ZOOM_DELTA) {
	return false;
	}

	float scaleFactor = detector.getScaleFactor();
	synchronized (mRenderData) {
	mRenderData.transform.postScale(
	scaleFactor, scaleFactor, detector.getFocusX(), detector.getFocusY());
	}
	repositionImageWithZoom();
	return true;
	}

	/** Called whenever a gesture starts. Always accepts the gesture so it isn't ignored. */
	@Override
	public boolean onDown(MotionEvent e) {
	return true;
	}

	/**
	* Called when the user starts to zoom. Always accepts the zoom so that
	* onScale() can decide whether to respond to it.
	*/
	@Override
	public boolean onScaleBegin(ScaleGestureDetector detector) {
	return true;
	}

	/** Called when the user is done zooming. Defers to onScale()'s judgement. */
	@Override
	public void onScaleEnd(ScaleGestureDetector detector) {
	onScale(detector);
	}

	/** Maps the number of fingers in a tap or long-press gesture to a mouse-button. */
	private int mouseButtonFromPointerCount(int pointerCount) {
	switch (pointerCount) {
	case 1:
	return BUTTON_LEFT;
	case 2:
	return BUTTON_RIGHT;
	case 3:
	return BUTTON_MIDDLE;
	default:
	return BUTTON_UNDEFINED;
	}
	}

	/** Called when the user taps the screen with one or more fingers. */
	@Override
	public boolean onTap(int pointerCount) {
	int button = mouseButtonFromPointerCount(pointerCount);
	if (button == BUTTON_UNDEFINED) {
	return false;
	} else {
	injectButtonEvent(button, true);
	injectButtonEvent(button, false);
	return true;
	}
	}

	/** Called when a long-press is triggered for one or more fingers. */
	@Override
	public void onLongPress(int pointerCount) {
	mHeldButton = mouseButtonFromPointerCount(pointerCount);
	if (mHeldButton != BUTTON_UNDEFINED) {
	injectButtonEvent(mHeldButton, true);
	mViewer.showLongPressFeedback();
	mSuppressFling = true;
	}
	}
	}
	}