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