FCL/sf/app/browserui: comparison qstmgesturelib/qstmgestureapi.cpp

equal deleted inserted replaced

-:6aeb7a756187
+:3c88a81ff781
 #include <qstmleftrightgesturerecogniser.h>
 #include <qstmupdowngesturerecogniser.h>
 #include <qstmflickgesturerecogniser.h>
 #include <qstmunknowngesturerecogniser.h>
 #include <qstmzoomgesturerecogniser.h>
+#include <qstmmaybetapgesturerecogniser.h>
 #include <qstmgestureapi.h>
 #include <qstmgestureevent.h>
 #include <QtGui>
 memcpy(&m_areaSettings[0], &params.m_areaSettings[0], sizeof(m_areaSettings));
 memcpy(&m_enabled[0], &params.m_enabled[0], sizeof(m_enabled));
 }
-QStm_GestureEngineApi::QStm_GestureEngineApi()
+QStm_GestureEngineApi::QStm_GestureEngineApi() : m_gestureEngine(0), m_statemachine(0), m_config(0)
 {
 	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();
+	//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_config;
 delete m_gestureEngine;
 delete m_statemachine;
 }
 QStm_GestureContext* QStm_GestureEngineApi::createContext(int /*aId*/ )
 m_statemachine->setTouchArea      ( !filter ? 0 : touchAreaSizeInMm );
 m_statemachine->setTouchTimeout   ( !filter ? 0 : touchArea.m_timeout);
 int moveToleranceInMm = conf.param(qstmGesture::EMoveTolerance);
 m_statemachine->setMoveTolerance(moveToleranceInMm);
+qreal axisLock = conf.param(qstmGesture::EAxisLockThreshold) /100.f;
 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) ;
 using qstmGesture::QStm_LeftrightGestureRecogniser;
 if (conf.enabled(QStm_LeftrightGestureRecogniser::KUid)) {
 QStm_LeftrightGestureRecogniser* gesture = NULL;
 initRecognizer(gesture, context, isNewCtx);
+gesture->setAxisLockThreshold(axisLock);
 }
 // ===================================================== UP-DOWN
 using qstmGesture::QStm_UpdownGestureRecogniser;
 if (conf.enabled(QStm_UpdownGestureRecogniser::KUid)) {
 QStm_UpdownGestureRecogniser* gesture = NULL;
 initRecognizer(gesture, context, isNewCtx);
+gesture->setAxisLockThreshold(axisLock);
 }
 // ===================================================== HOVER
 using qstmGesture::QStm_HoveringGestureRecogniser;
 gesture->setPanningSpeedLow ( conf.param(qstmGesture::EPanSpeedLow)  / 100.f );
 gesture->setPanningSpeedHigh( conf.param(qstmGesture::EPanSpeedHigh) / 100.f );
 }
 }
-// ===================================================== RELEASE
+// ===================================================== MAYBE TAP
-using qstmGesture::QStm_ReleaseGestureRecogniser;
+using qstmGesture::QStm_MaybeTapGestureRecogniser;
-if (conf.enabled(QStm_ReleaseGestureRecogniser::KUid)) {
+if (conf.enabled(QStm_MaybeTapGestureRecogniser::KUid)) {
-QStm_ReleaseGestureRecogniser* gesture = NULL;
+int pos = m_gestureEngine->findGesture(QStm_MaybeTapGestureRecogniser::KUid);
-initRecognizer(gesture, context, isNewCtx);
+QStm_MaybeTapGestureRecogniser* gesture = NULL;
-if(gesture) {
+if (pos > -1) {
-gesture->setArea(QRect());
+gesture = static_cast<QStm_MaybeTapGestureRecogniser*>(m_gestureEngine->gestureAt(pos));
-}
+gesture->addTapListener(&context, context.getOwner());
 }
+else {
+initRecognizer(gesture, context, isNewCtx);
+}
+if(gesture) {
+gesture->setTapRange( touchAreaSizeInMm );
+}
+}
 // ===================================================== TAP / DOUBLE TAP
 // Add recognizer before any existing Flick, Release, Unknown
 // Add the gesture to the gesture engine
 using qstmGesture::QStm_TapGestureRecogniser;
 if(gesture) {
 qreal flickSpeed = conf.param(qstmGesture::EFlickSpeed) / 100.f;
 gesture->setFlickingSpeed(flickSpeed);
 }
 }
+// ===================================================== RELEASE
+using qstmGesture::QStm_ReleaseGestureRecogniser;
+if (conf.enabled(QStm_ReleaseGestureRecogniser::KUid)) {
+QStm_ReleaseGestureRecogniser* gesture = NULL;
+initRecognizer(gesture, context, isNewCtx);
+if(gesture) {
+gesture->setArea(QRect());
+}
+}
 // ===================================================== UNKNOWN
 using qstmGesture::QStm_UnknownGestureRecogniser;
 if (conf.enabled(QStm_UnknownGestureRecogniser::KUid)) {
 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->setTouchSuppressTimeout(!filter ? 0 : conf.param(qstmGesture::ESuppressTimeout)) ;
-m_statemachine->setMoveSuppressTimeout(!filter ? 0 : conf.param(qstmGesture::EMoveSuppressTimeout)*1000) ;
+m_statemachine->setMoveSuppressTimeout(!filter ? 0 : conf.param(qstmGesture::EMoveSuppressTimeout)) ;
 m_statemachine->enableCapacitiveUp    (!filter ? 0 : conf.param(qstmGesture::ECapacitiveUpUsed));
 m_statemachine->enableYadjustment     (!filter ? 0 : conf.param(qstmGesture::EAdjustYPos));
 m_statemachine->enableLogging(context.m_logging);
 }
 void QStm_GestureContext::init()
 {
 m_engine.m_contexts.append(this);
 m_config = new QStm_GestureParameters();
-m_engine.getStateMachine()->addUiEventObserver(this);
+//m_engine.getStateMachine()->addUiEventObserver(this);
 for(int i = 0; i < qstmGesture::EStmGestureUid_Count; ++i) {
 m_recognizers[i] = NULL;
 }
 QPoint vec = gesture->getLengthAndDirection();
 gest->setLengthAndDirection(vec);
 gest->setSpeed(gesture->getSpeed());
 QPoint pos = gesture->getLocation();
 gest->setPosition(pos);
+QPoint pos2 = gesture->getLocation2();
+gest->setPosition2(pos2);
 gest->setDetails(gesture->getDetails());
 gest->setSpeedVec(gesture->getSpeedVec());
 QWidget* w = static_cast<QWidget*>(gesture->target());
 gest->setTarget(w);
 }
 }
 }
 void QStm_GestureContext::enableRecognizer(qstmGesture::QStm_GestureUid uid )
 {
-	qstmGesture::QStm_GestureRecogniserIf* rec = m_recognizers[uid];
+qstmGesture::QStm_GestureRecogniserIf* rec = m_recognizers[uid];
 if(rec && !rec->isEnabled()) {
 rec->enable(true);
 // TODO: Notify listener
 }
 }
 }
 bool QStm_GestureContext::handleSymbianPlatformEvent(const QSymbianEvent* platEvent)
 {
-return	m_engine.getStateMachine()->handleSymbianPlatformEvent(platEvent);
+return m_engine.getStateMachine()->handleSymbianPlatformEvent(platEvent);
 }
 bool QStm_GestureContext::handleX11PlatformEvent(const XEvent* platEvent)
 {
-	return	m_engine.getStateMachine()->handleX11PlatformEvent(platEvent);
+return m_engine.getStateMachine()->handleX11PlatformEvent(platEvent);
 }
+bool QStm_GestureContext::handleWinPlatformEvent(const void* platEvent)
+{
+return m_engine.getStateMachine()->handleWinPlatformEvent(platEvent);
+}
+void QStm_GestureContext::enableDblClick(bool enable)
+{
+m_engine.getStateMachine()->enableDblClick(enable);
+}
+void QStm_GestureContext::setLogging(int enabled)
+{
+m_logging = enabled;
+m_engine.getGestureEngine()->enableLogging(enabled);
+}

changeset 16	3c88a81ff781
parent 3	0954f5dd2cd0