1 /* |
|
2 * Copyright (c) 2008-2008 Nokia Corporation and/or its subsidiary(-ies). |
|
3 * All rights reserved. |
|
4 * This component and the accompanying materials are made available |
|
5 * under the terms of "Eclipse Public License v1.0" |
|
6 * which accompanies this distribution, and is available |
|
7 * at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
8 * |
|
9 * Initial Contributors: |
|
10 * Nokia Corporation - initial contribution. |
|
11 * |
|
12 * Contributors: |
|
13 * |
|
14 * Description: Gesture class |
|
15 * |
|
16 */ |
|
17 |
|
18 #include "gesture.h" |
|
19 |
|
20 #include <e32math.h> |
|
21 |
|
22 #include "gesturedefs.h" |
|
23 #include "utils.h" |
|
24 |
|
25 using namespace GestureHelper; |
|
26 |
|
27 /** |
|
28 * Point array for which only x axis is relevant |
|
29 */ |
|
30 class TXAxisPointArray : public TPointArray |
|
31 { |
|
32 public: |
|
33 TXAxisPointArray( const RArray< TPointEntry >& aPoints ) |
|
34 : TPointArray( aPoints ) {} |
|
35 |
|
36 // from TPointArray |
|
37 TPoint operator[]( TInt aIndex ) const |
|
38 { |
|
39 return TPoint( Raw( aIndex ).iX, 0 ); |
|
40 } |
|
41 }; |
|
42 |
|
43 /** |
|
44 * Point array for which only y axis is relevant |
|
45 */ |
|
46 class TYAxisPointArray : public TPointArray |
|
47 { |
|
48 public: |
|
49 TYAxisPointArray( const RArray< TPointEntry >& aPoints ) |
|
50 : TPointArray( aPoints ) {} |
|
51 |
|
52 // from TPointArray |
|
53 TPoint operator[]( TInt aIndex ) const |
|
54 { |
|
55 return TPoint( 0, Raw( aIndex ).iY ); |
|
56 } |
|
57 }; |
|
58 |
|
59 namespace |
|
60 { |
|
61 /** @return the current time */ |
|
62 TTime CurrentTime() |
|
63 { |
|
64 TTime time; |
|
65 time.UniversalTime(); |
|
66 return time; |
|
67 } |
|
68 |
|
69 /** |
|
70 * @param aRelevantAxis See @ref MGestureEvent::Code |
|
71 * @return gesture code by analysing the sequence of points |
|
72 */ |
|
73 TGestureCode CodeFromPoints( const RArray< TPointEntry >& aPoints, |
|
74 MGestureEvent::TAxis aRelevantAxis ) |
|
75 { |
|
76 // select the correct filter based on aRelevantAxis |
|
77 // these filter_ objects are array decorators that will eliminate either |
|
78 // x, y or neither coordinate of each point |
|
79 TXAxisPointArray filterY( aPoints ); |
|
80 TYAxisPointArray filterX( aPoints ); |
|
81 TPointArray filterNone( aPoints ); |
|
82 TPointArray& filter = |
|
83 aRelevantAxis == MGestureEvent::EAxisHorizontal ? static_cast< TPointArray& >( filterY ) : |
|
84 aRelevantAxis == MGestureEvent::EAxisVertical ? static_cast< TPointArray& >( filterX ) : |
|
85 /* otherwise EAxisBoth */ filterNone; |
|
86 |
|
87 // currently the gesture recogniser does not have any state, so it is fast |
|
88 // to instantiate. The call is not static however, to allow the recogniser |
|
89 // to be replaced by a more complicated implementation that has state. |
|
90 // then it may make sense to make the recogniser a member variable. |
|
91 return TGestureRecogniser().GestureCode( filter, aRelevantAxis ); |
|
92 } |
|
93 |
|
94 /** |
|
95 * @param aPoints Sequence of points representing 1st pointer movement |
|
96 * @param aSecondaryPoints Sequence of points representing 2nd pointer movement |
|
97 * @param aPreviousDistance contains the previous distance aftre this function execution |
|
98 * @return gesture code by analysing the sequence of points |
|
99 */ |
|
100 TGestureCode MultiTouchCode( const RArray< TPointEntry >& aPoints, |
|
101 const RArray< TPointEntry >& aSecondaryPoints, TInt aPreviousDistance, TBool aIsFirstPinch ) |
|
102 { |
|
103 TPointArray filter(aPoints); |
|
104 TPointArray secondaryFilter(aSecondaryPoints); |
|
105 return TGestureRecogniser().MultiTouchGestureCode( filter, secondaryFilter, aPreviousDistance, aIsFirstPinch ); |
|
106 } |
|
107 } // unnamed namespace |
|
108 |
|
109 // ---------------------------------------------------------------------------- |
|
110 // constructor |
|
111 // ---------------------------------------------------------------------------- |
|
112 // |
|
113 CGesture::CGesture() |
|
114 { |
|
115 iPinchStartDistance = -1; |
|
116 iPinchEndDistance = -1; |
|
117 iPinchDetected = EFalse ; |
|
118 } |
|
119 |
|
120 // ---------------------------------------------------------------------------- |
|
121 // destructor |
|
122 // ---------------------------------------------------------------------------- |
|
123 // |
|
124 CGesture::~CGesture() |
|
125 { |
|
126 iPoints.Close(); |
|
127 iSecondaryPoints.Close(); |
|
128 } |
|
129 |
|
130 // ---------------------------------------------------------------------------- |
|
131 // AsStartEventL |
|
132 // ---------------------------------------------------------------------------- |
|
133 // |
|
134 CGesture* CGesture::AsStartEventLC() const |
|
135 { |
|
136 __ASSERT_DEBUG( 0 < iPoints.Count(), Panic( EGesturePanicIllegalLogic ) ); |
|
137 CGesture* gesture = new ( ELeave ) CGesture; |
|
138 CleanupStack::PushL( gesture ); |
|
139 User::LeaveIfError( gesture->AddPoint( iPoints[0].iPos ) ); |
|
140 return gesture; |
|
141 } |
|
142 |
|
143 // ---------------------------------------------------------------------------- |
|
144 // ResetToLastPoint |
|
145 // ---------------------------------------------------------------------------- |
|
146 // |
|
147 void CGesture::ResetToLastPoint(TBool aSetPointerZero,TBool aSetToZero) |
|
148 { |
|
149 TPointEntry lastEntry(TPoint(0,0),TTime()); |
|
150 if( aSetToZero ) |
|
151 { |
|
152 __ASSERT_DEBUG( 0 < iPoints.Count(), Panic( EGesturePanicIllegalLogic ) ); |
|
153 lastEntry = LastPoint( iPoints); |
|
154 } |
|
155 else |
|
156 { |
|
157 __ASSERT_DEBUG( 0 < iSecondaryPoints.Count(), Panic( EGesturePanicIllegalLogic ) ); |
|
158 lastEntry = LastPoint( iSecondaryPoints); |
|
159 } |
|
160 Reset(); |
|
161 if( aSetPointerZero ) |
|
162 { |
|
163 iPoints.Append(lastEntry); |
|
164 } |
|
165 else |
|
166 { |
|
167 iSecondaryPoints.Append(lastEntry); |
|
168 } |
|
169 } |
|
170 |
|
171 // ---------------------------------------------------------------------------- |
|
172 // LastPoint |
|
173 // ---------------------------------------------------------------------------- |
|
174 // |
|
175 inline const TPointEntry CGesture::LastPoint( const RArray< TPointEntry >& aPoints ) const |
|
176 { |
|
177 return aPoints[aPoints.Count() - 1]; |
|
178 } |
|
179 |
|
180 // ---------------------------------------------------------------------------- |
|
181 // IsPinchToleranceHigh |
|
182 // ---------------------------------------------------------------------------- |
|
183 // |
|
184 inline TBool CGesture::IsHighPinchTolerance() const |
|
185 { |
|
186 |
|
187 if( iPinchEndDistance == -1 ) |
|
188 { |
|
189 return ETrue; |
|
190 } |
|
191 else |
|
192 { |
|
193 TInt currentDistance = TGestureRecogniser().Length( LastPoint(iPoints).iPos, LastPoint(iSecondaryPoints).iPos ); |
|
194 // if previously zooming out and current distance corresponds to zooming in or viceversa |
|
195 if( ( iZoomState == EZoomOut && currentDistance < iPinchStartDistance) || |
|
196 ( iZoomState == EZoomIn && currentDistance > iPinchStartDistance)) |
|
197 { |
|
198 return ETrue; |
|
199 } |
|
200 } |
|
201 return EFalse; |
|
202 } |
|
203 // ---------------------------------------------------------------------------- |
|
204 // Reset |
|
205 // ---------------------------------------------------------------------------- |
|
206 // |
|
207 void CGesture::Reset() |
|
208 { |
|
209 iPoints.Reset(); |
|
210 iSecondaryPoints.Reset(); |
|
211 iHoldingState = ENotHolding; |
|
212 iState = ENotActive; |
|
213 iHoldingPointIndex = 0; |
|
214 iVisual = NULL; |
|
215 iIsDoubleTap = EFalse; |
|
216 iPinchStartDistance = -1; |
|
217 iPinchEndDistance = -1; |
|
218 iPinchDetected = EFalse; |
|
219 iZoomState = ENoZoom; |
|
220 } |
|
221 |
|
222 // ---------------------------------------------------------------------------- |
|
223 // IsEmpty |
|
224 // ---------------------------------------------------------------------------- |
|
225 // |
|
226 TBool CGesture::IsEmpty() const |
|
227 { |
|
228 return iPoints.Count() == 0; |
|
229 } |
|
230 |
|
231 // ---------------------------------------------------------------------------- |
|
232 // IsMultiTouch |
|
233 // ---------------------------------------------------------------------------- |
|
234 // |
|
235 TBool CGesture::IsMultiTouch() const |
|
236 { |
|
237 return iSecondaryPoints.Count() == 0; |
|
238 } |
|
239 |
|
240 // ---------------------------------------------------------------------------- |
|
241 // Add a point to the sequence of points that together make up the gesture |
|
242 // ---------------------------------------------------------------------------- |
|
243 // |
|
244 TInt CGesture::AddPoint( const TPoint& aPoint ) |
|
245 { |
|
246 if ( !IsLatestPoint( aPoint ) ) |
|
247 { |
|
248 return iPoints.Append( TPointEntry( aPoint, CurrentTime() ) ); |
|
249 } |
|
250 return KErrNone; |
|
251 } |
|
252 |
|
253 // ---------------------------------------------------------------------------- |
|
254 // AddSecondaryPoint |
|
255 // ---------------------------------------------------------------------------- |
|
256 // |
|
257 TInt CGesture::AddSecondaryPoint( const TPoint& aPoint ) |
|
258 { |
|
259 if ( !IsLatestSecondaryPoint( aPoint ) ) |
|
260 { |
|
261 return iSecondaryPoints.Append( TPointEntry( aPoint, CurrentTime() ) ); |
|
262 } |
|
263 return KErrNone; |
|
264 } |
|
265 |
|
266 // ---------------------------------------------------------------------------- |
|
267 // SetVisual |
|
268 // ---------------------------------------------------------------------------- |
|
269 // |
|
270 void CGesture::SetVisual( CAlfVisual* aVisual ) |
|
271 { |
|
272 iVisual = aVisual; |
|
273 } |
|
274 |
|
275 // ---------------------------------------------------------------------------- |
|
276 // IsNearHoldingPoint |
|
277 // ---------------------------------------------------------------------------- |
|
278 // |
|
279 TBool CGesture::IsNearHoldingPoint( const TPoint& aPoint ) const |
|
280 { |
|
281 return ToleranceRect( iPoints[ iHoldingPointIndex ].iPos ).Contains( aPoint ); |
|
282 } |
|
283 |
|
284 // ---------------------------------------------------------------------------- |
|
285 // IsLatestPoint |
|
286 // ---------------------------------------------------------------------------- |
|
287 // |
|
288 TBool CGesture::IsLatestPoint( const TPoint& aPoint ) const |
|
289 { |
|
290 if ( iPoints.Count() > 0 ) |
|
291 { |
|
292 return aPoint == CurrentPos(); |
|
293 } |
|
294 return EFalse; |
|
295 } |
|
296 // ---------------------------------------------------------------------------- |
|
297 // IsLatestSecondaryPoint |
|
298 // ---------------------------------------------------------------------------- |
|
299 // |
|
300 TBool CGesture::IsLatestSecondaryPoint( const TPoint& aPoint ) const |
|
301 { |
|
302 if ( iSecondaryPoints.Count() > 0 ) |
|
303 { |
|
304 return aPoint == iSecondaryPoints[ iSecondaryPoints.Count() - 1 ].iPos; |
|
305 } |
|
306 return EFalse; |
|
307 } |
|
308 |
|
309 // ---------------------------------------------------------------------------- |
|
310 // StartHolding |
|
311 // ---------------------------------------------------------------------------- |
|
312 // |
|
313 void CGesture::StartHolding() |
|
314 { |
|
315 iHoldingState = EHoldStarting; |
|
316 |
|
317 // remove all points that were introduced after holding started |
|
318 for ( TInt i = iPoints.Count() - 1; i > iHoldingPointIndex; i-- ) |
|
319 { |
|
320 iPoints.Remove( i ); |
|
321 } |
|
322 } |
|
323 |
|
324 // ---------------------------------------------------------------------------- |
|
325 // SetHoldingPoint |
|
326 // ---------------------------------------------------------------------------- |
|
327 // |
|
328 void CGesture::SetHoldingPoint() |
|
329 { |
|
330 iHoldingPointIndex = iPoints.Count() - 1; |
|
331 } |
|
332 |
|
333 // ---------------------------------------------------------------------------- |
|
334 // ContinueHolding |
|
335 // ---------------------------------------------------------------------------- |
|
336 // |
|
337 void CGesture::ContinueHolding() |
|
338 { |
|
339 iHoldingState = EHolding; |
|
340 } |
|
341 |
|
342 // ---------------------------------------------------------------------------- |
|
343 // SetSingleTouchActive |
|
344 // ---------------------------------------------------------------------------- |
|
345 // |
|
346 void CGesture::SetSingleTouchActive() |
|
347 { |
|
348 __ASSERT_DEBUG( ENotActive == iState, Panic( EGesturePanicIllegalLogic ) ); |
|
349 iState = ESingleTouchActive; |
|
350 } |
|
351 // ---------------------------------------------------------------------------- |
|
352 // SetMultiTouchActive |
|
353 // ---------------------------------------------------------------------------- |
|
354 // |
|
355 void CGesture::SetMultiTouchActive() |
|
356 { |
|
357 iState = EMultiTouchActive; |
|
358 iIsMultiTouched = ETrue; |
|
359 } |
|
360 // ---------------------------------------------------------------------------- |
|
361 // SetSingleTouchReleased |
|
362 // ---------------------------------------------------------------------------- |
|
363 // |
|
364 void CGesture::SetSingleTouchReleased() |
|
365 { |
|
366 // IsMovementStopped expects corresponding SetComplete to be called before SetRelease |
|
367 __ASSERT_DEBUG( ESingleTouchComplete == iState, Panic( EGesturePanicIllegalLogic ) ); |
|
368 iState = ESingleTouchReleased; |
|
369 iIsMultiTouched = EFalse; |
|
370 } |
|
371 // ---------------------------------------------------------------------------- |
|
372 // SetMultiTouchReleased |
|
373 // ---------------------------------------------------------------------------- |
|
374 // |
|
375 void CGesture::SetMultiTouchReleased() |
|
376 { |
|
377 // IsMovementStopped expects corresponding SetComplete to be called before SetRelease |
|
378 __ASSERT_DEBUG( EMultiTouchComplete == iState, Panic( EGesturePanicIllegalLogic ) ); |
|
379 iState = EMultiTouchReleased; |
|
380 } |
|
381 |
|
382 /** |
|
383 * @return elapsed time between aStartTime and aEndTime |
|
384 */ |
|
385 inline TTimeIntervalMicroSeconds32 Elapsed( const TTime& aStartTime, |
|
386 const TTime& aEndTime ) |
|
387 { |
|
388 return aEndTime.MicroSecondsFrom( aStartTime ).Int64(); |
|
389 } |
|
390 |
|
391 // ---------------------------------------------------------------------------- |
|
392 // SetSingleTouchComplete |
|
393 // ---------------------------------------------------------------------------- |
|
394 // |
|
395 void CGesture::SetSingleTouchComplete() |
|
396 { |
|
397 __ASSERT_DEBUG( iPoints.Count() > 0, Panic( EGesturePanicIllegalLogic ) ); |
|
398 iState = ESingleTouchComplete; |
|
399 iCompletionTime = CurrentTime(); |
|
400 } |
|
401 |
|
402 // ---------------------------------------------------------------------------- |
|
403 // SetMultiTouchComplete |
|
404 // ---------------------------------------------------------------------------- |
|
405 // |
|
406 void CGesture::SetMultiTouchComplete() |
|
407 { |
|
408 __ASSERT_DEBUG( iSecondaryPoints.Count() > 0, Panic( EGesturePanicIllegalLogic ) ); |
|
409 iState = EMultiTouchComplete; |
|
410 } |
|
411 |
|
412 // ---------------------------------------------------------------------------- |
|
413 // SetCancelled |
|
414 // ---------------------------------------------------------------------------- |
|
415 // |
|
416 void CGesture::SetCancelled() |
|
417 { |
|
418 iState = ECancelled; |
|
419 } |
|
420 |
|
421 // ---------------------------------------------------------------------------- |
|
422 // SetDoubleTap |
|
423 // ---------------------------------------------------------------------------- |
|
424 // |
|
425 void CGesture::SetDoubleTap() |
|
426 { |
|
427 iIsDoubleTap = ETrue; |
|
428 } |
|
429 |
|
430 // ---------------------------------------------------------------------------- |
|
431 // IsTap |
|
432 // ---------------------------------------------------------------------------- |
|
433 // |
|
434 TBool CGesture::IsTap() const |
|
435 { |
|
436 if(iIsMultiTouched) |
|
437 { |
|
438 return EFalse; |
|
439 } |
|
440 return CodeFromPoints( iPoints, EAxisBoth ) == EGestureTap; |
|
441 } |
|
442 |
|
443 // ---------------------------------------------------------------------------- |
|
444 // IsPinch |
|
445 // ---------------------------------------------------------------------------- |
|
446 // |
|
447 TBool CGesture::IsPinch() |
|
448 { |
|
449 if (iPinchStartDistance == -1 ) |
|
450 { |
|
451 iPinchStartDistance = TGestureRecogniser().Length( iPoints[0].iPos, iSecondaryPoints[0].iPos ) ; |
|
452 } |
|
453 // if there is a pinch detected in the last attempt then update the start distance. |
|
454 // henceforth this new distance is used as reference for calculating the pinch. |
|
455 |
|
456 if( iPinchDetected ) |
|
457 { |
|
458 iPinchStartDistance = iPinchEndDistance; |
|
459 } |
|
460 iPinchDetected = MultiTouchCode( iPoints, iSecondaryPoints, iPinchStartDistance,IsHighPinchTolerance()) == EGesturePinch; |
|
461 if( iPinchDetected ) |
|
462 { |
|
463 // This end distance is updated the first time the pinch is detected. |
|
464 // This is done the save the value of pinch end distnce for further refernce to |
|
465 // update the pinch start distance next time any pointer position changes. |
|
466 iPinchEndDistance = TGestureRecogniser().Length( |
|
467 LastPoint(iPoints).iPos,LastPoint(iSecondaryPoints).iPos ); |
|
468 iZoomState = iPinchEndDistance > iPinchStartDistance ? EZoomOut : EZoomIn; |
|
469 } |
|
470 return iPinchDetected; |
|
471 } |
|
472 |
|
473 /** |
|
474 * Translates a non-holding code into a holding code |
|
475 * @param aCode original gesture code |
|
476 * @return a gesture code with hold flag applied |
|
477 */ |
|
478 inline TGestureCode Hold( TGestureCode aCode ) |
|
479 { |
|
480 if ( aCode != EGestureStart && |
|
481 aCode != EGestureDrag && |
|
482 aCode != EGestureReleased && |
|
483 aCode != EGestureUnknown ) |
|
484 { |
|
485 return static_cast< TGestureCode >( aCode | EFlagHold ); |
|
486 } |
|
487 return aCode; |
|
488 } |
|
489 |
|
490 // ---------------------------------------------------------------------------- |
|
491 // Code |
|
492 // ---------------------------------------------------------------------------- |
|
493 // |
|
494 TGestureCode CGesture::Code( TAxis aRelevantAxis ) const |
|
495 { |
|
496 switch ( iState ) |
|
497 { |
|
498 case ESingleTouchActive: |
|
499 // "start" event if only first point received |
|
500 // need to check that not holding, in case user pressed stylus |
|
501 // down, and activated holding without moving the stylus |
|
502 if ( iPoints.Count() == 1 && !IsHolding() ) |
|
503 { |
|
504 return EGestureStart; |
|
505 } |
|
506 // "drag" event if holding not started or holding started earlier |
|
507 else if ( iHoldingState != EHoldStarting ) |
|
508 { |
|
509 // select the correct filter based on aRelevantAxis |
|
510 // these filter_ objects are array decorators that will eliminate either |
|
511 // x, y or neither coordinate of each point |
|
512 TXAxisPointArray filterY( iPoints ); |
|
513 TYAxisPointArray filterX( iPoints ); |
|
514 TPointArray filterNone( iPoints ); |
|
515 TPointArray& filter = |
|
516 aRelevantAxis == MGestureEvent::EAxisHorizontal ? static_cast< TPointArray& >( filterY ) : |
|
517 aRelevantAxis == MGestureEvent::EAxisVertical ? static_cast< TPointArray& >( filterX ) : |
|
518 /* otherwise EAxisBoth */ filterNone; |
|
519 |
|
520 return TGestureRecogniser().ValidateDrag( filter, aRelevantAxis ); |
|
521 } |
|
522 // holding was just started |
|
523 else |
|
524 { |
|
525 return Hold( CodeFromPoints( iPoints, aRelevantAxis ) ); |
|
526 } |
|
527 |
|
528 case EMultiTouchActive: |
|
529 // Only if there are some points in secondary array |
|
530 if ( iSecondaryPoints.Count() == 1 && iPoints.Count() == 1 ) |
|
531 { |
|
532 return EGestureMultiTouchStart; |
|
533 } |
|
534 else |
|
535 { |
|
536 return MultiTouchCode( iPoints, iSecondaryPoints, iPinchStartDistance,IsHighPinchTolerance() ); |
|
537 } |
|
538 |
|
539 case ESingleTouchComplete: |
|
540 { |
|
541 if ( iIsDoubleTap ) |
|
542 { |
|
543 return EGestureDoubleTap; |
|
544 } |
|
545 |
|
546 // If there was a mulitouch within the last gesture then ignore the tap |
|
547 TGestureCode gestureCode = CodeFromPoints( iPoints, aRelevantAxis ); |
|
548 if( gestureCode == EGestureTap && iIsMultiTouched) |
|
549 { |
|
550 return EGestureUnknown; |
|
551 } |
|
552 return gestureCode; |
|
553 } |
|
554 case EMultiTouchComplete: |
|
555 return MultiTouchCode( iPoints, iSecondaryPoints, iPinchStartDistance,IsHighPinchTolerance()); |
|
556 |
|
557 case ESingleTouchReleased: |
|
558 return EGestureReleased; |
|
559 case EMultiTouchReleased: |
|
560 return EGestureMultiTouchReleased; |
|
561 |
|
562 case ECancelled: // fallthrough |
|
563 case ENotActive: |
|
564 default: |
|
565 return EGestureUnknown; |
|
566 } |
|
567 } |
|
568 |
|
569 // ---------------------------------------------------------------------------- |
|
570 // IsHolding |
|
571 // ---------------------------------------------------------------------------- |
|
572 // |
|
573 TBool CGesture::IsHolding() const |
|
574 { |
|
575 return iHoldingState >= EHoldStarting; |
|
576 } |
|
577 |
|
578 // ---------------------------------------------------------------------------- |
|
579 // StartPos |
|
580 // ---------------------------------------------------------------------------- |
|
581 // |
|
582 TPoint CGesture::StartPos() const |
|
583 { |
|
584 // at least one point will be in the array during callback (pointer down pos) |
|
585 return iPoints[ 0 ].iPos; |
|
586 } |
|
587 |
|
588 // ---------------------------------------------------------------------------- |
|
589 // CurrentPos |
|
590 // ---------------------------------------------------------------------------- |
|
591 // |
|
592 TPoint CGesture::CurrentPos() const |
|
593 { |
|
594 // at least on point will be in the array during callback (pointer down pos) |
|
595 return iPoints[ iPoints.Count() - 1 ].iPos; |
|
596 } |
|
597 |
|
598 // ---------------------------------------------------------------------------- |
|
599 // IsMovementStopped |
|
600 // ---------------------------------------------------------------------------- |
|
601 // |
|
602 inline TBool CGesture::IsMovementStopped() const |
|
603 { |
|
604 // iCompletionTime is only only valid if client has called SetComplete |
|
605 if ( iState >= ESingleTouchComplete ) |
|
606 { |
|
607 return Elapsed( NthLastEntry( 1 ).iTime, iCompletionTime ).Int() > KSpeedStopTime; |
|
608 } |
|
609 return EFalse; |
|
610 } |
|
611 |
|
612 namespace |
|
613 { |
|
614 const TInt KFloatingPointAccuracy = 0.000001; |
|
615 |
|
616 /** @return percentage (0.0-1.0) how far aPos is from aEdge1 towards aEdge2 */ |
|
617 inline TReal32 Proportion( TReal32 aPos, TReal32 aEdge1, TReal32 aEdge2 ) |
|
618 { |
|
619 if ( Abs( aEdge2 - aEdge1 ) > KFloatingPointAccuracy ) |
|
620 { |
|
621 return ( aPos - aEdge1 ) / ( aEdge2 - aEdge1 ); |
|
622 } |
|
623 return 0; // avoid division by zero |
|
624 } |
|
625 |
|
626 /** Edges (pixels) at which speed should be -100% or 100% */ |
|
627 NONSHARABLE_STRUCT( TEdges ) |
|
628 { |
|
629 TReal32 iMin; |
|
630 TReal32 iMax; |
|
631 }; |
|
632 |
|
633 /** |
|
634 * scale which allows different (coordinate -> percentage) mapping |
|
635 * between -100% to 0% and 0 and 100% |
|
636 */ |
|
637 NONSHARABLE_STRUCT( TScale ) |
|
638 { |
|
639 TScale( TInt aZero, const TEdges& aEdges ) |
|
640 : iMin( aEdges.iMin ), iZero( aZero ), iMax( aEdges.iMax ) |
|
641 { |
|
642 } |
|
643 |
|
644 /** @return aPos as a percentage between -100% and 100% in aScale */ |
|
645 TReal32 Percent( TReal32 aPos ) const; |
|
646 |
|
647 /// coordinate where speed is -100% |
|
648 TReal32 iMin; |
|
649 /// coordinate where speed is 0% |
|
650 TReal32 iZero; |
|
651 /// coordinate where speed is 100% |
|
652 TReal32 iMax; |
|
653 }; |
|
654 |
|
655 /** @convert aPos into a percentage between -100% and 100% in aScale */ |
|
656 TReal32 TScale::Percent( TReal32 aPos ) const |
|
657 { |
|
658 TReal32 percent; |
|
659 if ( aPos < iZero ) |
|
660 { |
|
661 // return negative percentages on the lower side of zero point |
|
662 percent = -1 * Proportion( aPos, iZero, iMin ); |
|
663 } |
|
664 else |
|
665 { |
|
666 percent = Proportion( aPos, iZero, iMax ); |
|
667 } |
|
668 // constrain between -100% and 100% |
|
669 return Min( Max( percent, -1.0F ), 1.0F ); |
|
670 } |
|
671 |
|
672 /** Scale in x and y dimensions */ |
|
673 NONSHARABLE_STRUCT( TScale2D ) |
|
674 { |
|
675 TRealPoint Percent( const TPoint& aPos ) const |
|
676 { |
|
677 return TRealPoint( iX.Percent( aPos.iX ), |
|
678 iY.Percent( aPos.iY ) ); |
|
679 } |
|
680 |
|
681 TScale iX; |
|
682 TScale iY; |
|
683 }; |
|
684 |
|
685 enum TDirection { ESmaller, ELarger }; |
|
686 |
|
687 /** @return the direction of pos compared to the previous pos */ |
|
688 inline TDirection Direction( TInt aPos, TInt aPreviousPos ) |
|
689 { |
|
690 return aPos < aPreviousPos ? ESmaller : ELarger; |
|
691 } |
|
692 |
|
693 /** Direction in x and y dimensions */ |
|
694 NONSHARABLE_STRUCT( TDirection2D ) |
|
695 { |
|
696 TDirection iX; |
|
697 TDirection iY; |
|
698 }; |
|
699 |
|
700 /** Return the direction (up/down) of signal at aIndex */ |
|
701 inline TDirection2D Direction( TInt aIndex, const RArray< TPointEntry >& aPoints ) |
|
702 { |
|
703 const TPoint& pos = aPoints[ aIndex ].iPos; |
|
704 const TPoint& prevPos = aPoints[ aIndex - 1 ].iPos; |
|
705 TDirection2D dir = { Direction( pos.iX, prevPos.iX ), |
|
706 Direction( pos.iY, prevPos.iY ) }; |
|
707 return dir; |
|
708 } |
|
709 /** |
|
710 * @return a position in the aLow and aHigh, so that it aProportion of |
|
711 * of length is above the pos |
|
712 */ |
|
713 TReal32 ProportionalLength( TReal32 aLow, TReal32 aHigh, TReal32 aProportion ) |
|
714 { |
|
715 return ( aHigh - aLow ) * aProportion / ( 1 + aProportion ); |
|
716 } |
|
717 |
|
718 /** |
|
719 * @return aVariableEdge scaled to new position, when the other edge changes |
|
720 * from aOldEdge to aNewEdge, so that aOrigin maintains the *same relative |
|
721 * position* between aVariableEdge and the other edge |
|
722 */ |
|
723 inline TReal32 ScaledEdge( TReal32 aOrigin, TReal32 aVariableEdge, |
|
724 TReal32 aOldEdge, TReal aNewEdge ) |
|
725 { |
|
726 TReal32 proportion = Proportion( aOrigin, aVariableEdge, aOldEdge ); |
|
727 return ( proportion * aNewEdge - aOrigin ) / ( proportion - 1 ); |
|
728 } |
|
729 |
|
730 TScale Rescale( TReal32 aPos, TDirection aDir, TDirection aPrevDir, |
|
731 const TScale& aPrevScale, const TEdges& aEdges ) |
|
732 { |
|
733 TScale scale( aPrevScale ); |
|
734 if ( aPrevDir != aDir ) |
|
735 { |
|
736 // the code duplication is accepted here, since it is difficult to factor out |
|
737 // while maintaining the understandability of this anyway complex algorithm |
|
738 if ( aDir == ESmaller ) |
|
739 { |
|
740 scale.iMin = aEdges.iMin; |
|
741 if ( aPrevScale.iZero < aPos ) |
|
742 { |
|
743 TReal32 proportionAboveZero = Proportion( aPos, aPrevScale.iZero, aPrevScale.iMax ); |
|
744 scale.iZero = aPos - ProportionalLength( aEdges.iMin, aPos, proportionAboveZero ); |
|
745 } |
|
746 else |
|
747 { |
|
748 // adjust zero pos so that proportion between aPos, Min, and Zero pos |
|
749 // stay the same (Min will move to 0, aPos stays the same) |
|
750 scale.iZero = ScaledEdge( aPos, aPrevScale.iZero, |
|
751 aPrevScale.iMin, aEdges.iMin ); |
|
752 } |
|
753 // adjust the upper edge to take into account the movement of zero pos |
|
754 scale.iMax = ScaledEdge( aPos, aPrevScale.iMax, |
|
755 aPrevScale.iZero, scale.iZero ); |
|
756 } |
|
757 else // ELarger |
|
758 { |
|
759 scale.iMax = aEdges.iMax; |
|
760 if ( aPos < aPrevScale.iZero ) |
|
761 { |
|
762 TReal32 proportionBelowZero = Proportion( aPos, aPrevScale.iZero, aPrevScale.iMin ); |
|
763 scale.iZero = aPos + ProportionalLength( aPos, aEdges.iMax, proportionBelowZero ); |
|
764 } |
|
765 else |
|
766 { |
|
767 // adjust zero pos so that proportion between aPos, Max, and Zero pos |
|
768 // stay the same (Max will move edge, aPos stays the same) |
|
769 scale.iZero = ScaledEdge( aPos, aPrevScale.iZero, |
|
770 aPrevScale.iMax, aEdges.iMax ); |
|
771 } |
|
772 // adjust the lower edge to take into account the movement of zero pos |
|
773 scale.iMin = ScaledEdge( aPos, aPrevScale.iMin, |
|
774 aPrevScale.iZero, scale.iZero ); |
|
775 } |
|
776 } |
|
777 return scale; |
|
778 } |
|
779 |
|
780 /** Edges in x and y dimensions */ |
|
781 NONSHARABLE_STRUCT( TEdges2D ) |
|
782 { |
|
783 TEdges iX; |
|
784 TEdges iY; |
|
785 }; |
|
786 |
|
787 /** |
|
788 * @param aEdges edges of the area in which gesture points are accepted |
|
789 * @return the scale of latest point in the list of points |
|
790 */ |
|
791 TScale2D Scale( const RArray< TPointEntry >& aPoints, const TEdges2D& aEdges ) |
|
792 { |
|
793 TScale2D scale = { TScale( aPoints[0].iPos.iX, aEdges.iX ), |
|
794 TScale( aPoints[0].iPos.iY, aEdges.iY ) }; |
|
795 TInt count = aPoints.Count(); |
|
796 if ( count > 1 ) |
|
797 { |
|
798 // iterate the whole point list to arrive to the current scale |
|
799 TDirection2D dir( Direction( 1, aPoints ) ); |
|
800 for ( TInt i = 1; i < count; i++ ) |
|
801 { |
|
802 // get direction at i |
|
803 TDirection2D newDir( Direction( i, aPoints ) ); |
|
804 // get new scale at i |
|
805 scale.iX = Rescale( aPoints[i - 1].iPos.iX, newDir.iX, dir.iX, scale.iX, aEdges.iX ); |
|
806 scale.iY = Rescale( aPoints[i - 1].iPos.iY, newDir.iY, dir.iY, scale.iY, aEdges.iY ); |
|
807 dir = newDir; |
|
808 } |
|
809 } |
|
810 return scale; |
|
811 } |
|
812 } // unnamed namespace |
|
813 |
|
814 TRealPoint CGesture::SpeedPercent( const TRect& aEdges ) const |
|
815 { |
|
816 // x and y coordinates are easier to handle separately, extract from TRect: |
|
817 // ((iMinX, iMinY), (iMaxX, iMaxY)) -> ((iMinX, iMaxX), (iMinY, iMaxY)) |
|
818 TEdges2D edges = { { aEdges.iTl.iX, aEdges.iBr.iX }, |
|
819 { aEdges.iTl.iY, aEdges.iBr.iY } }; |
|
820 // work out the current scale (coordinate -> percentage mapping) from |
|
821 // the history of points (i.e., points of current gesture). Then |
|
822 // calculate the percentage of the current position. |
|
823 return Scale( iPoints, edges ).Percent( CurrentPos() ); |
|
824 } |
|
825 |
|
826 // ---------------------------------------------------------------------------- |
|
827 // Speed |
|
828 // ---------------------------------------------------------------------------- |
|
829 // |
|
830 TRealPoint CGesture::Speed() const |
|
831 { |
|
832 const TReal32 KMicroSecondsInSecond = 1000000; |
|
833 |
|
834 // Speed is only evaluated at the end of the swipe |
|
835 // if user stops at the end of the swipe before lifting stylus, |
|
836 // speed is zero. If time is zero, return 0 speed (infinite does |
|
837 // not make sense either). Will need to consider also earlier points |
|
838 // and their times or start time, if this zero-speed behavior is a problem |
|
839 TRealPoint speed; |
|
840 TReal32 time = static_cast<TReal32>( TimeFromPreviousPoint().Int() ) |
|
841 / KMicroSecondsInSecond; |
|
842 if ( !IsMovementStopped() && time > 0 ) |
|
843 { |
|
844 TPoint distance = CurrentPos() - PreviousPos(); |
|
845 speed.iX = static_cast<TReal32>( distance.iX ) / time; |
|
846 speed.iY = static_cast<TReal32>( distance.iY ) / time; |
|
847 } |
|
848 return speed; |
|
849 } |
|
850 |
|
851 // ---------------------------------------------------------------------------- |
|
852 // Distance |
|
853 // ---------------------------------------------------------------------------- |
|
854 // |
|
855 TPoint CGesture::Distance() const |
|
856 { |
|
857 return CurrentPos() - StartPos(); |
|
858 } |
|
859 |
|
860 // ---------------------------------------------------------------------------- |
|
861 // Visual |
|
862 // ---------------------------------------------------------------------------- |
|
863 // |
|
864 CAlfVisual* CGesture::Visual() const |
|
865 { |
|
866 return iVisual; |
|
867 } |
|
868 |
|
869 // ---------------------------------------------------------------------------- |
|
870 // TimeFromPreviousPoint |
|
871 // ---------------------------------------------------------------------------- |
|
872 // |
|
873 inline TTimeIntervalMicroSeconds32 CGesture::TimeFromPreviousPoint() const |
|
874 { |
|
875 const TInt KLatestEntryOffset = 1; |
|
876 return Elapsed( PreviousEntry().iTime, NthLastEntry( KLatestEntryOffset ).iTime ); |
|
877 } |
|
878 |
|
879 // ---------------------------------------------------------------------------- |
|
880 // return nth point from the end of the points array |
|
881 // ---------------------------------------------------------------------------- |
|
882 // |
|
883 inline const TPointEntry& CGesture::NthLastEntry( TInt aOffset ) const |
|
884 { |
|
885 return iPoints[ Max( iPoints.Count() - aOffset, 0 ) ]; |
|
886 } |
|
887 |
|
888 // ---------------------------------------------------------------------------- |
|
889 // PreviousEntry |
|
890 // ---------------------------------------------------------------------------- |
|
891 // |
|
892 inline const TPointEntry& CGesture::PreviousEntry() const |
|
893 { |
|
894 return NthLastEntry( KPreviousPointOffset ); |
|
895 } |
|
896 |
|
897 // ---------------------------------------------------------------------------- |
|
898 // PreviousPos |
|
899 // ---------------------------------------------------------------------------- |
|
900 // |
|
901 inline TPoint CGesture::PreviousPos() const |
|
902 { |
|
903 return PreviousEntry().iPos; |
|
904 } |
|
905 |
|
906 // ---------------------------------------------------------------------------- |
|
907 // PinchPercent |
|
908 // ---------------------------------------------------------------------------- |
|
909 // |
|
910 TInt CGesture::PinchPercent() const |
|
911 { |
|
912 // Added 0.5 to avoid 5.7 getting rounded off to 5. |
|
913 return (iPinchEndDistance*100/iPinchStartDistance) + 0.5; |
|
914 } |
|
915 |
|
916 // ---------------------------------------------------------------------------- |
|
917 // PinchCentrePoint |
|
918 // ---------------------------------------------------------------------------- |
|
919 // |
|
920 TPoint CGesture::PinchCentrePoint() const |
|
921 { |
|
922 if( iPoints.Count() <= 0 || iSecondaryPoints.Count() <= 0 ) |
|
923 { |
|
924 return TPoint(0,0); |
|
925 } |
|
926 return TPoint( (iPoints[0].iPos.iX + iSecondaryPoints[0].iPos.iX)/2, (iPoints[0].iPos.iY + iSecondaryPoints[0].iPos.iY)/2); |
|
927 } |
|
928 |
|
929 // end of file |
|
930 |
|