submodule/skia/tools/viewer/TouchGesture.cpp

   1 /*
   2  * Copyright 2010 Google Inc.
   3  *
   4  * Use of this source code is governed by a BSD-style license that can be
   5  * found in the LICENSE file.
   6  */
   7
   8 #include <algorithm>
   9
  10 #include "include/core/SkMatrix.h"
  11 #include "include/core/SkTime.h"
  12 #include "tools/viewer/TouchGesture.h"
  13
  14 #define DISCRETIZE_TRANSLATE_TO_AVOID_FLICKER   true
  15
  16 static const SkScalar MAX_FLING_SPEED = SkIntToScalar(1500);
  17
  18 static SkScalar pin_max_fling(SkScalar speed) {
  19     if (speed > MAX_FLING_SPEED) {
  20         speed = MAX_FLING_SPEED;
  21     }
  22     return speed;
  23 }
  24
  25 static double getseconds() {
  26     return SkTime::GetMSecs() * 0.001;
  27 }
  28
  29 // returns +1 or -1, depending on the sign of x
  30 // returns +1 if z is zero
  31 static SkScalar SkScalarSignNonZero(SkScalar x) {
  32     SkScalar sign = SK_Scalar1;
  33     if (x < 0) {
  34         sign = -sign;
  35     }
  36     return sign;
  37 }
  38
  39 static void unit_axis_align(SkVector* unit) {
  40     const SkScalar TOLERANCE = SkDoubleToScalar(0.15);
  41     if (SkScalarAbs(unit->fX) < TOLERANCE) {
  42         unit->fX = 0;
  43         unit->fY = SkScalarSignNonZero(unit->fY);
  44     } else if (SkScalarAbs(unit->fY) < TOLERANCE) {
  45         unit->fX = SkScalarSignNonZero(unit->fX);
  46         unit->fY = 0;
  47     }
  48 }
  49
  50 void TouchGesture::FlingState::reset(float sx, float sy) {
  51     fActive = true;
  52     fDirection.set(sx, sy);
  53     fSpeed0 = SkPoint::Normalize(&fDirection);
  54     fSpeed0 = pin_max_fling(fSpeed0);
  55     fTime0 = getseconds();
  56
  57     unit_axis_align(&fDirection);
  58 //    printf("---- speed %g dir %g %g\n", fSpeed0, fDirection.fX, fDirection.fY);
  59 }
  60
  61 bool TouchGesture::FlingState::evaluateMatrix(SkMatrix* matrix) {
  62     if (!fActive) {
  63         return false;
  64     }
  65
  66     const float t =  (float)(getseconds() - fTime0);
  67     const float MIN_SPEED = 2;
  68     const float K0 = 5;
  69     const float K1 = 0.02f;
  70     const float speed = fSpeed0 * (sk_float_exp(- K0 * t) - K1);
  71     if (speed <= MIN_SPEED) {
  72         fActive = false;
  73         return false;
  74     }
  75     float dist = (fSpeed0 - speed) / K0;
  76
  77 //    printf("---- time %g speed %g dist %g\n", t, speed, dist);
  78     float tx = fDirection.fX * dist;
  79     float ty = fDirection.fY * dist;
  80     if (DISCRETIZE_TRANSLATE_TO_AVOID_FLICKER) {
  81         tx = (float)sk_float_round2int(tx);
  82         ty = (float)sk_float_round2int(ty);
  83     }
  84     matrix->setTranslate(tx, ty);
  85 //    printf("---- evaluate (%g %g)\n", tx, ty);
  86
  87     return true;
  88 }
  89
  90 ///////////////////////////////////////////////////////////////////////////////
  91
  92 static const SkMSec MAX_DBL_TAP_INTERVAL = 300;
  93 static const float MAX_DBL_TAP_DISTANCE = 100;
  94 static const float MAX_JITTER_RADIUS = 2;
  95
  96 // if true, then ignore the touch-move, 'cause its probably just jitter
  97 static bool close_enough_for_jitter(float x0, float y0, float x1, float y1) {
  98     return  sk_float_abs(x0 - x1) <= MAX_JITTER_RADIUS &&
  99             sk_float_abs(y0 - y1) <= MAX_JITTER_RADIUS;
 100 }
 101
 102 ///////////////////////////////////////////////////////////////////////////////
 103
 104 TouchGesture::TouchGesture() {
 105     this->reset();
 106 }
 107
 108 TouchGesture::~TouchGesture() {
 109 }
 110
 111 void TouchGesture::resetTouchState() {
 112     fIsTransLimited = false;
 113     fTouches.reset();
 114     fState = kEmpty_State;
 115     fLocalM.reset();
 116
 117     fLastUpMillis = SkTime::GetMSecs() - 2*MAX_DBL_TAP_INTERVAL;
 118     fLastUpP.set(0, 0);
 119 }
 120
 121 void TouchGesture::reset() {
 122     fGlobalM.reset();
 123     this->resetTouchState();
 124 }
 125
 126 void TouchGesture::flushLocalM() {
 127     fGlobalM.postConcat(fLocalM);
 128     fLocalM.reset();
 129 }
 130
 131 const SkMatrix& TouchGesture::localM() {
 132     if (fFlinger.isActive()) {
 133         if (!fFlinger.evaluateMatrix(&fLocalM)) {
 134             this->flushLocalM();
 135         }
 136     }
 137     return fLocalM;
 138 }
 139
 140 void TouchGesture::appendNewRec(void* owner, float x, float y) {
 141     Rec* rec = fTouches.append();
 142     rec->fOwner = owner;
 143     rec->fStartX = rec->fPrevX = rec->fLastX = x;
 144     rec->fStartY = rec->fPrevY = rec->fLastY = y;
 145     rec->fLastT = rec->fPrevT = static_cast<float>(SkTime::GetSecs());
 146 }
 147
 148 void TouchGesture::touchBegin(void* owner, float x, float y) {
 149 //    SkDebugf("--- %d touchBegin %p %g %g\n", fTouches.count(), owner, x, y);
 150
 151     int index = this->findRec(owner);
 152     if (index >= 0) {
 153         this->flushLocalM();
 154         fTouches.removeShuffle(index);
 155         SkDebugf("---- already exists, removing\n");
 156     }
 157
 158     if (fTouches.count() == 2) {
 159         return;
 160     }
 161
 162     this->flushLocalM();
 163     fFlinger.stop();
 164
 165     this->appendNewRec(owner, x, y);
 166
 167     switch (fTouches.count()) {
 168         case 1:
 169             fState = kTranslate_State;
 170             break;
 171         case 2:
 172             this->startZoom();
 173             break;
 174         default:
 175             break;
 176     }
 177 }
 178
 179 int TouchGesture::findRec(void* owner) const {
 180     for (int i = 0; i < fTouches.count(); i++) {
 181         if (owner == fTouches[i].fOwner) {
 182             return i;
 183         }
 184     }
 185     return -1;
 186 }
 187
 188 static SkScalar center(float pos0, float pos1) {
 189     return (pos0 + pos1) * 0.5f;
 190 }
 191
 192 void TouchGesture::startZoom() {
 193     fState = kZoom_State;
 194 }
 195
 196 void TouchGesture::updateZoom(float scale, float startX, float startY, float lastX, float lastY) {
 197     fLocalM.setTranslate(-startX, -startY);
 198     fLocalM.postScale(scale, scale);
 199     fLocalM.postTranslate(lastX, lastY);
 200 }
 201
 202 void TouchGesture::endZoom() {
 203     this->flushLocalM();
 204     SkASSERT(kZoom_State == fState);
 205     fState = kEmpty_State;
 206 }
 207
 208 void TouchGesture::touchMoved(void* owner, float x, float y) {
 209 //    SkDebugf("--- %d touchMoved %p %g %g\n", fTouches.count(), owner, x, y);
 210
 211     if (kEmpty_State == fState) {
 212         return;
 213     }
 214
 215     int index = this->findRec(owner);
 216     if (index < 0) {
 217         SkDebugf("---- ignoring move without begin\n");
 218         return;
 219     }
 220
 221     Rec& rec = fTouches[index];
 222
 223     // not sure how valuable this is
 224     if (fTouches.count() == 2) {
 225         if (close_enough_for_jitter(rec.fLastX, rec.fLastY, x, y)) {
 226 //            SkDebugf("--- drop touchMove, within jitter tolerance %g %g\n", rec.fLastX - x, rec.fLastY - y);
 227             return;
 228         }
 229     }
 230
 231     rec.fPrevX = rec.fLastX; rec.fLastX = x;
 232     rec.fPrevY = rec.fLastY; rec.fLastY = y;
 233     rec.fPrevT = rec.fLastT;
 234     rec.fLastT = static_cast<float>(SkTime::GetSecs());
 235
 236     switch (fTouches.count()) {
 237         case 1: {
 238             float dx = rec.fLastX - rec.fStartX;
 239             float dy = rec.fLastY - rec.fStartY;
 240             dx = (float)sk_float_round2int(dx);
 241             dy = (float)sk_float_round2int(dy);
 242             fLocalM.setTranslate(dx, dy);
 243         } break;
 244         case 2: {
 245             SkASSERT(kZoom_State == fState);
 246             const Rec& rec0 = fTouches[0];
 247             const Rec& rec1 = fTouches[1];
 248
 249             float scale = this->computePinch(rec0, rec1);
 250             this->updateZoom(scale,
 251                              center(rec0.fStartX, rec1.fStartX),
 252                              center(rec0.fStartY, rec1.fStartY),
 253                              center(rec0.fLastX, rec1.fLastX),
 254                              center(rec0.fLastY, rec1.fLastY));
 255         } break;
 256         default:
 257             break;
 258     }
 259 }
 260
 261 void TouchGesture::touchEnd(void* owner) {
 262 //    SkDebugf("--- %d touchEnd   %p\n", fTouches.count(), owner);
 263
 264     int index = this->findRec(owner);
 265     if (index < 0) {
 266         SkDebugf("--- not found\n");
 267         return;
 268     }
 269
 270     const Rec& rec = fTouches[index];
 271     if (this->handleDblTap(rec.fLastX, rec.fLastY)) {
 272         return;
 273     }
 274
 275     // count() reflects the number before we removed the owner
 276     switch (fTouches.count()) {
 277         case 1: {
 278             this->flushLocalM();
 279             float dx = rec.fLastX - rec.fPrevX;
 280             float dy = rec.fLastY - rec.fPrevY;
 281             float dur = rec.fLastT - rec.fPrevT;
 282             if (dur > 0) {
 283                 fFlinger.reset(dx / dur, dy / dur);
 284             }
 285             fState = kEmpty_State;
 286         } break;
 287         case 2:
 288             this->endZoom();
 289             break;
 290         default:
 291             SkASSERT(kZoom_State == fState);
 292             break;
 293     }
 294
 295     fTouches.removeShuffle(index);
 296
 297     limitTrans();
 298 }
 299
 300 bool TouchGesture::isFling(SkPoint* dir) {
 301     if (fFlinger.isActive()) {
 302         SkScalar speed;
 303         fFlinger.get(dir, &speed);
 304         if (speed > 1000) {
 305             return true;
 306         }
 307     }
 308     return false;
 309 }
 310
 311 float TouchGesture::computePinch(const Rec& rec0, const Rec& rec1) {
 312     double dx = rec0.fStartX - rec1.fStartX;
 313     double dy = rec0.fStartY - rec1.fStartY;
 314     double dist0 = sqrt(dx*dx + dy*dy);
 315
 316     dx = rec0.fLastX - rec1.fLastX;
 317     dy = rec0.fLastY - rec1.fLastY;
 318     double dist1 = sqrt(dx*dx + dy*dy);
 319
 320     double scale = dist1 / dist0;
 321     return (float)scale;
 322 }
 323
 324 bool TouchGesture::handleDblTap(float x, float y) {
 325     bool found = false;
 326     double now = SkTime::GetMSecs();
 327     if (now - fLastUpMillis <= MAX_DBL_TAP_INTERVAL) {
 328         if (SkPoint::Length(fLastUpP.fX - x,
 329                             fLastUpP.fY - y) <= MAX_DBL_TAP_DISTANCE) {
 330             fFlinger.stop();
 331             fLocalM.reset();
 332             fGlobalM.reset();
 333             fTouches.reset();
 334             fState = kEmpty_State;
 335             found = true;
 336         }
 337     }
 338
 339     fLastUpMillis = now;
 340     fLastUpP.set(x, y);
 341     return found;
 342 }
 343
 344 void TouchGesture::setTransLimit(const SkRect& contentRect, const SkRect& windowRect,
 345                                    const SkMatrix& preTouchMatrix) {
 346     fIsTransLimited = true;
 347     fContentRect = contentRect;
 348     fWindowRect = windowRect;
 349     fPreTouchM = preTouchMatrix;
 350 }
 351
 352 void TouchGesture::limitTrans() {
 353     if (!fIsTransLimited) {
 354         return;
 355     }
 356
 357     SkRect scaledContent = fContentRect;
 358     fPreTouchM.mapRect(&scaledContent);
 359     fGlobalM.mapRect(&scaledContent);
 360     const SkScalar ZERO = 0;
 361
 362     fGlobalM.postTranslate(ZERO, std::min(ZERO, fWindowRect.fBottom - scaledContent.fTop));
 363     fGlobalM.postTranslate(ZERO, std::max(ZERO, fWindowRect.fTop - scaledContent.fBottom));
 364     fGlobalM.postTranslate(std::min(ZERO, fWindowRect.fRight - scaledContent.fLeft), ZERO);
 365     fGlobalM.postTranslate(std::max(ZERO, fWindowRect.fLeft - scaledContent.fRight), ZERO);
 366 }