diff -r 000000000000 -r dd21522fd290 webengine/webkitutils/rt_gesturehelper/src/gesture.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/webengine/webkitutils/rt_gesturehelper/src/gesture.h Mon Mar 30 12:54:55 2009 +0300 @@ -0,0 +1,199 @@ +/* +* Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of the License "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: Gesture class +* +*/ + + +#ifndef _GESTURE_H_ +#define _GESTURE_H_ + +#include + +#include "rt_gestureobserver.h" +#include "gesturerecogniser.h" +#include "pointarray.h" + +namespace RT_GestureHelper +{ + + +enum TEventState + { + ENoEvent = 0, + ETouchDown, + ETouchUp, + EMove, + ELongTouchDown + }; + +/** + * TGesture represents the gesture that the user has made. + * Implements MGestureEvent interface to allow clients to + * inspect the gesture + */ +NONSHARABLE_CLASS( CGesture ) : public CBase + { +public: + /** destructor */ + ~CGesture(); + + /** + * @return a new gesture that will have only the first point + * of this gesture. Can be used to create gesture's a "start" event + * after some other points have been received. + */ + CGesture* AsStartEventLC() const; + + /** + * Sets the gesture as empty. resets timers to receive points + * immediately + */ + void Reset(); + + /** @return ETrue if the gesture has no points */ + TBool IsEmpty() const; + + /** + * Add a point to the sequence of points that forms the gesture + * Call Reset() just before adding the first point + * @param aPoint the point to add + * @return error code + */ + TInt AddPoint( const TPoint& aPoint, const TTime& eventtime); + + /** Set the visual of this gesture. Should be called when gesture starts */ + void SetVisual( CAlfVisual* aVisual ); + + /** @return ETrue if the point is very near the holding point */ + TBool IsNearHoldingPoint( const TPoint& aPoint ) const; + /** Set the latest point as the holding point */ + void SetHoldingPoint(); + /** @return ETrue if aPoint is the same as point added last */ + TBool IsLatestPoint( const TPoint& aPoint ) const; + + /** + * After call, Code(...) will return appropriate holding gesture code. + */ + void StartHolding(); + /** + * After call, Code(...) will return a "hold released" gesture code when + * the gesture is completed. Meanwhile, code will be drag. + */ + void ContinueHolding(); + /** Set as stylus released */ + void SetReleased(); + /** Set the gesture as complete. Gesture is completed at pointer up */ + void SetComplete(); + /** After call, Code(...) will return a "cancelled" gesture code */ + void SetCancelled(); + + /** force returning a code as double tap when gesture is complete */ + void SetDoubleTap(); + + /** + * @return Whether the current gesture is a tap (and hence not a swipe) + * Does not consider holding or other state information (such as + * whether the gesture was just started or is dragging). + * Results are based purely on the current stream of points. + */ + TBool IsTap() const; + + void SetLongTap(TBool aLongTap); + +// From MGestureEvent + TTime TimeOfLastEntry() const; + inline TGestureCode PreviousGestureCode() { return iPrevGestureCode; }; + TGestureCode Code( MGestureEvent::TAxis aRelevantAxis ); + TBool IsHolding() const; + TPoint StartPos() const; + TPoint CurrentPos() const; + TRealPoint Speed() const; + TRealPoint SpeedPercent( const TRect& aEdges ) const; + TPoint Distance() const; + CAlfVisual* Visual() const; + + + + +private: + /** @return elapsed time between the latest and previous points */ + inline TTimeIntervalMicroSeconds32 TimeFromPreviousPoint() const; + + /** @return elapsed time between the latest and first points */ + inline TTimeIntervalMicroSeconds32 TimeFromStart() const; + + /** @return ETrue if user has stopped moving the stylus before lifting it */ + inline TBool IsMovementStopped() const; + + /** @return aOffset'th last entry in the list of points */ + inline const TPointEntry& NthLastEntry( TInt aOffset ) const; + + /** @return previous point (may not be exactly the point before last) */ + inline const TPointEntry& PreviousEntry() const; + + /** @return position of point received just before the latest point */ + inline TPoint PreviousPos() const; + + + + TBool IsFlick() const; +private: + /// sequence of points that make up the gesture. own. + RArray< TPointEntry > iPoints; + /// index in iPoints of the point in which user started holding + TInt iHoldingPointIndex; + + /// the different states that indicate whether user has made a holding gesture + enum THoldingState + { + ENotHolding = 0, // before holding activated (i.e., holding not activated) + EHoldStarting, // holding activated just now (lasts just one callback round) + EHolding // holding activated earlier + }; + + /// state that indicates is user has held the pointer down in one position + /// for long time to indicate a holding gesture + THoldingState iHoldingState; + + /// Whether the gesture completion code will be forcefully overridden to be double tap, + /// regardless of what the points are + TBool iIsDoubleTap; + + enum TCompletionState + { + // Note: implementation assumes this order of enums + ENotComplete = 0, + ECancelled, + EComplete, + EReleased + }; + /// gesture only becomes complete when user lifts the pointer + TCompletionState iState; + + /// time when the stylus was lifted. + TTime iCompletionTime; + + /// visual relevant to this gesture. null if not known. + CAlfVisual* iVisual; + + TGestureCode iPrevGestureCode; + + TBool iIsLongTap; + TBool iIsStopFlick; + }; + +} // namespace GestureHelper + +#endif // _GESTURE_H_