/*

* 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:

*  Gesture UI Engine

*/

// Gesture Library: Framework

#include <qstmgestureengine.h>

#include <qstmstatemachine.h>

// Gesture Library: Recognizers

#include <qstmtapgesturerecogniser.h>

#include <qstmpangesturerecogniser.h>

#include <qstmhoveringgesturerecogniser.h>

#include <qstmedgescrollgesturerecogniser.h>

#include <qstmlongpressgesturerecogniser.h>

#include <qstmpinchgesturerecogniser.h>

#include <qstmtouchgesturerecogniser.h>

#include <qstmreleasegesturerecogniser.h>

#include <qstmleftrightgesturerecogniser.h>

#include <qstmupdowngesturerecogniser.h>

#include <qstmflickgesturerecogniser.h>

#include <qstmunknowngesturerecogniser.h>

#include <qstmzoomgesturerecogniser.h>

#include <qstmgestureapi.h>

#include <qstmgestureevent.h>

#include <QtGui>

using namespace qstmGesture;

using namespace qstmUiEventEngine;

QStm_GestureParameters::QStm_GestureParameters()

{

}

QStm_GestureParameters::QStm_GestureParameters(const QStm_GestureParameters& params )

{

    memcpy(&m_param[0], &params.m_param[0], sizeof(m_param));

    memcpy(&m_areaSettings[0], &params.m_areaSettings[0], sizeof(m_areaSettings));

    memcpy(&m_enabled[0], &params.m_enabled[0], sizeof(m_enabled));

}

QStm_GestureEngineApi::QStm_GestureEngineApi()

{

	init();

}

void QStm_GestureEngineApi::init()

{

    //m_gf = new QStm_GestureFramework();

	m_gestureEngine = new QStm_GestureEngine();

	m_statemachine = new QStm_StateMachine();

	m_statemachine->addUiEventObserver(m_gestureEngine);

	m_config = new QStm_GestureParameters();    

}

QStm_GestureEngineApi::~QStm_GestureEngineApi()

{

    // Prevent reactivation of contexts as they remove themselves

    m_dtorPhase = true;

    qDeleteAll(m_contexts.begin(), m_contexts.end());

    m_contexts.clear();

    m_ctxtStack.clear();

    delete m_config;

    delete m_gestureEngine;

    delete m_statemachine;

}

QStm_GestureContext* QStm_GestureEngineApi::createContext(int /*aId*/ )

{

    QStm_GestureContext* ctxt = new QStm_GestureContext(*this);

    return ctxt;

}

QStm_GestureContext* QStm_GestureEngineApi::context(int /*aId*/ )

{

    return NULL;

}

void QStm_GestureEngineApi::enableContext(QStm_GestureContext& context )

{

    // NB: enabling context puts it on top of the Context Stack

    int idx = m_ctxtStack.indexOf(&context);

    if(idx >= 0) {

        m_ctxtStack.removeAt(idx);

    }

    setupRecognizers(context, true);

    m_ctxtStack.append(&context);

}

void QStm_GestureEngineApi::disableContext(QStm_GestureContext& context )

{

    int idx = m_ctxtStack.indexOf(&context);

    if(idx == -1) {

        return;

    }

    m_ctxtStack.removeAt(idx);

    for(int i = 0; i < qstmGesture::EStmGestureUid_Count; ++i) {

    	qstmGesture::QStm_GestureRecogniserIf* rec = context.m_recognizers[i];

        if(rec) {

        	m_gestureEngine->removeGesture(rec);

        }

    }

/* OK: we need to decide semantics of the GestureContext concept:

   - is only one is active at a time?

   - is there a stack of them

   OR

   - application activates and deactivates them as needed

   - GestureEngine only ensures that proper order of recognizers is used

   Disabled code below, because it doesn't allow porting of the stmProto demo,

   where two TestContainer are used, each with own gesture context, simultaneously.

   If app uses only one context, then this change doesn't break anything

    // re-activate previous (new top-most) context

    // NB: if deleted context is not top-most (active) one, no updates done

    TInt count = m_ctxtStack.Count();

    if(idx == count && count > 0 && !m_dtorPhase)

        {

        QStm_GestureContext* previous = m_ctxtStack[count - 1];

        setupRecognizers(*previous, EFalse);

        }

*/

}

template<class T>

void QStm_GestureEngineApi::initRecognizer(T*& gesture, QStm_GestureContext& context, bool isNewCtx )

{

    qstmGesture::QStm_GestureRecogniserIf*& recognizer = context.m_recognizers[T::KUid];

    gesture = static_cast<T*>(recognizer);

    if(!gesture && isNewCtx) {

        recognizer = gesture = new T(&context);

        recognizer->enableLogging((context.m_logging & (1<<T::KUid)) != 0);

    }

    // TODO: Add in right place according to gesture class

    // Find similar (by Uid gesture, insert before it), otherwise add as last or

    //      before any known gestures that should follow after it (NOT IMPLEMENTED)

    int pos = m_gestureEngine->findGesture(T::KUid);

    bool added = m_gestureEngine->insertGesture(gesture, pos >= 0 ? pos : m_gestureEngine->gestureCount());

    if(!added) {

    	// TODO: exception here?

    }

}

void QStm_GestureEngineApi::setupRecognizers(QStm_GestureContext& context, bool isNewCtx )

{

    // Order of recognizers in the Gesture Engine (upper ones receive input before lower ones)

    //

    // PINCH

    // CORNER_ZOOM

    // EDGE_SCROLL

    // LONGPRESS

    // TOUCH

    // UP_DOWN

    // LEFT_RIGHT

    // HOVER

    // PAN

    // TAP / DOUBLE_TAP

    // FLICK

    // RELEASE

    // UNKNOWN

    QStm_GestureParameters& conf = context.config();

    bool filter = conf.param(qstmGesture::EEnableFiltering) != 0;

    // TOUCH AREA

    qstmGesture::QStm_GestureArea& touchArea = *(conf.area(qstmGesture::ETouchArea));

    int touchAreaSizeInMm = touchArea.m_size.width();

    m_statemachine->setTouchAreaShape ( qstmUiEventEngine::QStm_AreaShape(touchArea.m_shape) );

    m_statemachine->setTouchArea      ( !filter ? 0 : touchAreaSizeInMm );

    m_statemachine->setTouchTimeout   ( !filter ? 0 : touchArea.m_timeout);

    int moveToleranceInMm = conf.param(qstmGesture::EMoveTolerance);

    m_statemachine->setMoveTolerance(moveToleranceInMm);

    QWidget* gestureContext = static_cast<QWidget*>(context.getOwner());

    QRect ctxtRect = gestureContext ? gestureContext->rect() : QRect();

    if(gestureContext) {

        QPoint p = gestureContext->mapToGlobal(QPoint(0,0)) ;

        ctxtRect.moveTo(p) ;

        }

    // ===================================================== PINCH

    using qstmGesture::QStm_PinchGestureRecogniser;

    if (conf.enabled(QStm_PinchGestureRecogniser::KUid)) {

        QStm_PinchGestureRecogniser* gesture = NULL;

        initRecognizer(gesture, context, isNewCtx);

        if(gesture) {

            qreal pspeed = conf.param(qstmGesture::EPinchSpeed) / 100.f;

            gesture->setPinchingSpeed(pspeed);

        }

    }

    // ===================================================== CORNER ZOOM

    using qstmGesture::QStm_ZoomGestureRecogniser;

    if (conf.enabled(QStm_ZoomGestureRecogniser::KUid)) {

        QStm_ZoomGestureRecogniser* gesture = NULL;

        initRecognizer(gesture, context, isNewCtx);

        if(gesture) {

            gesture->setArea(ctxtRect);

            gesture->setRange(conf.param(qstmGesture::EZoomCornerSize));

        }

    }

    // ===================================================== EDGE SCROLL

    using qstmGesture::QStm_EdgeScrollGestureRecogniser;

    if (conf.enabled(QStm_EdgeScrollGestureRecogniser::KUid)) {

        QStm_EdgeScrollGestureRecogniser* gesture = NULL;

        initRecognizer(gesture, context, isNewCtx);

        if(gesture) {

            gesture->setArea(ctxtRect);

            gesture->setScrollRange(conf.param(qstmGesture::EEdgeScrollRange)); // range is 20 pixels from the edge TODO: add this to settings...

        }

    }

    // ===================================================== LONG PRESS

    using qstmGesture::QStm_LongPressGestureRecogniser;

    if (conf.enabled(QStm_LongPressGestureRecogniser::KUid)) {

        QStm_LongPressGestureRecogniser* gesture = NULL;

        initRecognizer(gesture, context, isNewCtx);

        if(gesture) {

            gesture->setArea(ctxtRect);

        }

    }

    // ===================================================== TOUCH

    using qstmGesture::QStm_TouchGestureRecogniser;

    if (conf.enabled(QStm_TouchGestureRecogniser::KUid)) {

    	QStm_TouchGestureRecogniser* gesture = NULL;

        initRecognizer(gesture, context, isNewCtx);

        if(gesture) {

            // define empty area so that touch is reported only inside

            // our window (touch recognizer handles either an area or the target window)

            gesture->setArea(QRect());

        }

    }

    // ===================================================== LEFT-RIGHT

    using qstmGesture::QStm_LeftrightGestureRecogniser;

    if (conf.enabled(QStm_LeftrightGestureRecogniser::KUid)) {

        QStm_LeftrightGestureRecogniser* gesture = NULL;

        initRecognizer(gesture, context, isNewCtx);

    }

    // ===================================================== UP-DOWN

    using qstmGesture::QStm_UpdownGestureRecogniser;

    if (conf.enabled(QStm_UpdownGestureRecogniser::KUid)) {

        QStm_UpdownGestureRecogniser* gesture = NULL;

        initRecognizer(gesture, context, isNewCtx);

    }

    // ===================================================== HOVER

    using qstmGesture::QStm_HoveringGestureRecogniser;

    if (conf.enabled(QStm_HoveringGestureRecogniser::KUid)) {

        QStm_HoveringGestureRecogniser* gesture = NULL;

        initRecognizer(gesture, context, isNewCtx);

        if(gesture) {

            gesture->setHoveringSpeed(conf.param(qstmGesture::EHoverSpeed) / 100.f);

        }

    }

    // ===================================================== PAN

    using qstmGesture::QStm_PanGestureRecogniser;

    if (conf.enabled(QStm_PanGestureRecogniser::KUid)) {

        QStm_PanGestureRecogniser* gesture = NULL;

        initRecognizer(gesture, context, isNewCtx);

        if(gesture) {

            gesture->setPanningSpeedLow ( conf.param(qstmGesture::EPanSpeedLow)  / 100.f );

            gesture->setPanningSpeedHigh( conf.param(qstmGesture::EPanSpeedHigh) / 100.f );

        }

    }

    // ===================================================== RELEASE

    using qstmGesture::QStm_ReleaseGestureRecogniser;

    if (conf.enabled(QStm_ReleaseGestureRecogniser::KUid)) {

        QStm_ReleaseGestureRecogniser* gesture = NULL;

        initRecognizer(gesture, context, isNewCtx);

        if(gesture) {

            gesture->setArea(QRect());

        }

    }

    // ===================================================== TAP / DOUBLE TAP

    // Add recognizer before any existing Flick, Release, Unknown

    // Add the gesture to the gesture engine

    using qstmGesture::QStm_TapGestureRecogniser;

    if (conf.enabled(QStm_TapGestureRecogniser::KUid)) {

        int pos = m_gestureEngine->findGesture(QStm_TapGestureRecogniser::KUid);

        QStm_TapGestureRecogniser* gesture = NULL;

        if (pos > -1) {

            gesture = static_cast<QStm_TapGestureRecogniser*>(m_gestureEngine->gestureAt(pos));

            gesture->addTapListener(&context, context.getOwner());

            gesture->addDoubleTapListener(&context, context.getOwner());

        }

        else {

            initRecognizer(gesture, context, isNewCtx);

        }

        if(gesture) {

            gesture->setDoubleTapTimeout(conf.param(qstmGesture::EDoubleTapTimeout));

            gesture->setDoubleTapRange( touchAreaSizeInMm );

            gesture->ignoreFirstTap(false);

        }

    }

    // ===================================================== FLICK

    using qstmGesture::QStm_FlickGestureRecogniser;

    if (conf.enabled(QStm_FlickGestureRecogniser::KUid)) {

        QStm_FlickGestureRecogniser* gesture = NULL;

        initRecognizer(gesture, context, isNewCtx);

        if(gesture) {

            qreal flickSpeed = conf.param(qstmGesture::EFlickSpeed) / 100.f;

            gesture->setFlickingSpeed(flickSpeed);

        }

    }

    // ===================================================== UNKNOWN

    using qstmGesture::QStm_UnknownGestureRecogniser;

    if (conf.enabled(QStm_UnknownGestureRecogniser::KUid)) {

    	QStm_UnknownGestureRecogniser* gesture = NULL;

        initRecognizer(gesture, context, isNewCtx);

    }

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

    if(isNewCtx) {

        for(int i = 0; i < qstmGesture::EStmGestureUid_Count; ++i) {

        	qstmGesture::QStm_GestureRecogniserIf* rec = context.m_recognizers[i];

            if(rec) {

                rec->enableLogging(context.m_logging & (1<<i)) ;

            }

        }

    }

    // HOLD AREA

    qstmGesture::QStm_GestureArea& holdArea = *conf.area(qstmGesture::EHoldArea);

    int holdAreaSizeInMm = holdArea.m_size.width();

    m_statemachine->setHoldAreaShape  ( qstmUiEventEngine::QStm_AreaShape(holdArea.m_shape) );

    m_statemachine->setHoldArea       ( !filter ? 0 : holdAreaSizeInMm );

    m_statemachine->setHoldTimeout    ( !filter ? 0 : holdArea.m_timeout);

    // TOUCH-TIME AREA

    qstmGesture::QStm_GestureArea& tTimeArea = *conf.area(qstmGesture::ETouchTimeArea);

    int tTimeAreaSizeInMm = tTimeArea.m_size.width();

    // NB: shape <-- TouchAreaShape

    m_statemachine->setTouchTimeArea      ( !filter ? 0 : tTimeAreaSizeInMm );

    // Timeouts, Adjustments, etc.

    m_statemachine->setTouchSuppressTimeout(!filter ? 0 : conf.param(qstmGesture::ESuppressTimeout)*1000) ;

    m_statemachine->setMoveSuppressTimeout(!filter ? 0 : conf.param(qstmGesture::EMoveSuppressTimeout)*1000) ;

    m_statemachine->enableCapacitiveUp    (!filter ? 0 : conf.param(qstmGesture::ECapacitiveUpUsed));

    m_statemachine->enableYadjustment     (!filter ? 0 : conf.param(qstmGesture::EAdjustYPos));

    m_statemachine->enableLogging(context.m_logging);

}

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

QStm_GestureContext::QStm_GestureContext(QStm_GestureEngineApi& engine ) : 

		             m_engine(engine),

		             m_isActivated(false),

		             m_ownerControl(NULL),

		             m_config(NULL)

{

	init();

}

void QStm_GestureContext::init()

{

    m_engine.m_contexts.append(this);

    m_config = new QStm_GestureParameters();

    m_engine.getStateMachine()->addUiEventObserver(this);

    for(int i = 0; i < qstmGesture::EStmGestureUid_Count; ++i) {

        m_recognizers[i] = NULL;

    }

}

QStm_GestureContext::~QStm_GestureContext()

{

    // Remove all gesture listeners

    for(int i = m_listeners.count() - 1; i >= 0; --i) {

    	QStm_GestureListenerApiIf* listener = m_listeners[i];

        m_listeners.removeAt(i);

        listener->handleGestureListenerRemoved();

    }

    m_listeners.clear();

    // Remove all context's recognizers from the Gesture Engine

    deactivate();

    // Destroy all recognizers

    for(int r = 0; r < qstmGesture::EStmGestureUid_Count; ++r) {

    	qstmGesture::QStm_GestureRecogniserIf*& rec = m_recognizers[r];

        if(rec) {

            delete rec;

            rec = NULL;

        }

    }

    // Remove context from the Gesture Engine

    int idx = m_engine.m_contexts.indexOf(this);

    if(idx != -1) {

        m_engine.m_contexts.removeAt(idx);

    }

    delete m_config;

}

void QStm_GestureContext::addListener(QStm_GestureListenerApiIf* listener, int pos)

{

    m_listeners.insert(pos, listener);

}

int QStm_GestureContext::removeListener(QStm_GestureListenerApiIf* listener )

{

    int ind = m_listeners.indexOf(listener);

    if(ind >= 0) {

        m_listeners.removeAt(ind);

    }

    return ind;

}

void QStm_GestureContext::setContext(void* control)

{

    m_ownerControl = control;

    for(int i = 0; i < qstmGesture::EStmGestureUid_Count; ++i) {

    	QStm_GestureRecogniserIf* rec = m_recognizers[i];

        if(rec) {

            rec->setOwner(control);

        }

    }

}

void QStm_GestureContext::activate(void* control)

{

	setContext(control);

	activate();

}

void QStm_GestureContext::activate()

{

    if(isActive()) {

        // re-enable all recognizers

        enableRecognizers();

        return;

    }

    // 1. Tell Engine to deactivate active context

    // 2. Setup all gesture recognizers

    m_engine.enableContext(*this);

    // 3. Notify listeners

    enableRecognizers();

    //

    m_isActivated = true;

}

void QStm_GestureContext::deactivate()

{

    m_engine.disableContext(*this);

    m_isActivated = false;    

}

void QStm_GestureContext::gestureEnter(QStm_GestureIf& gesture )

{

	dispatchGestureEvent(gesture.gestureUid(), &gesture);

}

void QStm_GestureContext::gestureExit(QStm_GestureIf& gesture )

{

    dispatchGestureEvent(gesture.gestureUid(), NULL);

}