Implement touch control

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 10 matching lines @@
 Application* Application::Create(int argc, char** argv, void* platformData) {
     return new Viewer(argc, argv, platformData);
 }
 
 static void on_paint_handler(SkCanvas* canvas, void* userData) {
     Viewer* vv = reinterpret_cast<Viewer*>(userData);
 
     return vv->onPaint(canvas);
 }
 
+static bool on_touch_handler(int owner, Window::InputState state, float x, float y, void* userData)
+{
+    Viewer* viewer = reinterpret_cast<Viewer*>(userData);
+
+    return viewer->onTouch(owner, state, x, y);
+}
+
 DEFINE_bool2(fullscreen, f, true, "Run fullscreen.");
 DEFINE_string(key, "", "Space-separated key/value pairs to add to JSON identifying this builder.");
 DEFINE_string2(match, m, nullptr,
                "[~][^]substring[$] [...] of bench name to run.\n"
                "Multiple matches may be separated by spaces.\n"
                "~ causes a matching bench to always be skipped\n"
                "^ requires the start of the bench to match\n"
                "$ requires the end of the bench to match\n"
                "^ and $ requires an exact match\n"
                "If a bench does not match any list entry,\n"
@@ skipping 17 matching lines @@
     SkDebugf("\n");
 
     SkCommandLineFlags::Parse(argc, argv);
 
     fWindow = Window::CreateNativeWindow(platformData);
     fWindow->attach(Window::kVulkan_BackendType, DisplayParams());
 
     // register callbacks
     fCommands.attach(fWindow);
     fWindow->registerPaintFunc(on_paint_handler, this);
+    fWindow->registerTouchFunc(on_touch_handler, this);
 
     // add key-bindings
     fCommands.addCommand('s', "Overlays", "Toggle stats display", [this]() {
         this->fDisplayStats = !this->fDisplayStats;
         fWindow->inval();
     });
     fCommands.addCommand('c', "Modes", "Toggle sRGB color mode", [this]() {
         DisplayParams params = fWindow->getDisplayParams();
         params.fProfileType = (kLinear_SkColorProfileType == params.fProfileType)
             ? kSRGB_SkColorProfileType : kLinear_SkColorProfileType;
@@ skipping 27 matching lines @@
     });
 
     // set up slides
     this->initSlides();
 
     fAnimTimer.run();
 
     // set up first frame
     fCurrentSlide = 0;
     setupCurrentSlide(-1);
-    updateMatrix();
 
     fWindow->show();
 }
 
 void Viewer::initSlides() {
     const skiagm::GMRegistry* gms(skiagm::GMRegistry::Head());
     while (gms) {
         SkAutoTDelete<skiagm::GM> gm(gms->factory()(nullptr));
 
         if (!SkCommandLineFlags::ShouldSkip(FLAGS_match, gm->getName())) {
@@ skipping 72 matching lines @@
     fZoomLevel += delta;
     if (fZoomLevel > 0) {
         fZoomLevel = SkMinScalar(fZoomLevel, MAX_ZOOM_LEVEL);
         fZoomScale = fZoomLevel + SK_Scalar1;
     } else if (fZoomLevel < 0) {
         fZoomLevel = SkMaxScalar(fZoomLevel, MIN_ZOOM_LEVEL);
         fZoomScale = SK_Scalar1 / (SK_Scalar1 - fZoomLevel);
     } else {
         fZoomScale = SK_Scalar1;
     }
-    this->updateMatrix();
 }
 
-void Viewer::updateMatrix(){
+SkMatrix Viewer::computeMatrix() {
     SkMatrix m;
     m.reset();
 
     if (fZoomLevel) {
         SkPoint center;
         //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);
     }
 
-    // TODO: add gesture support
-    // Apply any gesture matrix
-    //m.preConcat(fGesture.localM());
-    //m.preConcat(fGesture.globalM());
+    m.preConcat(fGesture.localM());
+    m.preConcat(fGesture.globalM());
 
-    fLocalMatrix = m;
+    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);
         canvas->concat(matrix);
     }
-    canvas->concat(fLocalMatrix);
+    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);
+    switch (state) {
+        case Window::kUp_InputState: {
+            fGesture.touchEnd(castedOwner);
+            break;
+        }
+        case Window::kDown_InputState: {
+            fGesture.touchBegin(castedOwner, x, y);
+            break;
+        }
+        case Window::kMove_InputState: {
+            fGesture.touchMoved(castedOwner, x, y);
+            break;
+        }
+    }
+    fWindow->inval();
+    return true;
+}
+
 void Viewer::drawStats(SkCanvas* canvas) {
     static const float kPixelPerMS = 2.0f;
     static const int kDisplayWidth = 130;
     static const int kDisplayHeight = 100;
     static const int kDisplayPadding = 10;
     static const int kGraphPadding = 3;
     static const SkScalar kBaseMS = 1000.f / 60.f;  // ms/frame to hit 60 fps
 
     SkISize canvasSize = canvas->getDeviceSize();
     SkRect rect = SkRect::MakeXYWH(SkIntToScalar(canvasSize.fWidth-kDisplayWidth-kDisplayPadding),
@@ skipping 39 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();
     }
 }