Separating cursor and viewport calculations in the desktop canvas

remoting/android/java/src/org/chromium/chromoting/TouchInputHandler.java

 // 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.graphics.Rect;
@@ skipping 309 matching lines @@
                 parameter.hostCapability;
         // We need both input mode and host input capabilities to select the input
         // strategy.
         if (!inputMode.isSet() || !hostTouchCapability.isSet()) {
             return;
         }
 
         switch (inputMode) {
             case TRACKPAD:
                 setInputStrategy(new TrackpadInputStrategy(mRenderData, injector));
+                moveCursorToScreenCenter();
                 break;
 
             case TOUCH:
                 if (hostTouchCapability.isSupported()) {
                     setInputStrategy(new TouchInputStrategy(mRenderData, injector));
                 } else {
                     setInputStrategy(
                             new SimulatedTouchInputStrategy(mRenderData, injector, mContext));
                 }
                 break;
 
             default:
                 // Unreachable, but required by Google Java style and findbugs.
                 assert false : "Unreached";
         }
 
         // Ensure the cursor state is updated appropriately.
         mRenderStub.setCursorVisibility(mRenderData.drawCursor);
     }
 
     private void handleSystemUiVisibilityChanged(
             SystemUiVisibilityChangedEventParameter parameter) {
         if (parameter.systemUiVisible) {
             mDesktopCanvas.setSystemUiOffsetValues(parameter.left, parameter.top,
                     mRenderData.screenWidth - parameter.right,
                     mRenderData.screenHeight - parameter.bottom);
         } else {
             mDesktopCanvas.clearSystemUiOffsets();
         }
-
-        mDesktopCanvas.repositionImage(true);
     }
 
     private boolean handleTouchEvent(MotionEvent event) {
         // Give the underlying input strategy a chance to observe the current motion event before
         // passing it to the gesture detectors.  This allows the input strategy to react to the
         // event or save the payload for use in recreating the gesture remotely.
         mInputStrategy.onMotionEvent(event);
 
         // Avoid short-circuit logic evaluation - ensure all gesture detectors see all events so
         // that they generate correct notifications.
@@ skipping 31 matching lines @@
     }
 
     private void handleHostSizeChanged(int width, int height) {
         mRenderData.imageWidth = width;
         mRenderData.imageHeight = height;
 
         resizeImageToFitScreen();
     }
 
     private void resizeImageToFitScreen() {
+        if (mRenderData.imageWidth == 0 || mRenderData.imageHeight == 0
+                || mRenderData.screenWidth == 0 || mRenderData.screenHeight == 0) {
+            return;
+        }
+
         mDesktopCanvas.resizeImageToFitScreen();
 
+        moveCursorToScreenCenter();
+    }
+
+    private void moveCursorToScreenCenter() {
         float screenCenterX = (float) mRenderData.screenWidth / 2;
         float screenCenterY = (float) mRenderData.screenHeight / 2;
 
         float[] imagePoint = mapScreenPointToImagePoint(screenCenterX, screenCenterY);
-        mDesktopCanvas.setViewportPosition(imagePoint[0], imagePoint[1]);
+        mDesktopCanvas.setCursorPosition(imagePoint[0], imagePoint[1]);
 
         moveCursorToScreenPoint(screenCenterX, screenCenterY);
-        mDesktopCanvas.repositionImage(true);
     }
 
     private void setInputStrategy(InputStrategyInterface inputStrategy) {
         // Since the rules for flinging differ between input modes, we want to stop running the
         // current fling animation when the mode changes to prevent a wonky experience.
         abortAnimation();
         mInputStrategy = inputStrategy;
     }
 
     /** Moves the desired center of the viewport using the specified deltas. */
     private void moveViewportByOffset(float deltaX, float deltaY) {
         // If we are in an indirect mode or are in the middle of a drag operation, then we want to
         // invert the direction of the operation (i.e. follow the motion of the finger).
         boolean followCursor = (mInputStrategy.isIndirectInputMode() || mIsDragging);
         if (followCursor) {
             deltaX = -deltaX;
             deltaY = -deltaY;
         }
+
         // Determine the center point from which to apply the delta.
         // For indirect input modes (i.e. trackpad), the view generally follows the cursor.
         // For direct input modes (i.e. touch) the should track the user's motion.
         // If the user is dragging, then the viewport should always follow the user's finger.
-        PointF newPos = mDesktopCanvas.moveViewportCenter(!followCursor, deltaX, deltaY);
-
-        // If we are in an indirect mode, then we want to keep the cursor centered, if possible, as
-        // the viewport moves.
         if (mInputStrategy.isIndirectInputMode()) {
-            moveCursor(newPos.x, newPos.y);
+            PointF newCursorPos = mDesktopCanvas.moveCursorPosition(deltaX, deltaY);
+            moveCursor(newCursorPos.x, newCursorPos.y);
+        } else {
+            mDesktopCanvas.moveViewportCenter(deltaX, deltaY);
         }
-
-        mDesktopCanvas.repositionImage(true);
     }
 
     /** Moves the cursor to the specified position on the screen. */
     private void moveCursorToScreenPoint(float screenX, float screenY) {
         float[] imagePoint = mapScreenPointToImagePoint(screenX, screenY);
         moveCursor(imagePoint[0], imagePoint[1]);
     }
 
     /** Moves the cursor to the specified position on the remote host. */
     private void moveCursor(float newX, float newY) {
@@ skipping 123 matching lines @@
             return true;
         }
 
         /** Called when the user is in the process of pinch-zooming. */
         @Override
         public boolean onScale(ScaleGestureDetector detector) {
             if (!mSwipePinchDetector.isPinching()) {
                 return false;
             }
 
-            float scaleFactor = detector.getScaleFactor();
-
-            mRenderData.transform.postScale(
-                    scaleFactor, scaleFactor, detector.getFocusX(), detector.getFocusY());
-
-            // For indirect input modes we want to zoom using the cursor as the focal point, for
-            // direct modes we use the actual focal point of the gesture.
-            mDesktopCanvas.repositionImageWithZoom(mInputStrategy.isIndirectInputMode());
+            mDesktopCanvas.scaleAndRepositionImage(detector.getScaleFactor(), detector.getFocusX(),
+                    detector.getFocusY(), mInputStrategy.isIndirectInputMode());
 
             return true;
         }
 
         /** Called whenever a gesture starts. Always accepts the gesture so it isn't ignored. */
         @Override
         public boolean onDown(MotionEvent e) {
             return true;
         }
 
@@ skipping 78 matching lines @@
             float[] mappedPoints = mapScreenPointToImagePoint(screenX, screenY);
 
             float imageWidth = (float) mRenderData.imageWidth + EPSILON;
             float imageHeight = (float) mRenderData.imageHeight + EPSILON;
 
             return mappedPoints[0] < -EPSILON || mappedPoints[0] > imageWidth
                     || mappedPoints[1] < -EPSILON || mappedPoints[1] > imageHeight;
         }
     }
 }