--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/qstmgesturelib/qstmgestureapi.cpp Tue May 04 12:39:35 2010 +0300
@@ -0,0 +1,708 @@
+/*
+* Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "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 Library: Framework
+#include <qstmgestureengine.h>
+#include <qstmstatemachine.h>
+// Gesture Library: Recognizers
+#include <qstmtapgesturerecogniser.h>
+#include <qstmpangesturerecogniser.h>
+#include <qstmhoveringgesturerecogniser.h>
+#include <qstmedgescrollgesturerecogniser.h>
+#include <qstmlongpressgesturerecogniser.h>
+#include <qstmpinchgesturerecogniser.h>
+#include <qstmtouchgesturerecogniser.h>
+#include <qstmreleasegesturerecogniser.h>
+#include <qstmleftrightgesturerecogniser.h>
+#include <qstmupdowngesturerecogniser.h>
+#include <qstmflickgesturerecogniser.h>
+#include <qstmunknowngesturerecogniser.h>
+#include <qstmzoomgesturerecogniser.h>
+
+#include <qstmgestureapi.h>
+#include <qstmgestureevent.h>
+#include <QtGui>
+
+using namespace qstmGesture;
+using namespace qstmUiEventEngine;
+
+QStm_GestureParameters::QStm_GestureParameters()
+{
+}
+
+QStm_GestureParameters::QStm_GestureParameters(const QStm_GestureParameters& params )
+{
+ memcpy(&m_param[0], ¶ms.m_param[0], sizeof(m_param));
+ memcpy(&m_areaSettings[0], ¶ms.m_areaSettings[0], sizeof(m_areaSettings));
+ memcpy(&m_enabled[0], ¶ms.m_enabled[0], sizeof(m_enabled));
+}
+
+
+QStm_GestureEngineApi::QStm_GestureEngineApi()
+{
+ init();
+}
+
+void QStm_GestureEngineApi::init()
+{
+ //m_gf = new QStm_GestureFramework();
+ m_gestureEngine = new QStm_GestureEngine();
+ m_statemachine = new QStm_StateMachine();
+ m_statemachine->addUiEventObserver(m_gestureEngine);
+ m_config = new QStm_GestureParameters();
+}
+
+QStm_GestureEngineApi::~QStm_GestureEngineApi()
+{
+ // Prevent reactivation of contexts as they remove themselves
+ m_dtorPhase = true;
+
+ qDeleteAll(m_contexts.begin(), m_contexts.end());
+ m_contexts.clear();
+ m_ctxtStack.clear();
+ delete m_config;
+ delete m_gestureEngine;
+ delete m_statemachine;
+}
+
+QStm_GestureContext* QStm_GestureEngineApi::createContext(int /*aId*/ )
+{
+ QStm_GestureContext* ctxt = new QStm_GestureContext(*this);
+ return ctxt;
+}
+
+QStm_GestureContext* QStm_GestureEngineApi::context(int /*aId*/ )
+{
+ return NULL;
+}
+
+void QStm_GestureEngineApi::enableContext(QStm_GestureContext& context )
+{
+ // NB: enabling context puts it on top of the Context Stack
+ int idx = m_ctxtStack.indexOf(&context);
+ if(idx >= 0) {
+ m_ctxtStack.removeAt(idx);
+ }
+
+ setupRecognizers(context, true);
+
+ m_ctxtStack.append(&context);
+}
+
+void QStm_GestureEngineApi::disableContext(QStm_GestureContext& context )
+{
+ int idx = m_ctxtStack.indexOf(&context);
+
+ if(idx == -1) {
+ return;
+ }
+
+ m_ctxtStack.removeAt(idx);
+
+ for(int i = 0; i < qstmGesture::EStmGestureUid_Count; ++i) {
+ qstmGesture::QStm_GestureRecogniserIf* rec = context.m_recognizers[i];
+ if(rec) {
+ m_gestureEngine->removeGesture(rec);
+ }
+ }
+/* OK: we need to decide semantics of the GestureContext concept:
+ - is only one is active at a time?
+ - is there a stack of them
+ OR
+ - application activates and deactivates them as needed
+ - GestureEngine only ensures that proper order of recognizers is used
+
+ Disabled code below, because it doesn't allow porting of the stmProto demo,
+ where two TestContainer are used, each with own gesture context, simultaneously.
+
+ If app uses only one context, then this change doesn't break anything
+
+ // re-activate previous (new top-most) context
+ // NB: if deleted context is not top-most (active) one, no updates done
+ TInt count = m_ctxtStack.Count();
+ if(idx == count && count > 0 && !m_dtorPhase)
+ {
+ QStm_GestureContext* previous = m_ctxtStack[count - 1];
+ setupRecognizers(*previous, EFalse);
+ }
+*/
+}
+
+template<class T>
+void QStm_GestureEngineApi::initRecognizer(T*& gesture, QStm_GestureContext& context, bool isNewCtx )
+{
+ qstmGesture::QStm_GestureRecogniserIf*& recognizer = context.m_recognizers[T::KUid];
+ gesture = static_cast<T*>(recognizer);
+ if(!gesture && isNewCtx) {
+ recognizer = gesture = new T(&context);
+ recognizer->enableLogging((context.m_logging & (1<<T::KUid)) != 0);
+ }
+
+ // TODO: Add in right place according to gesture class
+ // Find similar (by Uid gesture, insert before it), otherwise add as last or
+ // before any known gestures that should follow after it (NOT IMPLEMENTED)
+
+ int pos = m_gestureEngine->findGesture(T::KUid);
+ bool added = m_gestureEngine->insertGesture(gesture, pos >= 0 ? pos : m_gestureEngine->gestureCount());
+ if(!added) {
+ // TODO: exception here?
+ }
+}
+
+void QStm_GestureEngineApi::setupRecognizers(QStm_GestureContext& context, bool isNewCtx )
+{
+ // Order of recognizers in the Gesture Engine (upper ones receive input before lower ones)
+ //
+ // PINCH
+ // CORNER_ZOOM
+ // EDGE_SCROLL
+ // LONGPRESS
+ // TOUCH
+ // UP_DOWN
+ // LEFT_RIGHT
+ // HOVER
+ // PAN
+ // TAP / DOUBLE_TAP
+ // FLICK
+ // RELEASE
+ // UNKNOWN
+
+ QStm_GestureParameters& conf = context.config();
+
+ bool filter = conf.param(qstmGesture::EEnableFiltering) != 0;
+
+ // TOUCH AREA
+ qstmGesture::QStm_GestureArea& touchArea = *(conf.area(qstmGesture::ETouchArea));
+ int touchAreaSizeInMm = touchArea.m_size.width();
+ m_statemachine->setTouchAreaShape ( qstmUiEventEngine::QStm_AreaShape(touchArea.m_shape) );
+ m_statemachine->setTouchArea ( !filter ? 0 : touchAreaSizeInMm );
+ m_statemachine->setTouchTimeout ( !filter ? 0 : touchArea.m_timeout);
+ int moveToleranceInMm = conf.param(qstmGesture::EMoveTolerance);
+ m_statemachine->setMoveTolerance(moveToleranceInMm);
+
+ QWidget* gestureContext = static_cast<QWidget*>(context.getOwner());
+ QRect ctxtRect = gestureContext ? gestureContext->rect() : QRect();
+ if(gestureContext) {
+ QPoint p = gestureContext->mapToGlobal(QPoint(0,0)) ;
+ ctxtRect.moveTo(p) ;
+ }
+
+ // ===================================================== PINCH
+ using qstmGesture::QStm_PinchGestureRecogniser;
+
+ if (conf.enabled(QStm_PinchGestureRecogniser::KUid)) {
+ QStm_PinchGestureRecogniser* gesture = NULL;
+ initRecognizer(gesture, context, isNewCtx);
+
+ if(gesture) {
+ qreal pspeed = conf.param(qstmGesture::EPinchSpeed) / 100.f;
+ gesture->setPinchingSpeed(pspeed);
+ }
+ }
+
+ // ===================================================== CORNER ZOOM
+ using qstmGesture::QStm_ZoomGestureRecogniser;
+
+ if (conf.enabled(QStm_ZoomGestureRecogniser::KUid)) {
+ QStm_ZoomGestureRecogniser* gesture = NULL;
+ initRecognizer(gesture, context, isNewCtx);
+
+ if(gesture) {
+ gesture->setArea(ctxtRect);
+ gesture->setRange(conf.param(qstmGesture::EZoomCornerSize));
+ }
+ }
+
+ // ===================================================== EDGE SCROLL
+ using qstmGesture::QStm_EdgeScrollGestureRecogniser;
+
+ if (conf.enabled(QStm_EdgeScrollGestureRecogniser::KUid)) {
+ QStm_EdgeScrollGestureRecogniser* gesture = NULL;
+ initRecognizer(gesture, context, isNewCtx);
+
+ if(gesture) {
+ gesture->setArea(ctxtRect);
+ gesture->setScrollRange(conf.param(qstmGesture::EEdgeScrollRange)); // range is 20 pixels from the edge TODO: add this to settings...
+ }
+ }
+
+ // ===================================================== LONG PRESS
+ using qstmGesture::QStm_LongPressGestureRecogniser;
+
+ if (conf.enabled(QStm_LongPressGestureRecogniser::KUid)) {
+ QStm_LongPressGestureRecogniser* gesture = NULL;
+ initRecognizer(gesture, context, isNewCtx);
+
+ if(gesture) {
+ gesture->setArea(ctxtRect);
+ }
+ }
+
+ // ===================================================== TOUCH
+ using qstmGesture::QStm_TouchGestureRecogniser;
+
+ if (conf.enabled(QStm_TouchGestureRecogniser::KUid)) {
+ QStm_TouchGestureRecogniser* gesture = NULL;
+ initRecognizer(gesture, context, isNewCtx);
+
+ if(gesture) {
+ // define empty area so that touch is reported only inside
+ // our window (touch recognizer handles either an area or the target window)
+ gesture->setArea(QRect());
+ }
+ }
+
+ // ===================================================== LEFT-RIGHT
+ using qstmGesture::QStm_LeftrightGestureRecogniser;
+
+ if (conf.enabled(QStm_LeftrightGestureRecogniser::KUid)) {
+ QStm_LeftrightGestureRecogniser* gesture = NULL;
+ initRecognizer(gesture, context, isNewCtx);
+ }
+
+ // ===================================================== UP-DOWN
+ using qstmGesture::QStm_UpdownGestureRecogniser;
+
+ if (conf.enabled(QStm_UpdownGestureRecogniser::KUid)) {
+ QStm_UpdownGestureRecogniser* gesture = NULL;
+ initRecognizer(gesture, context, isNewCtx);
+ }
+
+ // ===================================================== HOVER
+ using qstmGesture::QStm_HoveringGestureRecogniser;
+
+ if (conf.enabled(QStm_HoveringGestureRecogniser::KUid)) {
+ QStm_HoveringGestureRecogniser* gesture = NULL;
+ initRecognizer(gesture, context, isNewCtx);
+ if(gesture) {
+ gesture->setHoveringSpeed(conf.param(qstmGesture::EHoverSpeed) / 100.f);
+ }
+ }
+
+ // ===================================================== PAN
+ using qstmGesture::QStm_PanGestureRecogniser;
+
+ if (conf.enabled(QStm_PanGestureRecogniser::KUid)) {
+ QStm_PanGestureRecogniser* gesture = NULL;
+ initRecognizer(gesture, context, isNewCtx);
+
+ if(gesture) {
+ gesture->setPanningSpeedLow ( conf.param(qstmGesture::EPanSpeedLow) / 100.f );
+ gesture->setPanningSpeedHigh( conf.param(qstmGesture::EPanSpeedHigh) / 100.f );
+ }
+ }
+
+ // ===================================================== RELEASE
+ using qstmGesture::QStm_ReleaseGestureRecogniser;
+
+ if (conf.enabled(QStm_ReleaseGestureRecogniser::KUid)) {
+ QStm_ReleaseGestureRecogniser* gesture = NULL;
+ initRecognizer(gesture, context, isNewCtx);
+
+ if(gesture) {
+ gesture->setArea(QRect());
+ }
+ }
+
+
+ // ===================================================== TAP / DOUBLE TAP
+ // Add recognizer before any existing Flick, Release, Unknown
+ // Add the gesture to the gesture engine
+ using qstmGesture::QStm_TapGestureRecogniser;
+
+ if (conf.enabled(QStm_TapGestureRecogniser::KUid)) {
+ int pos = m_gestureEngine->findGesture(QStm_TapGestureRecogniser::KUid);
+ QStm_TapGestureRecogniser* gesture = NULL;
+
+ if (pos > -1) {
+ gesture = static_cast<QStm_TapGestureRecogniser*>(m_gestureEngine->gestureAt(pos));
+ gesture->addTapListener(&context, context.getOwner());
+ gesture->addDoubleTapListener(&context, context.getOwner());
+ }
+ else {
+ initRecognizer(gesture, context, isNewCtx);
+ }
+
+ if(gesture) {
+ gesture->setDoubleTapTimeout(conf.param(qstmGesture::EDoubleTapTimeout));
+ gesture->setDoubleTapRange( touchAreaSizeInMm );
+ gesture->ignoreFirstTap(false);
+ }
+ }
+
+ // ===================================================== FLICK
+ using qstmGesture::QStm_FlickGestureRecogniser;
+
+ if (conf.enabled(QStm_FlickGestureRecogniser::KUid)) {
+ QStm_FlickGestureRecogniser* gesture = NULL;
+ initRecognizer(gesture, context, isNewCtx);
+
+ if(gesture) {
+ qreal flickSpeed = conf.param(qstmGesture::EFlickSpeed) / 100.f;
+ gesture->setFlickingSpeed(flickSpeed);
+ }
+ }
+
+ // ===================================================== UNKNOWN
+ using qstmGesture::QStm_UnknownGestureRecogniser;
+
+ if (conf.enabled(QStm_UnknownGestureRecogniser::KUid)) {
+ QStm_UnknownGestureRecogniser* gesture = NULL;
+ initRecognizer(gesture, context, isNewCtx);
+ }
+
+ // ===========================================================
+ if(isNewCtx) {
+ for(int i = 0; i < qstmGesture::EStmGestureUid_Count; ++i) {
+ qstmGesture::QStm_GestureRecogniserIf* rec = context.m_recognizers[i];
+ if(rec) {
+ rec->enableLogging(context.m_logging & (1<<i)) ;
+ }
+ }
+ }
+
+
+ // HOLD AREA
+ qstmGesture::QStm_GestureArea& holdArea = *conf.area(qstmGesture::EHoldArea);
+ int holdAreaSizeInMm = holdArea.m_size.width();
+ m_statemachine->setHoldAreaShape ( qstmUiEventEngine::QStm_AreaShape(holdArea.m_shape) );
+ m_statemachine->setHoldArea ( !filter ? 0 : holdAreaSizeInMm );
+ m_statemachine->setHoldTimeout ( !filter ? 0 : holdArea.m_timeout);
+
+ // TOUCH-TIME AREA
+ qstmGesture::QStm_GestureArea& tTimeArea = *conf.area(qstmGesture::ETouchTimeArea);
+ int tTimeAreaSizeInMm = tTimeArea.m_size.width();
+ // NB: shape <-- TouchAreaShape
+ m_statemachine->setTouchTimeArea ( !filter ? 0 : tTimeAreaSizeInMm );
+
+ // Timeouts, Adjustments, etc.
+ m_statemachine->setTouchSuppressTimeout(!filter ? 0 : conf.param(qstmGesture::ESuppressTimeout)*1000) ;
+ m_statemachine->setMoveSuppressTimeout(!filter ? 0 : conf.param(qstmGesture::EMoveSuppressTimeout)*1000) ;
+ m_statemachine->enableCapacitiveUp (!filter ? 0 : conf.param(qstmGesture::ECapacitiveUpUsed));
+ m_statemachine->enableYadjustment (!filter ? 0 : conf.param(qstmGesture::EAdjustYPos));
+ m_statemachine->enableLogging(context.m_logging);
+}
+
+// =============================================================
+
+QStm_GestureContext::QStm_GestureContext(QStm_GestureEngineApi& engine ) :
+ m_engine(engine),
+ m_isActivated(false),
+ m_ownerControl(NULL),
+ m_config(NULL)
+
+{
+ init();
+}
+
+void QStm_GestureContext::init()
+{
+ m_engine.m_contexts.append(this);
+ m_config = new QStm_GestureParameters();
+ m_engine.getStateMachine()->addUiEventObserver(this);
+
+ for(int i = 0; i < qstmGesture::EStmGestureUid_Count; ++i) {
+ m_recognizers[i] = NULL;
+ }
+
+}
+
+QStm_GestureContext::~QStm_GestureContext()
+{
+ // Remove all gesture listeners
+ for(int i = m_listeners.count() - 1; i >= 0; --i) {
+ QStm_GestureListenerApiIf* listener = m_listeners[i];
+ m_listeners.removeAt(i);
+ listener->handleGestureListenerRemoved();
+ }
+
+ m_listeners.clear();
+
+ // Remove all context's recognizers from the Gesture Engine
+ deactivate();
+
+ // Destroy all recognizers
+ for(int r = 0; r < qstmGesture::EStmGestureUid_Count; ++r) {
+ qstmGesture::QStm_GestureRecogniserIf*& rec = m_recognizers[r];
+ if(rec) {
+ delete rec;
+ rec = NULL;
+ }
+ }
+
+ // Remove context from the Gesture Engine
+ int idx = m_engine.m_contexts.indexOf(this);
+ if(idx != -1) {
+ m_engine.m_contexts.removeAt(idx);
+ }
+
+ delete m_config;
+}
+
+void QStm_GestureContext::addListener(QStm_GestureListenerApiIf* listener, int pos)
+{
+ m_listeners.insert(pos, listener);
+}
+
+int QStm_GestureContext::removeListener(QStm_GestureListenerApiIf* listener )
+{
+ int ind = m_listeners.indexOf(listener);
+ if(ind >= 0) {
+ m_listeners.removeAt(ind);
+ }
+ return ind;
+}
+
+void QStm_GestureContext::setContext(void* control)
+{
+ m_ownerControl = control;
+
+ for(int i = 0; i < qstmGesture::EStmGestureUid_Count; ++i) {
+ QStm_GestureRecogniserIf* rec = m_recognizers[i];
+ if(rec) {
+ rec->setOwner(control);
+ }
+ }
+}
+
+void QStm_GestureContext::activate(void* control)
+{
+ setContext(control);
+ activate();
+}
+
+void QStm_GestureContext::activate()
+{
+ if(isActive()) {
+ // re-enable all recognizers
+ enableRecognizers();
+ return;
+ }
+
+ // 1. Tell Engine to deactivate active context
+
+ // 2. Setup all gesture recognizers
+ m_engine.enableContext(*this);
+
+ // 3. Notify listeners
+ enableRecognizers();
+
+ //
+ m_isActivated = true;
+}
+
+void QStm_GestureContext::deactivate()
+{
+ m_engine.disableContext(*this);
+ m_isActivated = false;
+}
+
+void QStm_GestureContext::gestureEnter(QStm_GestureIf& gesture )
+{
+ dispatchGestureEvent(gesture.gestureUid(), &gesture);
+}
+
+void QStm_GestureContext::gestureExit(QStm_GestureIf& gesture )
+{
+ dispatchGestureEvent(gesture.gestureUid(), NULL);
+}
+
+void* QStm_GestureContext::getOwner()
+{
+ return m_ownerControl;
+}
+
+QStm_Gesture* QStm_GestureContext::createQStmGesture(QStm_GestureUid uid,
+ QStm_GestureIf* gesture)
+{
+ QStm_Gesture* gest = new QStm_Gesture();
+ int stmGestType = gesture ? gesture->getType() : -1;
+
+ switch(uid) {
+ case qstmGesture::EGestureUidTap:
+ {
+ qstmGesture::QStm_TapType type = qstmGesture::QStm_TapType(stmGestType);
+ if (type == qstmGesture::ETapTypeDouble) {
+ gest->setGestureStmType(QStmDoubleTapGestureType);
+ }
+ else {
+ gest->setGestureStmType(QStmTapGestureType);
+ }
+ break;
+ }
+
+ case qstmGesture::EGestureUidTouch:
+ {
+ gest->setGestureStmType(QStmTouchGestureType);
+ break;
+ }
+
+ case qstmGesture::EGestureUidRelease:
+ {
+ gest->setGestureStmType(QStmReleaseGestureType);
+ break;
+ }
+
+ case qstmGesture::EGestureUidFlick:
+ {
+ gest->setGestureStmType(QStmFlickGestureType);
+ break;
+ }
+
+ case qstmGesture::EGestureUidLeftRight:
+ {
+ gest->setGestureStmType(QStmLeftRightGestureType);
+ break;
+ }
+
+ case qstmGesture::EGestureUidUpDown:
+ {
+ gest->setGestureStmType(QStmUpDownGestureType);
+ break;
+ }
+
+ case qstmGesture::EGestureUidPan:
+ {
+ gest->setGestureStmType(QStmPanGestureType);
+ break;
+ }
+
+ case qstmGesture::EGestureUidHover:
+ {
+ gest->setGestureStmType(QStmHoverGestureType);
+ break;
+ }
+
+ case qstmGesture::EGestureUidLongPress:
+ {
+ gest->setGestureStmType(QStmLongPressGestureType);
+ break;
+ }
+
+ case qstmGesture::EGestureUidEdgeScroll:
+ {
+ gest->setGestureStmType(QStmEdgeScrollGestureType);
+ break;
+ }
+
+ case qstmGesture::EGestureUidCornerZoom:
+ {
+ gest->setGestureStmType(QStmCornerZoomGestureType);
+ break;
+ }
+
+ case qstmGesture::EGestureUidPinch:
+ {
+ gest->setGestureStmType(QStmPinchGestureType);
+ break;
+ }
+ }
+
+ if (gesture) { //gesture enter
+ gest->setGestureSubType(gesture->getType());
+ gest->setDirection(gesture->getDirection());
+ QPoint vec = gesture->getLengthAndDirection();
+ gest->setLengthAndDirection(vec);
+ gest->setSpeed(gesture->getSpeed());
+ QPoint pos = gesture->getLocation();
+ gest->setPosition(pos);
+ gest->setDetails(gesture->getDetails());
+ gest->setSpeedVec(gesture->getSpeedVec());
+ QWidget* w = static_cast<QWidget*>(gesture->target());
+ gest->setTarget(w);
+ }
+ else {
+ gest->setGestureState(Qt::GestureFinished);
+ }
+
+ return gest;
+}
+
+void QStm_GestureContext::dispatchGestureEvent(qstmGesture::QStm_GestureUid uid,
+ qstmGesture::QStm_GestureIf* gesture )
+{
+ bool consumed = false;
+ bool suspended = false;
+
+
+
+ for(int i = 0; i < m_listeners.count(); ++i) {
+ QStm_GestureListenerApiIf* listener = m_listeners[i];
+ if(consumed) {
+ listener->handleGestureListenerSuppressed(uid, gesture);
+ }
+ else {
+ QStm_GestureListenerApiIf::QStm_ProcessingResult res = listener->handleGestureEvent(uid, gesture);
+ if(res & QStm_GestureListenerApiIf::EConsume) {
+ consumed = true; // TODO: maybe we should notify all previous listeners as well...
+ }
+
+ suspended |= (res & QStm_GestureListenerApiIf::ESuspend) != 0; // TODO: notify listeners?
+ }
+ }
+ if(suspended) {
+ suspendRecognizer(uid);
+ }
+}
+
+void QStm_GestureContext::suspendRecognizer(qstmGesture::QStm_GestureUid uid)
+{
+ qstmGesture::QStm_GestureRecogniserIf* rec = m_recognizers[uid];
+ if(rec && !rec->isEnabled()) {
+ rec->enable(false);
+ // TODO: Notify listener
+ }
+}
+
+void QStm_GestureContext::enableRecognizers()
+{
+ for(int i = 0; i < qstmGesture::EStmGestureUid_Count; ++i) {
+ enableRecognizer(qstmGesture::QStm_GestureUid(i));
+ }
+}
+
+void QStm_GestureContext::enableRecognizer(qstmGesture::QStm_GestureUid uid )
+{
+ qstmGesture::QStm_GestureRecogniserIf* rec = m_recognizers[uid];
+ if(rec && !rec->isEnabled()) {
+ rec->enable(true);
+ // TODO: Notify listener
+ }
+}
+
+
+void QStm_GestureContext::handleUiEvent( const qstmUiEventEngine::QStm_UiEventIf& event )
+{
+ emit(uiEvent(event));
+}
+
+
+bool QStm_GestureContext::handleSymbianPlatformEvent(const QSymbianEvent* platEvent)
+{
+ return m_engine.getStateMachine()->handleSymbianPlatformEvent(platEvent);
+}
+
+
+bool QStm_GestureContext::handleX11PlatformEvent(const XEvent* platEvent)
+{
+ return m_engine.getStateMachine()->handleX11PlatformEvent(platEvent);
+}
+
+
+