/*

* Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

*

* This program is free software: you can redistribute it and/or modify

* it under the terms of the GNU Lesser General Public License as published by

* the Free Software Foundation, version 2.1 of the License.

* 

* This program is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

* GNU Lesser General Public License for more details.

*

* You should have received a copy of the GNU Lesser General Public License

* along with this program.  If not, 

* see "http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html/".

*

* Description:

*

*/

#ifndef QSTMGESTUREAPI_H__

#define QSTMGESTUREAPI_H__

#include <qstmgesture_if.h>

#include <qstmgesturelistener_if.h>

#include <qstmuievent_if.h>

#include <QGestureRecognizer>

#include <qwindowdefs.h>

#if !defined(Q_WS_X11)

#define XEvent void

#endif

namespace qstmGesture

{

    class QStm_GestureRecogniserIf;

    class QStm_GestureEngine;

}

namespace qstmUiEventEngine

{

    class QStm_StateMachine;

}

class QStm_GestureContext;

class QGestureEvent;

class QSymbianEvent;

class QStm_Gesture;

class QStm_GestureListenerApiIf

{

public:

    enum QStm_ProcessingResult

        {

        // Normally listeners return this code

        EContinue   = 0,

        // Prevents any other listeners to get this event

        EConsume    = 1,

        // continue and disable recognizer till explicitly re-enabled

        ESuspend    = 1<<1,

        };

    enum QStm_GestureContextEvent

        {

        EContextActivated,

        EContextDeactivated

        };

    // Gesture handling callback.

    // @param aUid  Type of gesture (actually, UID of gesture recognizer implementation)

    // @param aGesture Geture data; if it's NULL then event is Exit (end of gesture)

    // @note Some gestures issue more then one calls and then, typically Exit call.

    virtual QStm_ProcessingResult handleGestureEvent(qstmGesture::QStm_GestureUid /*aUid*/, qstmGesture::QStm_GestureIf* /*aGesture*/)

    {

        return QStm_GestureListenerApiIf::EContinue;

    }

    // This method is called instead of HandleGestureEventL if prevous listener locked itself

    // onto gesture handling by returning TProcessingResult::EConsume.

    // @see HandleGestureEventL

    // Default implementation does nothing.

    virtual void handleGestureListenerSuppressed(qstmGesture::QStm_GestureUid /*aUid*/, qstmGesture::QStm_GestureIf* /*aGesture*/)

    {

    }

    // Called by framework when listener is removed from a listener set.

    // It can be used for application-specific action, i.e. desturction of the listener.

    // Default implementation does nothing.

    virtual void handleGestureContextEvent(QStm_GestureContextEvent /*aEvent*/)

    {

    }

    // Called by framework when listener is removed from a listener set.

    // It can be used for application-specific action, i.e. destruction of the listener.

    // Default implementation does nothing.

    virtual void handleGestureListenerRemoved()

    {

    }

};

//==================================================================

class QStm_GestureParametersApiIf

{

public:

    virtual qstmGesture::QStm_GestureArea* area(qstmGesture::QStm_GestureAreaSettings aArea) = 0;

    virtual int param(qstmGesture::QStm_GestureSettings aParam) const = 0;

    virtual uint enabled(qstmGesture::QStm_GestureUid gestureUid) const = 0;

};

//==================================================================

{

public:

    QStm_GestureParameters();

    QStm_GestureParameters(const QStm_GestureParameters& aParams);

public: // getters from QStm_GestureParametersApiIf

    qstmGesture::QStm_GestureArea* area(qstmGesture::QStm_GestureAreaSettings aArea)

    {

        return &m_areaSettings[aArea];

    }

    int param(qstmGesture::QStm_GestureSettings param) const

    {

        return m_param[param];

    }

    uint enabled(qstmGesture::QStm_GestureUid gestureUid) const

        {

        return m_enabled[gestureUid] != 0;

        }

    void setParam(qstmGesture::QStm_GestureSettings param, int value)

    {

        m_param[param] = value;

    }

    void setEnabled(qstmGesture::QStm_GestureUid gestureUid, uint param)

    {

        m_enabled[gestureUid] = param;

    }

    int& operator[](qstmGesture::QStm_GestureSettings param)

    {

        return m_param[param];

    }

private:

    int m_param[qstmGesture::EGestureSettingsCount];

    qstmGesture::QStm_GestureArea m_areaSettings[qstmGesture::EGestureAreaSettingsCount];

    int m_modified;

    uint m_enabled[qstmGesture::EStmGestureUid_Count];

};

//==================================================================

{

public:

    QSTMGESTURELIB_EXPORT QStm_GestureContext* createContext(int aId);

    QStm_GestureContext* context(int aId);

    QSTMGESTURELIB_EXPORT QStm_GestureEngineApi();

    qstmGesture::QStm_GestureEngine* getGestureEngine() { return m_gestureEngine; }

    qstmUiEventEngine::QStm_StateMachine* getStateMachine() { return m_statemachine; }

private: // used by friend class QStm_GestureContext

    void init();

    void enableContext(QStm_GestureContext& ctx);

    void disableContext(QStm_GestureContext& ctx);

    template<class T>

    void initRecognizer(

        T*& gesture,

        QStm_GestureContext& ctx,

        bool isNewCtx);

    void setupRecognizers(QStm_GestureContext& ctx, bool isNewCtx);

private:

    friend class QStm_GestureContext;

    // Registered/owned contexts

    QList<QStm_GestureContext*> m_contexts;

    // Active set of contexts; latest added defines parameters

    QList<QStm_GestureContext*> m_ctxtStack;

    // Global/default parameters

    QStm_GestureParameters* m_config;

    bool m_dtorPhase;

    qstmGesture::QStm_GestureEngine* m_gestureEngine;

    qstmUiEventEngine::QStm_StateMachine* m_statemachine;

};

// Gesture context represents a certain configuration of gesture parameters

// (including what gestures are enabled) and gesture listeners.

// Context can be created beforehand and reused later.

// The assumed use of a context is to have rough correspondence between

// UI view and enabled gestures.

//

// @note Gesture contexts are created by an instance of QStm_GestureEngineApi.

class QStm_GestureContext: public QObject, 

                           public qstmGesture::QStm_GestureListenerIf,

                           public qstmUiEventEngine::QStm_UiEventObserverIf

{

    Q_OBJECT

public:

    QSTMGESTURELIB_EXPORT QStm_GestureContext(QStm_GestureEngineApi& engine);

    QSTMGESTURELIB_EXPORT ~QStm_GestureContext();

public: // Gesture listeners

    // Add listener to the gesture processing context.

    // @param aListener Listener object

    // @param aPos Position of inserted listener which determines order

    //     in which it receives gesture events (0 == first, before existing)

    QSTMGESTURELIB_EXPORT void addListener(QStm_GestureListenerApiIf* listener, int pos = 0);

    QSTMGESTURELIB_EXPORT int removeListener(QStm_GestureListenerApiIf* listener);

    const QList<QStm_GestureListenerApiIf*>& listeners() const { return m_listeners; }

    QSTMGESTURELIB_EXPORT void setContext(void* control);

    QSTMGESTURELIB_EXPORT void activate();

    QSTMGESTURELIB_EXPORT void activate(void* control);

    QSTMGESTURELIB_EXPORT void deactivate();

    // TODO: hide implementation, check boundaries

    {

        return m_recognizers[aUid];

    }

// from qstmGesture::QStm_GestureListenerIf

    void gestureEnter(qstmGesture::QStm_GestureIf& aGesture);

    void gestureExit(qstmGesture::QStm_GestureIf& aGesture);

    QSTMGESTURELIB_EXPORT void* getOwner();

//from qstmUiEventEngine::QStm_UiEventObserverIf    

    QSTMGESTURELIB_EXPORT void handleUiEvent( const qstmUiEventEngine::QStm_UiEventIf& event );

    QSTMGESTURELIB_EXPORT bool handleSymbianPlatformEvent(const QSymbianEvent* platEvent); 

    QSTMGESTURELIB_EXPORT bool handleX11PlatformEvent(const XEvent* platEvent);

signals:

    void uiEvent(const qstmUiEventEngine::QStm_UiEventIf& event);

private:

    friend class QStm_GestureEngineApi;

    QStm_Gesture* createQStmGesture(qstmGesture::QStm_GestureUid uid,

                                    qstmGesture::QStm_GestureIf* gesture);

    void init();

    void dispatchGestureEvent(qstmGesture::QStm_GestureUid aUid, qstmGesture::QStm_GestureIf* aGesture);

    void suspendRecognizer(qstmGesture::QStm_GestureUid aUid);

    void enableRecognizers();

    void enableRecognizer(qstmGesture::QStm_GestureUid aUid);

private:

    QStm_GestureEngineApi& m_engine;

    // Application-specific ID for finding context

    int    m_ctxtId;

    bool   m_isActivated;

    QStm_GestureParameters* m_config;

    void*  m_ownerControl;

    //TBool iPinchUsed;

    QList<QStm_GestureListenerApiIf*> m_listeners;

    // for simplicity of addressing recognizers, we'll use fixed array

    // with UID-based index (range 0..N is assumed for UIDs)

    // @note Tap recognizer actually produces Tap and DoubleTap gesture,

    //       so should be handled carefully -- only Tap position is set

    qstmGesture::QStm_GestureRecogniserIf* m_recognizers[qstmGesture::EStmGestureUid_Count];

    int m_logging;

};

#endif  // QSTMGESTUREAPI_H__