/*

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

*

*/

#include "qstmstatemachine.h"

#include "qstmstateengine.h"

#include "qstmuievent_if.h"

#include "qstmcallbacktimer.h"

#include "qstmstateengineconfig.h"

#include "qstmfilelogger.h"

#include "qstmutils.h"

#include <QtGui>

#ifdef Q_OS_SYMBIAN

#include <w32std.h>

#include <coecntrl.h>

#endif

#if defined(Q_WS_X11)

#include <X11/Xlib.h>

#endif

using namespace qstmUiEventEngine ;

//int pointBufferTimerCB(TAny* prt);

extern const char* stateNames[8] ;

const char* const ttypeNames[] = {  // for debugging purposes define the names of the pointer events

            "EButton1Down         ",

            "EButton1Up           ",

            "EButton2Down         ",

            "EButton2Up           ",

            "EButton3Down         ",

            "EButton3Up           ",

            "EDrag                ",

            "EMove                ",

            "EButtonRepeat        ",

            "ESwitchOn            ",

            "EOutOfRange          ",

            "EEnterCloseProximity ",

            "EExitCloseProximity  ",

            "EEnterHighPressure   ",

            "EExitHighPressure    "

            };

QStm_StateMachine::QStm_StateMachine()

{

    m_WasMessageFiltered = false ;

    m_wseventmonitoringenabled = false ; // NB: enabled only if really used by application

    m_loggingenabled = false ;

    m_capacitiveup = false ;

    m_adjustYposition = false ;

    //m_pointBuffer = NULL;

    init();

}

QStm_StateMachine::~QStm_StateMachine()

{

    for (int i = 0; i < KMaxNumberOfPointers; i++)

    {

        delete m_holdTimer[i] ;

        delete m_touchTimer[i] ;

        delete m_suppressTimer[i] ;

        delete m_impl[i] ;

    }

    delete m_config ;

/*    

    if (m_pointBufferTimer && m_pointBufferTimer->IsActive())

    {

        m_pointBufferTimer->Cancel();

    }

    delete m_pointBufferTimer;

    m_pointBufferTimer = NULL;

*/    

}

void QStm_StateMachine::init()

{

    m_config = new QStm_StateEngineConfiguration() ;

    for (int i = 0; i < KMaxNumberOfPointers; i++)

    {

        m_impl[i] = new QStm_StateEngine(m_config, this, i) ;

        m_holdTimer[i] = new QStm_CallbackTimer(this, &qstmUiEventEngine::QStm_StateMachine::handleholdTimer, 0, i, true);

        m_touchTimer[i] = new QStm_CallbackTimer(this, &qstmUiEventEngine::QStm_StateMachine::handletouchTimer, 0, i, true);

        m_suppressTimer[i] = new QStm_CallbackTimer(this, &qstmUiEventEngine::QStm_StateMachine::handlesuppressTimer, 0, i, true);

        /*

        m_holdTimer[i] = new QStm_CallbackTimer(this, SLOT(handleholdTimer(int)), 0, i, true);

        m_touchTimer[i] = new QStm_CallbackTimer(this, SLOT(handletouchTimer(int)), 0, i, true);

        m_suppressTimer[i] = new QStm_CallbackTimer(this, SLOT(handlesuppressTimer(int)), 0, i, true);

        */

    }

//    m_coeEnv = CCoeEnv::Static();

    m_3mminpixels = QStm_Utils::mm2Pixels(3) ;

}

bool QStm_StateMachine::handleStateEvent(const QStm_PlatformPointerEvent& platPointerEvent)

{

    int index = pointerIndex(platPointerEvent);

    QStm_StateEngine* engine = m_impl[index];

    createHwEvent(engine->initEvent(), platPointerEvent, platPointerEvent.m_target, platPointerEvent.m_time) ;

    if (m_loggingenabled)

    {

        LOGARG("handleStateEvent: ptr %d", index) ;

    }

    m_WasMessageFiltered = engine->handleStateEvent() ;

    return m_WasMessageFiltered ;

}

bool QStm_StateMachine::wasLastMessageFiltered(int aPointerNumber)

{

    return m_impl[aPointerNumber]->wasLastMessageFiltered() ;

}

QRect QStm_StateMachine::getTouchArea(int pointerNumber)

{

    return m_impl[pointerNumber]->getTouchArea() ;

}

void QStm_StateMachine::setTouchTimeArea(long fingersize_mm)

{

    m_config->setTouchTimeArea(fingersize_mm) ;

}

void QStm_StateMachine::setTouchArea(long fingersize_mm)

{

    m_config->setTouchArea(fingersize_mm) ;

}

void QStm_StateMachine::setMoveTolerance(long fingersize_mm)

{

    m_config->setMoveTolerance(fingersize_mm);    

}

QPoint QStm_StateMachine::getMoveTolerance()

{ 

    return m_config->getMoveTolerance(); 

}

QStm_AreaShape QStm_StateMachine::getTouchAreaShape()

{

    return m_config->getTouchAreaShape() ;

}

void QStm_StateMachine::setTouchAreaShape(const QStm_AreaShape aShape)

{

    m_config->setTouchAreaShape(aShape) ;

}

unsigned int QStm_StateMachine::getTouchTimeout()

{

    return m_config->getTouchTimeout() ;

}

void QStm_StateMachine::setTouchTimeout(unsigned int aDelay)

{

    m_config->setTouchTimeout(aDelay) ;

}

QRect QStm_StateMachine::getHoldArea(int pointerNumber)

{

    return m_impl[pointerNumber]->getHoldArea() ;

}

void QStm_StateMachine::setHoldArea(long fingersize_mm)

{

    m_config->setHoldArea(fingersize_mm) ;

}

QStm_AreaShape QStm_StateMachine::getHoldAreaShape()

{

    return m_config->getHoldAreaShape() ;

}

void QStm_StateMachine::setHoldAreaShape(const QStm_AreaShape aShape)

{

    m_config->setHoldAreaShape(aShape) ;

}

unsigned int QStm_StateMachine::getHoldTimeout()

{

    return m_config->getHoldTimeout() ;

}

void QStm_StateMachine::setHoldTimeout(unsigned int a)

{

    m_config->setHoldTimeout(a) ;

}

unsigned int QStm_StateMachine::getTouchSuppressTimeout()

{

    return m_config->getTouchSuppressTimeout() ;

}

void QStm_StateMachine::setTouchSuppressTimeout(unsigned int a)

{

    m_config->setTouchSuppressTimeout(a) ;

}

unsigned int QStm_StateMachine::getMoveSuppressTimeout()

{

    return m_config->getMoveSuppressTimeout() ;

}

void QStm_StateMachine::setMoveSuppressTimeout(unsigned int a)

{

    m_config->setMoveSuppressTimeout(a) ;

}

bool QStm_StateMachine::addUiEventObserver(QStm_UiEventObserverIf* observer)

{

    return m_config->addUiEventObserver(observer) ;

}

bool QStm_StateMachine::removeUiEventObserver(QStm_UiEventObserverIf* observer)

{

    return m_config->removeUiEventObserver(observer) ;

}

void QStm_StateMachine::enableLogging(bool aEnable)

{

    m_loggingenabled = aEnable ;

    m_config->enableLogging(aEnable) ;

}

int QStm_StateMachine::pointerIndex(const QStm_PlatformPointerEvent& platPointerEvent)

{

    int index = 0;

/*    

#if defined(ADVANCED_POINTER_EVENTS)

    if (aPointerEvent.IsAdvancedPointerEvent())

    {

        const TAdvancedPointerEvent* tadvp = aPointerEvent.AdvancedPointerEvent() ;

        index = tadvp->PointerNumber() ;

    }

#endif

*/

    index = platPointerEvent.m_pointerNumber;

    return index;

}

void QStm_StateMachine::createHwEvent(QStm_HwEvent& event, const QStm_PlatformPointerEvent& platPointerEvent, void* target, const QTime& time)

{

/*  should be set by this moment by CStateEngine with that index in CStateEngine::initEvent()

    aEvent.iPointerNumber = PointerIndex(aPointerEvent);

*/

    event.m_target = target ;

    event.m_time = time;

    // Change to screen coordinates here while the window is still existing....

    event.m_position = screenCoordinates(platPointerEvent.m_position, target) ;

    switch (platPointerEvent.m_type)

    {

    case QStm_PlatformPointerEvent::EButton1Down:

    case QStm_PlatformPointerEvent::EButton2Down:

    case QStm_PlatformPointerEvent::EButton3Down:

    {

        event.m_type = qstmUiEventEngine::EDown ;

        break ;

    }

    case QStm_PlatformPointerEvent::EButton1Up:

    case QStm_PlatformPointerEvent::EButton2Up:

    case QStm_PlatformPointerEvent::EButton3Up:

    {

        if (m_capacitiveup)

        {

            event.m_type = qstmUiEventEngine::ECapacitiveUP ;   // How could this be checked automatically?

        }

        else

        {

            event.m_type = qstmUiEventEngine::EResistiveUP ;    // How could this be checked automatically?

        }

        break ;

    }

    case QStm_PlatformPointerEvent::EDrag:

    {

        event.m_type = qstmUiEventEngine::EDrag ;

        break ;

    }

    }

}

void QStm_StateMachine::startholdTimer(int pointerNumber)

{

    if (!m_holdTimer[pointerNumber]->isActive())

    {

        m_holdTimer[pointerNumber]->start();

    }

}

void QStm_StateMachine::handleholdTimer(int pointerNumber)

{

    QStm_StateEngine* engine = m_impl[pointerNumber];

    createTimerEvent(engine->initEvent(), qstmUiEventEngine::EHoldTimer) ;

    engine->handleStateEvent() ;

}

void QStm_StateMachine::cancelholdTimer(int pointerNumber)

{

    m_holdTimer[pointerNumber]->stop();

}

void QStm_StateMachine::startsuppressTimer(int pointerNumber)

{

    m_suppressTimer[pointerNumber]->start();

}

void QStm_StateMachine::handlesuppressTimer(int pointerNumber)

{

    QStm_StateEngine* engine = m_impl[pointerNumber];

    createTimerEvent(engine->initEvent(), qstmUiEventEngine::ESuppressTimer) ;

    engine->handleStateEvent() ;

}

void QStm_StateMachine::cancelsuppressTimer(int pointerNumber)

{

    m_suppressTimer[pointerNumber]->stop();

}

void QStm_StateMachine::starttouchTimer(int pointerNumber)

{

    if (!m_touchTimer[pointerNumber]->isActive())

    {

        m_touchTimer[pointerNumber]->start();

    }

}

void QStm_StateMachine::handletouchTimer(int pointerNumber)

{

    QStm_StateEngine* engine = m_impl[pointerNumber];

    createTimerEvent(engine->initEvent(), qstmUiEventEngine::ETouchTimer) ;

    engine->handleStateEvent() ;

}

void QStm_StateMachine::canceltouchTimer(int pointerNumber)

{

    if (m_touchTimer[pointerNumber]->isActive())

    {

        m_touchTimer[pointerNumber]->stop();

    }

}

void QStm_StateMachine::createTimerEvent(QStm_HwEvent& event, QStm_StateMachineEvent eventCode)

{

    event.m_type = eventCode ;

    // m_hwe.iPosition = TPos(0, 0) ;       // should we just leave the previous pos

    event.m_time = QTime::currentTime() ;

}

bool QStm_StateMachine::handleX11PlatformEvent(const XEvent* platEvent)

{

    bool isPointerEvent = false;

#if defined(Q_WS_X11)

    QStm_PlatformPointerEvent platPointerEvent;

    switch (platEvent->type) {

        case ButtonPress:

        {

            switch (platEvent->xbutton.button) {

                case Button1:

                {

                    platPointerEvent.m_type = QStm_PlatformPointerEvent::EButton1Down;

                    break;

                }

                case Button2:

                {

                    platPointerEvent.m_type = QStm_PlatformPointerEvent::EButton2Down;

                    break;

                }

                case Button3:

                {

                    platPointerEvent.m_type = QStm_PlatformPointerEvent::EButton3Down;

                    break;

                }

            }

            isPointerEvent = true;

            break;

        }

        case ButtonRelease:

        {

            switch (platEvent->xbutton.button) {

                case Button1:

                {

                    platPointerEvent.m_type = QStm_PlatformPointerEvent::EButton1Up;

                    break;

                }

                case Button2:

                {

                    platPointerEvent.m_type = QStm_PlatformPointerEvent::EButton2Up;

                    break;

                }

                case Button3:

                {

                    platPointerEvent.m_type = QStm_PlatformPointerEvent::EButton3Up;

                    break;

                }

            }

            isPointerEvent = true;

            break;

        }

        case MotionNotify:

        {

            platPointerEvent.m_type = QStm_PlatformPointerEvent::EMove;

            isPointerEvent = true;

            break;

        }

    }

    if (isPointerEvent) {

        QWidget* widget = QWidget::find((WId)platEvent->xany.window);

        platPointerEvent.m_target = widget;

        int mds = platEvent->xbutton.time;

        int msec = mds % 1000;

        int sec =  (mds / 1000) % 60;

        int hr = mds / (1000 * 3600);

        int min = (mds % (1000 * 3600)) / 60000;

        platPointerEvent.m_time = QTime(hr, min, sec, msec);

        platPointerEvent.m_pointerNumber = 0;

        platPointerEvent.m_position = QPoint(platEvent->xbutton.x,

                                             platEvent->xbutton.y);

        handleStateEvent(platPointerEvent);

    }

#endif // Q_WS_X11

    return isPointerEvent;

}

bool QStm_StateMachine::handleSymbianPlatformEvent(const QSymbianEvent* platEvent)

{

    bool ret = false;

#ifdef Q_OS_SYMBIAN

	const TWsEvent* wse = platEvent->windowServerEvent();

	if (wse) {

		CCoeControl* ctrl = REINTERPRET_CAST(CCoeControl*, wse->Handle());

		QStm_PlatformPointerEvent platPointerEvent;

		if (wse->Type() == EEventPointer) {

		    QWidget* widget = QWidget::find(ctrl);

		    ret = (widget != NULL);

			TPointerEvent* tpe = wse->Pointer(); 

			 // For Symbian it's one-to-one correspondence

			platPointerEvent.m_type = static_cast<QStm_PlatformPointerEvent::PEType>(tpe->iType); 

			platPointerEvent.m_modifiers = tpe->iModifiers;

			platPointerEvent.m_position = QPoint(tpe->iPosition.iX, tpe->iPosition.iY); 

			platPointerEvent.m_pointerNumber = 0;

#if defined(ADVANCED_POINTER_EVENTS)

		    if (tpe->IsAdvancedPointerEvent()) {

		        const TAdvancedPointerEvent* tadvp = tpe->AdvancedPointerEvent() ;

		        platPointerEvent.m_pointerNumber = tadvp->PointerNumber() ;

		    }

#endif

		    platPointerEvent.m_target = widget;

		    int h = wse->Time().DateTime().Hour();

		    int m = wse->Time().DateTime().Minute();

		    int s = wse->Time().DateTime().Second();

		    int ms = wse->Time().DateTime().MicroSecond() / 1000;

		    QTime time(h, m, s, ms);

		    platPointerEvent.m_time = time;

		    handleStateEvent(platPointerEvent);

		}

	}

#endif

	return ret;

}

void QStm_StateMachine::startTouchTimer(int delay, int pointerNumber)

{

    m_touchTimer[pointerNumber]->setDelay(delay) ;

    starttouchTimer(pointerNumber) ;

}

void QStm_StateMachine::cancelTouchTimer(int pointerNumber)

{

    canceltouchTimer(pointerNumber) ;

}

void QStm_StateMachine::startHoldTimer(int delay, int pointerNumber)

{

    m_holdTimer[pointerNumber]->setDelay(delay) ;

    startholdTimer(pointerNumber) ;