--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/qstmgesturelib/qstmstateengine.h Tue May 04 12:39:35 2010 +0300
@@ -0,0 +1,216 @@
+/*
+* 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:
+*
+*/
+
+
+#ifndef QSTMSTATEENGINE_H_
+#define QSTMSTATEENGINE_H_
+
+#include "qstmuievent_if.h"
+#include "qstmtimerinterface.h"
+#include "qstmstatemachine_v2.h"
+#include "qstmstateengineconfig.h"
+#include "qstmuievent.h"
+
+#include <QtCore>
+
+
+namespace qstmUiEventEngine
+{
+
+class QStm_UiEvent;
+/*!
+ * Define THwEvent since we need the point, the type and timestamp to be stored.
+ * The HW event is used also to handle the timer events so that the wrapper class calling the
+ * state machine will handle the starting, canceling etc. of the timers and the state machine
+ * sees the timers as messages. This hopefully makes it easier to keep the core state machine as
+ * OS agnostic as possible.
+ */
+class QStm_HwEvent
+{
+public:
+ QStm_HwEvent() {} ;
+ QStm_HwEvent(const QStm_HwEvent& ev):
+ m_type(ev.m_type), m_position(ev.m_position),
+ m_time(ev.m_time), m_target(ev.m_target), m_pointerNumber(ev.m_pointerNumber) {}
+ QStm_HwEvent(QStm_StateMachineEvent code, const QPoint& pos, QTime time, void* target, int pointerNr):
+ m_type(code), m_position(pos),
+ m_time(time), m_target(target), m_pointerNumber(pointerNr) {}
+
+ QStm_StateMachineEvent m_type ;
+ QPoint m_position ;
+ QTime m_time ;
+ void* m_target ;
+ int m_pointerNumber ;
+};
+
+
+class QStm_StateEngine : public QObject
+{
+public:
+ /**
+ * constructor and destructor
+ */
+ QStm_StateEngine(QStm_StateEngineConfiguration* config, QStm_TimerInterfaceIf* timerif, int index) ;
+
+ ~QStm_StateEngine() ;
+ /**
+ * The methods needed for state machine
+ */
+ void consumeEvent() ;
+ bool isTouchTimer() ;
+ bool isHoldTimer() ;
+ bool isSuppressTimer() ;
+ bool isTouchTimeArea() ;
+ bool isTouchArea() ;
+ bool isHoldArea() ;
+ bool insideTouchTimeArea() ;
+ bool insideTouchArea() ;
+ bool insideHoldArea() ;
+ bool looksLikeHold() ;
+ void errorEvent() ;
+ void initTouchTimer() ;
+ void initHoldTimer() ;
+ void restartHoldTimer() ;
+ void initTouchSuppressTimer() ;
+ void initMoveSuppressTimer() ;
+ void clearTouchTimer() ;
+ void clearHoldTimer() ;
+ void clearSuppressTimer() ;
+ void produceTouch() ;
+ void produceMove() ;
+ void produceRelease() ;
+ void produceHold() ;
+ void renameToDrag() ;
+ void prepareTouchTimeArea() ;
+ void prepareTouchArea() ;
+ void prepareHoldArea() ;
+ void setCurrentPos() ;
+ void setGestureStart() ;
+ void addToTouch() ;
+ void addDraggingPos() ;
+ void storeMovePos() ;
+ bool insideMoveThreshold();
+
+ /**
+ * The event interface
+ */
+
+ QStm_HwEvent& initEvent()
+ {
+ m_hwe.m_pointerNumber = m_index;
+ return m_hwe;
+ }
+
+ // event returned by initEvent() must initialized first
+ bool handleStateEvent() ;
+
+ QRect getTouchArea() ;
+ QRect getHoldArea() ;
+ bool wasLastMessageFiltered() ;
+
+private:
+ bool m_eventConsumed ;
+ QStm_HwEvent m_hwe ;
+
+ bool isNewHoldingPoint() ;
+ QList<QStm_HwEvent*> m_dragPoints; // LATER: change this into std::vector
+ QStm_TimerInterfaceIf* m_timerif ; //
+
+ QList<QStm_HwEvent> m_touchPoints; // LATER: change this into std::vector
+
+ // Variables for running the state machine
+ QStm_StateMachineState m_currentState ;
+ bool m_isTimerEvent ; // We need to separate the pointer events and the timer events
+ QPoint m_currentTouchXY ; // This is the touching point
+ QPoint m_gestureStartXY ; // gesture started at this point
+ QPoint m_uiEventXY ; // The UI event XY point.
+ QPoint m_previousPointerEventPosition ;
+ QPoint m_deltaVector ;
+ QRect m_touchRect ;
+ QRect m_holdRect ;
+
+ bool m_wasFiltered ;
+ void calculateDelta() ;
+ void calculateTouchAverage() ;
+ void calculateCurrentVector() ;
+ QPoint calculateTouchAverageFromPoints() ;
+ bool insideArea(const QPoint& point, const QRect& rect, QStm_AreaShape shape, const QPoint& tolerance);
+ void setTolerance(long fingersize_mm, QPoint& tolerance, QStm_AreaShape shape) ;
+
+ void debugPrintState(QStm_StateMachineState nextstate) ;
+ inline static QRect toleranceRect( const QPoint& aCenterPoint, const QPoint& tolerance) ;
+ void turnStateMachine() ;
+
+ QPoint m_touchCentre ;
+ QPoint m_holdCentre ;
+
+ void* m_gestureTarget ;
+ long getInterval() ;
+ QTime m_lastMessageTime ;
+ QStm_UiEvent* createUIEvent(QStm_UiEventCode code, const QPoint& aPos) ;
+ QPoint getPreviousXY(const QPoint& aXY) ;
+ QPoint m_previousXY ;
+ bool isTimerMessage() ;
+ int m_index ;
+ // TPoint screenCoordinates(TPoint aPos, void* aGestureTarget) ;
+ QStm_UiEventCode m_previousUiGenerated ;
+ QPoint m_lastFilteredPosition ;
+ QTime m_lastFilteredMessageTime ;
+
+ QStm_StateEngineConfiguration* m_config ;
+
+};
+
+class QStm_UiEventSender: public QObject
+{
+public:
+ enum EventSenderState
+ {
+ ENoEvents,
+ EEventsReady,
+ EBusy
+ };
+
+ QStm_UiEventSender();
+ ~QStm_UiEventSender();
+
+ int addEvent(QStm_UiEvent* gestureEvent);
+ bool addObserver(QStm_UiEventObserverIf* observer );
+ bool removeObserver(QStm_UiEventObserverIf* observer );
+ bool isObserver(void* observer );
+ void setLogging(bool a) {m_loggingenabled = a;} ;
+
+private:
+ void emitEvent( const QStm_UiEvent& gestureEvent );
+
+ /*!
+ * Should we be prepared for more than 5 pointers ? Jos tulee Torvisen voittaja
+ */
+ QStm_UiEvent* m_events[qstmUiEventEngine::KMaxNumberOfPointers];
+ void compressStack(QStm_UiEvent* uiEvent) ;
+
+ /*
+ * Let's be prepared for more than one observer,
+ * although usually there is only the gesture engine
+ */
+ QList<QStm_UiEventObserverIf*> m_observers;
+ bool m_loggingenabled ;
+
+};
+} // namespace
+
+#endif /* QSTMSTATEENGINE_H_ */