/*
* 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:   State Engine
*
*/
#ifndef STATEENGINE_H_
#define STATEENGINE_H_

#include "rt_uievent.h"
#include "timerinterface.h"
#include "statemachine_v2.h"
#include "uieventsender.h"
#include "stateengineconfiguration.h"

namespace stmUiEventEngine
{

/*!
 * 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 THwEvent
{
public:
    THwEvent() {} ;
    THwEvent(const THwEvent& ev):
        iType(ev.iType), iPosition(ev.iPosition),
        iTime(ev.iTime), iTarget(ev.iTarget), iPointerNumber(ev.iPointerNumber) {}
    THwEvent(TStateMachineEvent code, 
             const TPoint& pos, 
             TTime time, 
             void* aTarget, 
             TInt aPointerNr):
             iType(code), iPosition(pos),
             iTime(time), iTarget(aTarget), iPointerNumber(aPointerNr) 
             {
             }

    TStateMachineEvent iType ;
    TPoint  iPosition ;
    TTime   iTime ;
    void*   iTarget ;
	TInt	iPointerNumber ;
};


NONSHARABLE_CLASS( CStateEngine ) : public CBase
{
public:
    /**
     * constructor and destructor
     */
	CStateEngine(CStateEngineConfiguration* aConfig, MTimerInterface* timerif, int index) ;

    ~CStateEngine() ;
    /**
     *  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() ;

    /**
     * The event interface
     */

    THwEvent& initEvent()
    {
        m_hwe.iPointerNumber = m_index;
        return m_hwe;
    }

    // event returned by initEvent() must initialized first
	bool handleStateEvent()  ;

	TRect getTouchArea() ;
	TRect getHoldArea() ;
	bool wasLastMessageFiltered() ;

private:
    bool m_eventConsumed ;
    THwEvent m_hwe ;

    bool isNewHoldingPoint() ;
    RPointerArray<THwEvent> iDragPoints;
    MTimerInterface* m_timerif ;

    RArray<THwEvent> iTouchPoints;

    // Variables for running the state machine
    TStateMachineState m_currentState ;
    bool m_isTimerEvent ;                   // We need to separate the pointer events and the timer events
    TPoint m_currentTouchXY ;               // This is the touching point
    TPoint m_gestureStartXY ;               // gesture started at this point
    TPoint m_uiEventXY ;                    // The UI event XY point.
    TPoint m_previousPointerEventPosition ;
    TPoint m_deltaVector ;
    TRect m_touchRect ;
    TRect m_holdRect ;

    bool m_wasFiltered ;
    void CalculateDelta() ;
    void CalculateTouchAverage() ;
    void CalculateCurrentVector() ;
    TPoint calculateTouchAverageFromPoints() ;
    bool InsideArea(const TPoint& point, 
                    const TRect& rect, 
                    TAreaShape shape, 
                    const TPoint& tolerance);
    void setTolerance(long fingersize_mm, TPoint& tolerance, TAreaShape shape) ;

    void DebugPrintState(TStateMachineState anextstate) ;
    inline static TRect ToleranceRect( const TPoint& aCenterPoint, const TPoint& tolerance) ;
    void turnStateMachine() ;

    TPoint     m_touchCentre ;
    TPoint     m_holdCentre ;

    void*       m_gestureTarget ;
    TTimeIntervalMicroSeconds getInterval() ;
    TTime       m_lastMessageTime ;
    CUiEvent* createUIEventL(TUiEventCode code, const TPoint& aPos) ;
    TPoint getPreviousXY(const TPoint& aXY) ;
    TPoint m_previousXY ;
    bool isTimerMessage() ;
    int  m_index ;
    TUiEventCode m_previousUiGenerated ;
    TPoint m_lastFilteredPosition ;
    TTime m_lastFilteredMessageTime ;

	CStateEngineConfiguration* m_config ;
	bool isStatemachineBlocked;

};
}   // namespace

#endif /* STATEENGINE_H_ */