diff -r 6297cdf66332 -r d39add9822e2 web_plat/stmgesturefw_api/inc/stmgestureinterface.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/web_plat/stmgesturefw_api/inc/stmgestureinterface.h Tue Feb 02 00:56:45 2010 +0200 @@ -0,0 +1,300 @@ +/* +* Copyright (c) 2008 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: +* +*/ + + +#ifndef __STMGESTUREINTERFACE_H__ +#define __STMGESTUREINTERFACE_H__ + +#include +#include +#include +#include +#include + +// FORWARD DECLARATION +namespace stmGesture +{ + class CGestureFramework; + class MGestureRecogniserIf; +} + +class CStmGestureContext; +class MStmGestureListener; + +typedef stmGesture::MGestureIf MStmGesture; +typedef stmGesture::TGestureUid TStmGestureUid; +typedef stmGesture::MGestureListener MStmGestureEngineListener; +typedef stmGesture::MGestureRecogniserIf MStmGestureRecogniser; +typedef stmGesture::TGestureSettings TStmGestureSettings; +typedef stmGesture::TGestureAreaSettings TStmGestureAreaSettings; +typedef stmGesture::TGestureArea TStmGestureArea; + +///================================================================== + +/** + * Interface class for defining gesture settings parameters + */ +class MStmGestureParameters + { +public: + virtual TStmGestureArea* Area(TStmGestureAreaSettings aArea) = 0; + virtual TInt Param(TStmGestureSettings aParam) const = 0; + virtual TUint8 Enabled(TStmGestureUid aGesture) const = 0; + }; + +///================================================================== + +/** + * Class definition for gesture settings parameters + */ +NONSHARABLE_CLASS( CStmGestureParameters ): public CBase, public MStmGestureParameters + { +public: + /*! + * Constructors + */ + IMPORT_C CStmGestureParameters(); + IMPORT_C CStmGestureParameters(const CStmGestureParameters& aParams); + +public: //getter methods + + /*! + * To get the area settings + */ + TStmGestureArea* Area(TStmGestureAreaSettings aArea) { return &iAreaSettings[aArea]; } + + /*! + * To get Gesture params + */ + TInt Param(TStmGestureSettings aParam) const { return iParam[aParam]; } + + /*! + * Gesture enabled or not + */ + TUint8 Enabled(TStmGestureUid aGesture) const { return iEnabled[aGesture] != 0; } + +public: // setter methods + + /*! + * To set the parameters + */ + void SetParam(TStmGestureSettings aParam, TInt aValue) { iParam[aParam] = aValue; } + + /*! + * To enable or disble the gestures + */ + void SetEnabled(TStmGestureUid aGesture, TUint8 aParam) { iEnabled[aGesture] = aParam; } + + /*! + * Gesture settings + */ + TInt& operator[](TStmGestureSettings aParam) { return iParam[aParam]; } + +private: + TInt iParam[stmGesture::EGestureSettingsCount]; + TStmGestureArea iAreaSettings[stmGesture::EGestureAreaSettingsCount]; + TInt iModified; + TUint8 iEnabled[stmGesture::EStmGestureUid_Count]; + }; + +///================================================================== + +/** + * CStmGestureEngine Class Declaration + */ +NONSHARABLE_CLASS( CStmGestureEngine ): public CBase + { +public: + + /*! + * Gesture Engine Creation + */ + IMPORT_C static CStmGestureEngine* NewL(); + ~CStmGestureEngine(); + +public: + + /*! + * To Create a context in gesture engine + */ + IMPORT_C CStmGestureContext* CreateContextL(TInt aId); + + /*! + * To get the context + */ + IMPORT_C CStmGestureContext* Context(TInt aId); + + /*! + * Application use HandlePointerEventL API to pass the raw hardware events to the gesture library + */ + IMPORT_C void HandlePointerEventL(const TPointerEvent& aPointerEvent, void* target); + +private: + + /*! + * default constructor + */ + CStmGestureEngine(); + + /*! + * Two-phase constructor + */ + void ConstructL(); + +private: // used by friend class CStmGestureContext + + void EnableContextL(CStmGestureContext& aCtxt); + void DisableContextL(CStmGestureContext& aCtxt); + + template + void InitRecognizerL( T*& aGesture, CStmGestureContext& aContext, TBool aNewCOntext); + + void SetupRecognizersL(CStmGestureContext& aCtxt, TBool aNewContext); + +private: + friend class CStmGestureContext; + stmGesture::CGestureFramework* iGf; + // Registered/owned contexts + RPointerArray iContexts; + // Active set of contexts; latest added defines parameters + RPointerArray iCtxtStack; + // Global/default parameters + CStmGestureParameters* iConfig; + TBool iDtorPhase; + }; + +///================================================================== + +//Forward declaration +class CGestureEventSender; + +/** + * Gesture context represents a certain configuration of gesture parameters + * (including what gestures are enabled) and gesture listeners. + * Context can be created beforehand and reused later. + * The assumed use of a context is to have rough correspondence between + * UI view and enabled gestures. + * + * @note Gesture contexts are created by an instance of CStmGestureEngine. + */ + +class CStmGestureContext: public CBase, public MStmGestureEngineListener + { +public: + /*! + * Constructor + */ + CStmGestureContext(CStmGestureEngine& aEngine); + + ~CStmGestureContext(); + +public: /// Gesture listeners + + /*! + * Add listener to the gesture processing context. + * @param aListener Listener object + * @param aPos Position of inserted listener which determines order in which it receives gesture events (0 == first, before existing) + */ + IMPORT_C void AddListenerL(MStmGestureListener* aListener, TInt aPos = 0); + + /*! + * Remove listener from the gesture processing context. + * @param aListener Listener object + */ + IMPORT_C TInt RemoveListener(MStmGestureListener* aListener); + + /*! + * To get the list of listeners + */ + const RPointerArray& Listeners() const { return iListeners; } + +public: /// Context activation + + /*! + * To set the context configuration in Gesture Engine. + */ + IMPORT_C void SetContext(CCoeControl* aControl); + + /*! + * Initialize context configuration on the Gesture Engine. + */ + IMPORT_C void ActivateL(); + + /*! + * deactivate context configuration on the Gesture Engine. + */ + IMPORT_C void Deactivate(); + + /*! + * gesture configuration + */ + CStmGestureParameters& Config() { return *iConfig; } + + /*! + * Enable Logging + */ + void SetLogging(TInt aEnabled) { iLogging = aEnabled; } + + /*! + * Context control + */ + CCoeControl* ContextControl() { return iOwnerControl; } + + /*! + * is gesture context is active ? + */ + TBool IsActive() { return iActivated; } + + /*! + * Context id + */ + TInt Id() const { return iCtxtId; } + +public: // from MStmGestureEngineListener + + void gestureEnter(MStmGesture& aGesture); + void gestureExit(TStmGestureUid aGestureUid); + CCoeControl* getOwner(); + +private: + friend class CStmGestureEngine; + + void ConstructL(); + void DispatchGestureEventL(TStmGestureUid aUid, MStmGesture* aGesture); + void SuspendRecognizer(TStmGestureUid aUid); + void EnableRecognizersL(); + void EnableRecognizerL(TStmGestureUid aUid); + +private: + CStmGestureEngine& iEngine; + // Application-specific ID for finding context + TInt iCtxtId; + TBool iActivated; + CStmGestureParameters* iConfig; + CCoeControl* iOwnerControl; + //TBool iPinchUsed; + RPointerArray iListeners; + // for simplicity of addressing recognizers, we'll use fixed array + // with UID-based index (range 0..N is assumed for UIDs) + // @note Tap recognizer actually produces Tap and DoubleTap gesture, + // so should be handled carefully -- only Tap position is set + MStmGestureRecogniser* iRecognizers[stmGesture::EStmGestureUid_Count]; + TBool iLogging; + CGestureEventSender* iEventSender; + }; + +#endif