/*

* 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 Machine implementation

*

*/

#ifndef STATEMACHINE_H

#define STATEMACHINE_H

// INCLUDES

#include <e32base.h>

#include <aknwseventobserver.h>

#include <rt_uievent.h>

#include "timerinterface.h"

#include "statemachine_v2.h"

class CCoeEnv;

namespace stmUiEventEngine

{

class CCallbackTimer;

class CStateEngine;

class THwEvent;

class CStateEngineConfiguration;

int Distance(int dx, int dy);

inline int Distance(const TPoint& aP1, const TPoint& aP2)

{

    return Distance(aP1.iX - aP2.iX, aP1.iY - aP2.iY);

}

// CLASS DECLARATION

/**

 *  CStateMachine

 *

 */

NONSHARABLE_CLASS( CStateMachine ): public CBase, 

                                    public MTimerInterface, 

                                    public MAknWsEventObserver, 

                                    public MStateMachine

{

public:

    /**

     * The MStateMachine interface methods

     */

    virtual TRect getTouchArea(TInt aPointerNumber) ;

    virtual void setTouchTimeArea(long fingersize_mm) ;

    virtual void setTouchArea(long fingersize_mm) ;

    virtual TAreaShape getTouchAreaShape() ;

    virtual void setTouchAreaShape(const TAreaShape shape) ;

    virtual unsigned int getTouchTimeout() ;

    virtual void setTouchTimeout(unsigned int) ;

    virtual TRect getHoldArea(TInt aPointerNumber) ;

    virtual void setHoldArea(long fingersize_mm) ;

    virtual TAreaShape getHoldAreaShape() ;

    virtual void setHoldAreaShape(const TAreaShape shape) ;

    virtual unsigned int getHoldTimeout();

    virtual void setHoldTimeout(unsigned int a);

    virtual unsigned int getTouchSuppressTimeout() ;

    virtual void setTouchSuppressTimeout(unsigned int a) ;

    virtual unsigned int getMoveSuppressTimeout() ;

    virtual void setMoveSuppressTimeout(unsigned int a) ;

    virtual bool addUiEventObserver(MUiEventObserver* observer) ;

    virtual bool removeUiEventObserver(MUiEventObserver* observer) ;

    virtual bool wasLastMessageFiltered(TInt aPointerNumber) ;

    virtual void enableCapacitiveUp(bool enable) ;

    virtual void enableLogging(bool aEnable) ;

    virtual void enableYadjustment(bool aEnable) ;

    virtual int getNumberOfPointers() ;

    /**

     * MAknWsEventObserver methods

     */

    virtual void HandleWsEventL(const TWsEvent& aEvent, CCoeControl* aDestination) ;

    /* other methods */

    /**

     * Pointer event handling in case the messaging should be handled that way, note that the target CCoeControl needs to be givem

     */

    void HandlePointerEventL(const TPointerEvent& aPointerEvent, void* target) ;

    /**

     * Simple toggle changes from handling the messages using ...WsEventL or ...PointerEventL

     */

    void EnableWsEventMonitoring(bool aEnable) ;

    /**

     * Method to handle the TPointerEvent

     */

    bool HandleStateEvent(const TPointerEvent& aPointerEvent, void* aTarget, const TTime& aTime) ;

    /*!

     * Setting the Y adjustment useful in capacitive touch

     * Note that there are problems with the adjustment if done at this level,

     * the most proper place would be the window server.

     */

    /**

     * MTimerInterface methods, these are internal and do not need to be exported

     */

    virtual void startTouchTimer(TInt aDelay, TInt aPointerNumber) ;

    virtual void cancelTouchTimer(TInt aPointerNumber)  ;

    virtual void startHoldTimer(TInt aDelay, TInt aPointerNumber)  ;

    virtual void cancelHoldTimer(TInt aPointerNumber)  ;

    virtual void startSuppressTimer(TInt aDelay, TInt aPointerNumber) ;

    virtual void cancelSuppressTimer(TInt aPointerNumber)  ;

public:

    ~CStateMachine();

    static CStateMachine* NewL();

    static CStateMachine* NewLC();

private:

    CStateMachine();

    void ConstructL();

    inline static TInt PointerIndex(const TPointerEvent& aPointerEvent);

    /**

     * Convert pointer event into our own event format (including timestamp)

     */

    void CreateHwEvent(THwEvent& aEvent, 

                       const TPointerEvent& aPointerEvent, 

                       void* aTarget, 

                       const TTime& aTime) ;

    void CreateTimerEvent(THwEvent& aEvent, TStateMachineEvent aEventCode) ;

    /**

     * the actual state machines implementing the transitions etc.

     */

    CStateEngine* m_impl[KMaxNumberOfPointers] ;

    /*

     * The configuration for state machines

     */

    CStateEngineConfiguration* m_config ;

    /*!

     * convert window coordinates to screen coordinates.

     */

    TPoint screenCoordinates(const TPoint& aPos, void* aGestureTarget) ;

    CCoeEnv* m_coeEnv;

    bool m_WasMessageFiltered ;

    bool m_wseventmonitoringenabled ;

    bool m_loggingenabled ;

    bool m_capacitiveup ;

    int m_3mminpixels ;

    bool m_adjustYposition ;

    // Use same naming scheme with the timers, and variables and methods

    // using macro expansion tricks (with multitouch support starts to look quite ugly):

#define DECLARE_TIMER(x) \

            void start##x##Timer(TInt aPointerNumber) ;\

            CCallbackTimer* m_##x##Timer[KMaxNumberOfPointers] ;\

            void handle##x##Timer(TInt aPointerNumber) ;\

            void cancel##x##Timer(TInt aPointerNumber)

    DECLARE_TIMER(touch) ;

    DECLARE_TIMER(hold) ;

    DECLARE_TIMER(suppress) ;

};

}   // namespace

#endif // STATEMACHINE_H