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 "SkTouchGesture.h" 11 #include "SkMatrix.h" 12 #include "SkTime.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 SkFlingState::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 SkFlingState::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 SkTouchGesture::SkTouchGesture() { 105 this->reset(); 106 } 107 108 SkTouchGesture::~SkTouchGesture() { 109 } 110 111 void SkTouchGesture::reset() { 112 fIsTransLimited = false; 113 fTouches.reset(); 114 fState = kEmpty_State; 115 fLocalM.reset(); 116 fGlobalM.reset(); 117 118 fLastUpMillis = 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 = static_cast<float>(SkTime::GetSecs()); 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 SkDebugf("---- ignoring move without begin\n"); 213 return; 214 } 215 216 Rec& rec = fTouches[index]; 217 218 // not sure how valuable this is 219 if (fTouches.count() == 2) { 220 if (close_enough_for_jitter(rec.fLastX, rec.fLastY, x, y)) { 221 // SkDebugf("--- drop touchMove, within jitter tolerance %g %g\n", rec.fLastX - x, rec.fLastY - y); 222 return; 223 } 224 } 225 226 rec.fPrevX = rec.fLastX; rec.fLastX = x; 227 rec.fPrevY = rec.fLastY; rec.fLastY = y; 228 rec.fPrevT = rec.fLastT; 229 rec.fLastT = static_cast<float>(SkTime::GetSecs()); 230 231 switch (fTouches.count()) { 232 case 1: { 233 float dx = rec.fLastX - rec.fStartX; 234 float dy = rec.fLastY - rec.fStartY; 235 dx = (float)sk_float_round2int(dx); 236 dy = (float)sk_float_round2int(dy); 237 fLocalM.setTranslate(dx, dy); 238 } break; 239 case 2: { 240 SkASSERT(kZoom_State == fState); 241 const Rec& rec0 = fTouches[0]; 242 const Rec& rec1 = fTouches[1]; 243 244 float scale = this->computePinch(rec0, rec1); 245 scale = this->limitTotalZoom(scale); 246 247 fLocalM.setTranslate(-center(rec0.fStartX, rec1.fStartX), 248 -center(rec0.fStartY, rec1.fStartY)); 249 fLocalM.postScale(scale, scale); 250 fLocalM.postTranslate(center(rec0.fLastX, rec1.fLastX), 251 center(rec0.fLastY, rec1.fLastY)); 252 } break; 253 default: 254 break; 255 } 256 } 257 258 void SkTouchGesture::touchEnd(void* owner) { 259 // SkDebugf("--- %d touchEnd %p\n", fTouches.count(), owner); 260 261 int index = this->findRec(owner); 262 if (index < 0) { 263 SkDebugf("--- not found\n"); 264 return; 265 } 266 267 const Rec& rec = fTouches[index]; 268 if (this->handleDblTap(rec.fLastX, rec.fLastY)) { 269 return; 270 } 271 272 // count() reflects the number before we removed the owner 273 switch (fTouches.count()) { 274 case 1: { 275 this->flushLocalM(); 276 float dx = rec.fLastX - rec.fPrevX; 277 float dy = rec.fLastY - rec.fPrevY; 278 float dur = rec.fLastT - rec.fPrevT; 279 if (dur > 0) { 280 fFlinger.reset(dx / dur, dy / dur); 281 } 282 fState = kEmpty_State; 283 } break; 284 case 2: 285 this->flushLocalM(); 286 SkASSERT(kZoom_State == fState); 287 fState = kEmpty_State; 288 break; 289 default: 290 SkASSERT(kZoom_State == fState); 291 break; 292 } 293 294 fTouches.removeShuffle(index); 295 296 limitTrans(); 297 } 298 299 float SkTouchGesture::computePinch(const Rec& rec0, const Rec& rec1) { 300 double dx = rec0.fStartX - rec1.fStartX; 301 double dy = rec0.fStartY - rec1.fStartY; 302 double dist0 = sqrt(dx*dx + dy*dy); 303 304 dx = rec0.fLastX - rec1.fLastX; 305 dy = rec0.fLastY - rec1.fLastY; 306 double dist1 = sqrt(dx*dx + dy*dy); 307 308 double scale = dist1 / dist0; 309 return (float)scale; 310 } 311 312 bool SkTouchGesture::handleDblTap(float x, float y) { 313 bool found = false; 314 double now = SkTime::GetMSecs(); 315 if (now - fLastUpMillis <= MAX_DBL_TAP_INTERVAL) { 316 if (SkPoint::Length(fLastUpP.fX - x, 317 fLastUpP.fY - y) <= MAX_DBL_TAP_DISTANCE) { 318 fFlinger.stop(); 319 fLocalM.reset(); 320 fGlobalM.reset(); 321 fTouches.reset(); 322 fState = kEmpty_State; 323 found = true; 324 } 325 } 326 327 fLastUpMillis = now; 328 fLastUpP.set(x, y); 329 return found; 330 } 331 332 void SkTouchGesture::setTransLimit(const SkRect& contentRect, const SkRect& windowRect, 333 const SkMatrix& preTouchMatrix) { 334 fIsTransLimited = true; 335 fContentRect = contentRect; 336 fWindowRect = windowRect; 337 fPreTouchM = preTouchMatrix; 338 } 339 340 void SkTouchGesture::limitTrans() { 341 if (!fIsTransLimited) { 342 return; 343 } 344 345 SkRect scaledContent = fContentRect; 346 fPreTouchM.mapRect(&scaledContent); 347 fGlobalM.mapRect(&scaledContent); 348 const SkScalar ZERO = 0; 349 350 fGlobalM.postTranslate(ZERO, std::min(ZERO, fWindowRect.fBottom - scaledContent.fTop)); 351 fGlobalM.postTranslate(ZERO, std::max(ZERO, fWindowRect.fTop - scaledContent.fBottom)); 352 fGlobalM.postTranslate(std::min(ZERO, fWindowRect.fRight - scaledContent.fLeft), ZERO); 353 fGlobalM.postTranslate(std::max(ZERO, fWindowRect.fLeft - scaledContent.fRight), ZERO); 354 } 355
