diff -r 000000000000 -r 1450b09d0cfd qstmgesturelib/qstmstateengine.h
--- /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_ */