#include "qstmgestureapi.h"

#include "qstmstatemachine.h"

#include "bedrockprovisioning.h"

#include "wrtperftracer.h"

#if defined(ORBIT_UI)

#include <hbapplication.h>

#endif

#ifdef Q_OS_SYMBIAN

#include <w32std.h>

#include <coecntrl.h>

#endif

    //delete m_dummyRecognizer;

    // Get settings from provisioning

    BEDROCK_PROVISIONING::BedrockProvisioning * settings =

        BEDROCK_PROVISIONING::BedrockProvisioning::createBedrockProvisioning();

    int logEnabled = settings->valueAsInt("GesturesEnableLogging");

    qstmEnableDebug((logEnabled != 0));

    m_gestures->setLogging(logEnabled);

    param.setEnabled(qstmGesture::EGestureUidTap, settings->valueAsInt("GesturesEnableTap") != 0);

    param[qstmGesture::EDoubleTapTimeout] = settings->valueAsInt("GesturesDoubleTapTimeout"); // 300 7x = 400

    param.setEnabled(qstmGesture::EGestureUidPan, settings->valueAsInt("GesturesEnablePan") != 0);

    param[qstmGesture::EPanSpeedLow] = settings->valueAsInt("GesturesPanSpeedLow");

    param[qstmGesture::EPanSpeedHigh] = settings->valueAsInt("GesturesPanSpeedHigh"); // 100 7x = 400

    param[qstmGesture::EPanDisabledWhileHovering] = settings->valueAsInt("GesturesPanDisabledWhileHovering") != 0; // !7x

    param[qstmGesture::EMoveTolerance] = settings->valueAsInt("GesturesMoveTolerance"); // !7x

    param.setEnabled(qstmGesture::EGestureUidHover, settings->valueAsInt("GesturesEnableHover") != 0);

    param[qstmGesture::EHoverSpeed] = settings->valueAsInt("GesturesHoverSpeed"); // !7x

    param[qstmGesture::EHoverDisabledWhilePanning] = settings->valueAsInt("GesturesHoverDisabledWhilePanning") != 0; // !7x

    param.setEnabled(qstmGesture::EGestureUidLeftRight,  settings->valueAsInt("GesturesEnableLeftRight") != 0);

    param.setEnabled(qstmGesture::EGestureUidUpDown,     settings->valueAsInt("GesturesEnableUpDown") != 0);

    param[qstmGesture::EAxisLockThreshold] = (int)(100 * settings->value("GesturesAxisLockThreshold").toDouble());

    param.setEnabled(qstmGesture::EGestureUidFlick,      settings->valueAsInt("GesturesEnableFlick") != 0);

    param[qstmGesture::EFlickSpeed] = settings->valueAsInt("GesturesFlickSpeed", 25); /*param[stmGesture::EPanSpeedHigh];*/ // !7x

    param.setEnabled(qstmGesture::EGestureUidRelease,    settings->valueAsInt("GesturesEnableRelease") != 0);

    param.setEnabled(qstmGesture::EGestureUidTouch,      settings->valueAsInt("GesturesEnableTouch") != 0);

    param.setEnabled(qstmGesture::EGestureUidEdgeScroll, settings->valueAsInt("GesturesEnableEdgeScroll") != 0);

    param[qstmGesture::EEdgeScrollRange] = settings->valueAsInt("GesturesEdgeScrollRange"); // !7x

    param.setEnabled(qstmGesture::EGestureUidCornerZoom, settings->valueAsInt("GesturesEnableCornerZoom") != 0);

    param[qstmGesture::EZoomCornerSize] = settings->valueAsInt("GesturesZoomCornerSize"); // 7 !7x

    param.setEnabled(qstmGesture::EGestureUidPinch, settings->valueAsInt("GesturesEnablePinch") != 0);

    param.setEnabled(qstmGesture::EGestureUidLongPress, settings->valueAsInt("GesturesEnableLongPress") != 0);

    param.setEnabled(qstmGesture::EGestureUidUnknown, settings->valueAsInt("GesturesEnableUnknown") != 0);

    touchArea.m_shape    = QStm_GestureArea::QStm_Shape(settings->valueAsInt("GesturesTouchAreaShape"));

    touchArea.m_timeout  = settings->valueAsInt("GesturesTouchAreaTimeout"); // 150 7x = 0

    touchArea.m_size     = QSize(settings->valueAsInt("GesturesTouchAreaWidth"), 

                                 settings->valueAsInt("GesturesTouchAreaHeight")); // 7 7x = 4

    tTimeArea.m_shape    = QStm_GestureArea::QStm_Shape(settings->valueAsInt("GesturesTimeAreaShape"));

    tTimeArea.m_timeout  = settings->valueAsInt("GesturesTimeAreaTimeout"); // 150 7x = 200

    tTimeArea.m_size     = QSize(settings->valueAsInt("GesturesTimeAreaWidth"),

                                 settings->valueAsInt("GesturesTimeAreaHeight")); // 7 7x = 4

    holdArea.m_shape    = QStm_GestureArea::QStm_Shape(settings->valueAsInt("GesturesHoldAreaShape"));

    holdArea.m_timeout  = settings->valueAsInt("GesturesHoldAreaTimeout"); // 7x = 1500

    holdArea.m_size     = QSize(settings->valueAsInt("GesturesHoldAreaWidth"), 

                                settings->valueAsInt("GesturesHoldAreaHeight")); // 7 7x = 4

    param[ qstmGesture::ESuppressTimeout     ] = settings->valueAsInt("GesturesSuppressTimeout");

    param[ qstmGesture::EMoveSuppressTimeout ] = settings->valueAsInt("GesturesMoveSuppressTimeout");

    param[ qstmGesture::ECapacitiveUpUsed    ] = settings->valueAsInt("GesturesCapacitiveUpUsed") != 0;

    param[ qstmGesture::EAdjustYPos          ] = settings->valueAsInt("GesturesAdjustYPos") != 0; // 7x = true ifndef WINSCW

    param[ qstmGesture::EEnableFiltering     ] = settings->valueAsInt("GesturesEnableFiltering") != 0; // 7x = true

    param[ qstmGesture::EWServMessageInterception ] = (settings->valueAsInt("GesturesWServMessageInterception") != 0);

    // Wonder Twin powers, Activate!  Form of an ice "pan"!  Shape of a "pinch"-nose pug! 

    //if (QStm_Gesture::assignedType() == Qt::CustomGesture) {

    //}

    //QObject::connect(m_gestures, SIGNAL(uiEvent(const qstmUiEventEngine::QStm_UiEventIf&)), 

    //        m_dummyRecognizer, SLOT(handleQStmUiEvent(const qstmUiEventEngine::QStm_UiEventIf&)));

    // HACK!!! Disable this if you need Double Tap gesture. !!!

    //m_gestures->enableDblClick(true);

bool WebGestureHelper::shouldHandleGesture()

{

    bool shouldHandle = (BedrockSettings->value("EnableGestures").toInt() != 0);

#ifdef Q_OS_SYMBIAN    

    shouldHandle = !CCoeEnv::Static()->AppUi()->IsDisplayingMenuOrDialog();

#endif    

    QWidget* modal = QApplication::activeModalWidget();

    shouldHandle =  shouldHandle && (modal == NULL);

    return shouldHandle;

bool WebGestureHelper::winEventFilter(void* event)

{

    return m_gestures->handleWinPlatformEvent(event);

}

bool WebGestureHelper::isFilteredByGestureEngine()

    bool wasFiltered = false;

    QStm_GestureEngineApi* gestEng = gestureEngine();

    if (gestEng) {

        qstmUiEventEngine::QStm_StateMachine* sm = gestEng->getStateMachine();

        if (sm) {

            //for (int i = 0; i < qstmUiEventEngine::KMaxNumberOfPointers && !wasFiltered; i++) {

                wasFiltered = sm->wasLastMessageFiltered();

            //}

        }

    }

    return wasFiltered; 

}

#if defined(ORBIT_UI)

BrowserApp::BrowserApp(QS60MainApplicationFactory appfactory, int & argc, char** argv) : ParentApp(appfactory, argc, argv)

{

    m_gestureHelper = 0;

    m_mainWindow = 0;

    m_gestureEngine = new QStm_GestureEngineApi();

}

#endif // ORBIT_UI

BrowserApp::BrowserApp(int & argc, char** argv) : ParentApp(argc, argv)

{

    m_gestureHelper = 0;

    m_mainWindow = 0;

/*    if (mainWindow()) {

        qDebug() << __PRETTY_FUNCTION__ << " - grabbing gestures";

        mainWindow()->ungrabGesture(Qt::PanGesture);

        mainWindow()->ungrabGesture(Qt::TapGesture);

        mainWindow()->ungrabGesture(Qt::TapAndHoldGesture);

        mainWindow()->ungrabGesture(Qt::PinchGesture);

        mainWindow()->ungrabGesture(Qt::SwipeGesture);

        mainWindow()->grabGesture(QStm_Gesture::assignedType());

    }

*/ 

    bool wasFiltered = false;

    if (m_gestureHelper && m_gestureHelper->shouldHandleGesture()) {

        m_gestureHelper->symbianEventFilter(event);

        wasFiltered = m_gestureHelper->isFilteredByGestureEngine();

    }

    return false;

    bool wasFiltered = false;

    if (m_gestureHelper && m_gestureHelper->shouldHandleGesture()) {

        wasFiltered = m_gestureHelper->isFilteredByGestureEngine();

        m_gestureHelper->x11EventFilter(event);

    }

    return false;

#endif

    return false;

}

bool BrowserApp::winEventFilter(MSG* message, long* result)

{

#if (ENABLE_GESTURE_LIB)

    bool wasFiltered = false;

    if (m_gestureHelper && m_gestureHelper->shouldHandleGesture()) {

        if(m_gestureHelper->winEventFilter(message))

            wasFiltered = m_gestureHelper->isFilteredByGestureEngine();

        if(wasFiltered) *result = 0;

    }

    return false;

/*

// For now, treat gesture touch / release as mouse events

bool BrowserApp::event(QEvent* event)

{

    if (event->type() == QEvent::Gesture) {

        qDebug() << __PRETTY_FUNCTION__ << " - got a gesture";

        QStm_Gesture* gesture = getQStmGesture(event);

        if (gesture) {

//            QStm_GestureType gtype = gesture->getGestureStmType();

//            if (gtype == QStmTouchGestureType || gtype == QStmReleaseGestureType) {

                qDebug() << __PRETTY_FUNCTION__ << " - sending mouse events";

                gesture->sendMouseEvents();

                return true;

//            }

        }

    }

    return QApplication::event(event);

}

*/

        if (m_currentGesture->gestureState() == Qt::GestureFinished ||

            m_currentGesture->isGestureEnded()) {

            ret = QGestureRecognizer::FinishGesture;

    }

        else {

            ret = QGestureRecognizer::TriggerGesture;

        }

        event->accept();

void QStm_QtDummyGestureRecognizer::handleQStmUiEvent(const qstmUiEventEngine::QStm_UiEventIf& uiEvent)

{

}

        Q_ASSERT(gesture);        

    m_currentGesture->setGestureStmType(m_currentGesture->gestureUidToStmType(uid, stmGestType));

        switch (m_currentGesture->getGestureStmType()) {

            case QStmLeftRightGestureType:

                vec.ry() = 0;

                m_currentGesture->setGestureStmType(QStmPanGestureType);

            break;

            case QStmUpDownGestureType:

                vec.rx() = 0;

            m_currentGesture->setGestureStmType(QStmPanGestureType);

            break;

        }

        QPoint pos2 = gesture->getLocation2();

        m_currentGesture->setPosition2(pos2);

        m_currentGesture->setTimestamp(gesture->timestamp());

        m_currentGesture->setHotSpot(pos);

        QStm_GestureEvent dummy;

        m_currentGesture->sendEvent(&dummy);