Correct gesture scale and translation

tools/viewer/Viewer.cpp

 /*
 * Copyright 2016 Google Inc.
 *
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 */
 
 #include "Viewer.h"
 
 #include "GMSlide.h"
@@ skipping 172 matching lines @@
 void Viewer::updateTitle() {
     SkString title("Viewer: ");
     title.append(fSlides[fCurrentSlide]->getName());
     if (kSRGB_SkColorProfileType == fWindow->getDisplayParams().fProfileType) {
         title.append(" sRGB");
     }
     fWindow->setTitle(title.c_str());
 }
 
 void Viewer::setupCurrentSlide(int previousSlide) {
+    fGesture.reset();
+    fOffsetMatrix.reset();
+    fPreTouchMatrix.reset();
     this->updateTitle();
     fSlides[fCurrentSlide]->load();
     if (previousSlide >= 0) {
         fSlides[previousSlide]->unload();
     }
     fWindow->inval();
 }
 
 #define MAX_ZOOM_LEVEL  8
 #define MIN_ZOOM_LEVEL  -8
@@ skipping 20 matching lines @@
         //m = this->getLocalMatrix();//.invert(&m);
         m.mapXY(fZoomCenterX, fZoomCenterY, &center);
         SkScalar cx = center.fX;
         SkScalar cy = center.fY;
 
         m.setTranslate(-cx, -cy);
         m.postScale(fZoomScale, fZoomScale);
         m.postTranslate(cx, cy);
     }
 
-    m.preConcat(fGesture.localM());
-    m.preConcat(fGesture.globalM());
+    SkMatrix touchMatrixWithOffset;

[djsollen, 2016/05/19 17:04:23]

I think you can do this computation by just applying the gesture matrix to m. 
Then just look at the current scale and translate on the matrix and if it would
cause the content to be scrolled off the screen then just translate it back onto
the screen.

[liyuqian, 2016/05/19 19:23:15]

Done.

+    touchMatrixWithOffset.reset();
+    touchMatrixWithOffset.postConcat(fGesture.globalM());
+    touchMatrixWithOffset.postConcat(fGesture.localM());
+    if (touchMatrixWithOffset.isIdentity()) {
+        // The touch gesture has reset the matrix, so we reset the offset too.
+        fOffsetMatrix.reset();
+    }
+    touchMatrixWithOffset.preConcat(fOffsetMatrix);
+
+    // Begin checking if more offset is needed
+
+    const SkScalar scaleX = touchMatrixWithOffset.getScaleX();
+    const SkScalar scaleY = touchMatrixWithOffset.getScaleY();
+    // Bring the X/Y translation to the slide's scale
+    const SkScalar tX = touchMatrixWithOffset.getTranslateX() / scaleX;
+    const SkScalar tY = touchMatrixWithOffset.getTranslateY() / scaleY;
+
+    const SkISize slideSize = fSlides[fCurrentSlide]->getDimensions();
+    const SkScalar SW = slideSize.width(), SH = slideSize.height(), ZERO = 0;
+
+    // Bring contentRect's widht/height to the slide's scale
+    const SkRect contentRect = fWindow->getContentRect();

[djsollen, 2016/05/19 17:04:23]

on windows that don't return true for supportsContentRect() this will return an
empty rect.

[liyuqian, 2016/05/19 19:23:15]

Done.

+    const SkScalar CW = contentRect.width() / fPreTouchMatrix.getScaleX() / scaleX;
+    const SkScalar CH = contentRect.height() / fPreTouchMatrix.getScaleY() / scaleY;
+
+    // X Translation could be no less than -SW and no more than CW
+    const SkScalar overX = std::min(ZERO, tX + SW) + std::max(ZERO, tX - CW);
+    // Y Translation is similar to the X translation
+    const SkScalar overY = std::min(ZERO, tY + SH) + std::max(ZERO, tY - CH);
+
+    // Apply additional offset
+    fOffsetMatrix.preTranslate(-overX * scaleX, -overY * scaleY);
+    touchMatrixWithOffset.preTranslate(-overX * scaleX, -overY * scaleY);
+
+    // Finished checking offset
+
+    m.preConcat(touchMatrixWithOffset);
 
     return m;
 }
 
 void Viewer::onPaint(SkCanvas* canvas) {
 
     int count = canvas->save();
 
     if (fWindow->supportsContentRect()) {
         SkRect contentRect = fWindow->getContentRect();
         canvas->clipRect(contentRect);
         canvas->translate(contentRect.fLeft, contentRect.fTop);
     }
 
     canvas->clear(SK_ColorWHITE);
     if (fWindow->supportsContentRect() && fWindow->scaleContentToFit()) {
         const SkRect contentRect = fWindow->getContentRect();
         const SkISize slideSize = fSlides[fCurrentSlide]->getDimensions();
         const SkRect slideBounds = SkRect::MakeIWH(slideSize.width(), slideSize.height());
         SkMatrix matrix;
-        matrix.setRectToRect(slideBounds, contentRect, SkMatrix::kCenter_ScaleToFit);
+        matrix.setRectToRect(slideBounds, contentRect, SkMatrix::kStart_ScaleToFit);
         canvas->concat(matrix);
+        fPreTouchMatrix = matrix;
     }
     canvas->concat(computeMatrix());
 
     fSlides[fCurrentSlide]->draw(canvas);
     canvas->restoreToCount(count);
 
     if (fDisplayStats) {
         drawStats(canvas);
     }
     fCommands.drawHelp(canvas);
 }
 
 bool Viewer::onTouch(int owner, Window::InputState state, float x, float y) {
     void* castedOwner = reinterpret_cast<void*>(owner);
+    float castedX = (x - fPreTouchMatrix.getTranslateX()) / fPreTouchMatrix.getScaleX();
+    float castedY = (y - fPreTouchMatrix.getTranslateY()) / fPreTouchMatrix.getScaleY();

[djsollen, 2016/05/19 17:04:23]

SkPoint touchPoint = SkPoint::Make(x, y);
SkMatrix::mapPoints(&touchPoint, 1);

[liyuqian, 2016/05/19 19:23:15]

Done.

     switch (state) {
         case Window::kUp_InputState: {
             fGesture.touchEnd(castedOwner);
             break;
         }
         case Window::kDown_InputState: {
-            fGesture.touchBegin(castedOwner, x, y);
+            fGesture.touchBegin(castedOwner, castedX, castedY);
             break;
         }
         case Window::kMove_InputState: {
-            fGesture.touchMoved(castedOwner, x, y);
+            fGesture.touchMoved(castedOwner, castedX, castedY);
             break;
         }
     }
     fWindow->inval();
     return true;
 }
 
 void Viewer::drawStats(SkCanvas* canvas) {
     static const float kPixelPerMS = 2.0f;
     static const int kDisplayWidth = 130;
@@ skipping 46 matching lines @@
     // Record measurements
     fMeasurements[fCurrentMeasurement++] = ms;
     fCurrentMeasurement &= (kMeasurementCount - 1);  // fast mod
     SkASSERT(fCurrentMeasurement < kMeasurementCount);
 
     fAnimTimer.updateTime();
     if (fSlides[fCurrentSlide]->animate(fAnimTimer) || fDisplayStats) {
         fWindow->inval();
     }
 }