--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/webengine/webkitutils/rt_gesturehelper/src/gesturehelperimpl.h Mon Mar 30 12:54:55 2009 +0300
@@ -0,0 +1,209 @@
+/*
+* Copyright (c) 2007 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 helper implementation
+*
+*/
+
+
+#ifndef _GESTUREHELPERIMPL_H_
+#define _GESTUREHELPERIMPL_H_
+
+#include <e32base.h>
+#include <coemain.h>
+#include <rt_gesturehelper.h>
+
+class CAlfEnv;
+class CAlfDisplay;
+class CAlfVisual;
+class TAlfEvent;
+
+struct TPointerEvent;
+
+namespace RT_GestureHelper
+{
+
+class CCallbackTimer;
+class CGesture;
+class CPointerCapturer;
+class MGestureObserver;
+class CGestureEventFilter;
+class CGestureEventSender;
+
+/**
+ * Implementation of CGestureHelper interface
+ */
+NONSHARABLE_CLASS( CGestureHelperImpl ) : public CBase
+ {
+public:
+ /** 2-phase constructor */
+ static CGestureHelperImpl* NewL( MGestureObserver& aObserver );
+
+ /** Destructor */
+ ~CGestureHelperImpl();
+
+ void InitAlfredPointerCaptureL( CAlfEnv& aEnv, CAlfDisplay& aDisplay,
+ TInt aFreeControlGroupId );
+
+ /** See @ref CGestureHelper::SetHoldingEnabled */
+ void SetHoldingEnabled( TBool aEnabled );
+ /** See @ref CGestureHelper::IsHoldingEnabled */
+ TBool IsHoldingEnabled() const;
+ /** See @ref CGestureHelper::SetDoubleTapEnabled */
+ void SetDoubleTapEnabled( TBool aEnabled );
+ /** See @ref CGestureHelper::IsDoubleTapEnabled */
+ TBool IsDoubleTapEnabled() const;
+ /** See @ref CGestureHelper::HandlePointerEventL */
+ TBool HandlePointerEventL( const TPointerEvent& aEvent );
+ /** See @ref CGestureHelper::OfferEventL */
+ TBool OfferEventL( const TAlfEvent& aEvent );
+ /** Reset helper state */
+ void Reset();
+
+ void SetLastEventTime() {iLastEventTime.HomeTime(); } /*CCoeEnv::Static()->LastEvent().Time();*/
+
+
+ TTime GetLastEventTime() const { return iLastEventTime; }
+private:
+ /** Constructor */
+ CGestureHelperImpl( MGestureObserver& aObserver );
+
+ /**
+ * Analyse how the pointer event affects the current gesture, and potentially
+ * notify the observer.
+ * @param aVisual visual on which the event fell on or NULL if not known
+ * @return ETrue if the event was consumed
+ */
+ TBool HandlePointerEventL( const TPointerEvent& aEvent, CAlfVisual* aVisual );
+
+ TBool noneAlf_HandlePointerEventL( const TPointerEvent& aEvent);
+
+ /** @return ETrue if the helper has not started processing a gesture */
+ inline TBool IsIdle() const;
+ /** Add a point to the sequence of points that make up the gesture */
+ inline void AddPointL( const TPointerEvent& aEvent );
+ /** Add a point to the sequence of points that make up the gesture */
+ inline TInt AddPoint( const TPointerEvent& aEvent );
+ /** Activates holding and notifies observer that holding has been started */
+ void StartHoldingL();
+ /* Set previous tag gesture to null (and recycle the gesture object) */
+ static void RecyclePreviousTapGesture( TAny* aSelf );
+ /** Emits a tap event since second tap of a double tap was not received within timeout */
+ void EmitFirstTapEventL();
+ /** Emit the start gesture event that aGesture would have produced */
+ void EmitStartEventL( const CGesture& aGesture );
+ /**
+ * Send code event if not holding. Also sets the event to released and emits again.
+ * Modifies aGesture!
+ */
+ void CompleteAndEmitL( CGesture& aGesture );
+ /**
+ * Send cancel event about the latest gesture client was notified about
+ * Sets the latest gesture to Cancelled.
+ */
+ void EmitCancelEventL();
+
+ /**
+ * Send Released event
+ */
+ void EmitReleasedEventL();
+
+ /** Notify observer of the gesture */
+ void EmitEventL( const CGesture& aGesture );
+ /**
+ * (re)start holding timer at the current point.
+ * Does not restart holding if the point (in aEvent) is near enough to where holding
+ * was started earlier. (Allows small movement but still starting holding.
+ */
+ void StartHoldingTimer( const TPointerEvent& aNewEvent );
+
+ /**
+ * @return a gesture object from the gesture pool
+ * Getting gestures from the gesture pool avoids the need to create gestures
+ * after construction. There is max only one gesture object in the pool,
+ * but no more is needed
+ */
+ CGesture* NewGesture();
+ /** Move the gesture into the gesture pool, and set aGesturePointer to null */
+ void RecycleGesture( CGesture*& aGesturePointer );
+
+
+ void HandleTouchUpL(const TPointerEvent& aEvent);
+ void HandleTouchDownL(const TPointerEvent& aEvent);
+ void HandleMoveL(const TPointerEvent& aEvent);
+ void HandleLongTouchL();
+ void EmitDoubleTapEventL();
+ TBool IsMovementGesture(TGestureCode aCode);
+
+private:
+ /// Gesture is the logical representation of a sequence of points arriving
+ /// at certain times
+ /// This is the current gesture
+ CGesture* iGesture;
+
+ /// Tap gesture of the previous gesture. Used when double tap is enabled.
+ /// The gesture is cached, since it cannot be emitted until gesture helper
+ /// knows whether the next gesture forms a double tap
+ /// @see CGestureHelperImpl::iDoubleTapTimer
+ CGesture* iPreviousTapGesture;
+
+ /// This is a recyclable object pool with just one object.
+ /// This class needs one or two gesture objects at any one time. There is one
+ /// less error condition to handle if gesture objects are not created after
+ /// construction. Therefore, if only one gesture object is needed at a specific,
+ /// point in time, the unused gesture object is stored here.
+ CGesture* iUnusedGesture;
+
+ /// When double tap is enabled, a tap
+ /// event (and it's released event) is only emitted after the double tap timeout
+ /// passes. If user taps again before the timeout (in the same position),
+ /// this gesture is emitted as a double tap (followed by the released event,
+ /// and the second tap is not emitted at all.
+ /// If user taps, and then swipes before the double tap timeout, this tap
+ /// event (and it's released event) event is emitted, and only then the swipe's
+ /// down and drag events are emitted. In other words, if user presses down
+ /// during the timeout, the down event it not emitted until the gesture
+ /// helper knows that the gesture is not another tap.
+ /// Behavior while double tap enabled:
+ /// Swipe: Down + drag + up => emits down + swipe/cancel + released
+ /// Tap: Down + up => emits down ... timeout ... + tap + released
+ /// Double tap: Down + up + down + up => emits down ... double tap + released
+ /// Tap + quick swipe: Down + up + down + drag + ... => emits down ... tap + up (for tap) + down (for swipe ) + drag + ...
+ /// Double tap timer is cancelled when the second pointer down event is received,
+ /// i.e., it does not matter if user does this:
+ /// down + up + down ... long wait ... + up. It's still a double tap.
+ CCallbackTimer* iDoubleTapTimer;
+
+ /// holding is activated when user keeps pointer down in the same place for
+ /// a longer period. the holding timer activates off when enough time has passed.
+ CCallbackTimer* iHoldingTimer;
+
+ /// observer for gesture events
+ MGestureObserver& iObserver;
+
+ /// captures subsequent pointer events after pointer down received,
+ /// until pointer up
+ CPointerCapturer* iPointerCapturer;
+
+ TTime iLastEventTime;
+ TTime iLastTouchUpTime;
+ TTime iLastDoubleTapTime;
+
+ CCallbackTimer* iLongTouchTimer;
+ CGestureEventFilter* iEventFilter;
+ CGestureEventSender* iEventSender;
+ };
+
+} // GestureHelper
+
+#endif // _GESTUREHELPERIMPL_H_