/****************************************************************************

**

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

** All rights reserved.

** Contact: Nokia Corporation (developer.feedback@nokia.com)

**

** This file is part of the HbCore module of the UI Extensions for Mobile.

**

** GNU Lesser General Public License Usage

** This file may be used under the terms of the GNU Lesser General Public

** License version 2.1 as published by the Free Software Foundation and

** appearing in the file LICENSE.LGPL included in the packaging of this file.

** Please review the following information to ensure the GNU Lesser General

** Public License version 2.1 requirements will be met:

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

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at developer.feedback@nokia.com.

**

****************************************************************************/

#include <QEvent>

#include <QGestureRecognizer>

#include <QGraphicsView>

#include <QMouseEvent>

#include <QGraphicsScene>

#define followedTouchPoint(te, gesture) te->touchPoints().at(followedTouchPointIndex(te, gesture))

/*!

   @hbcore

   \internal

   \class HbPanGestureLogic

   \brief

*/

/*!

    \internal

    \brief

    \return

*/

HbPanGestureLogic::HbPanGestureLogic()

{

}

HbPanGestureLogic::~HbPanGestureLogic() {}

/*!

    \internal

    \brief

    \return

*/

bool HbPanGestureLogic::isMouseEvent(QEvent::Type eventType)

{

    return eventType == QEvent::MouseButtonPress ||

            eventType == QEvent::MouseMove ||

            eventType == QEvent::MouseButtonDblClick ||

            eventType == QEvent::MouseButtonRelease;

}

/*!

    \internal

    \brief

    \return

*/

bool HbPanGestureLogic::isTouchEvent(QEvent::Type eventType)

{

    return eventType == QEvent::TouchBegin ||

            eventType == QEvent::TouchEnd ||

            eventType == QEvent::TouchUpdate;

}

/*!

    \internal

    \brief

    \return

*/

void HbPanGestureLogic::resetGesture(HbPanGesture *gesture)

{

    gesture->d_ptr->mStartPos                     = QPointF(0,0);

    gesture->d_ptr->mDeltaSinceLastTimeStamp      = QPointF(0,0);

    gesture->d_ptr->mSceneStartPos                = QPointF(0,0);

    gesture->d_ptr->mSceneLastOffset              = QPointF(0,0);

    gesture->d_ptr->mSceneOffset                  = QPointF(0,0);

    gesture->d_ptr->mSceneDeltaSinceLastTimeStamp = QPointF(0,0);

    gesture->setLastOffset(QPointF());

    gesture->setOffset(QPointF(0,0));

    gesture->setAcceleration(0);

    gesture->setStartPos(QPointF());

    gesture->d_ptr->mIgnoreMouseEvents = false;

    gesture->d_ptr->mFollowedTouchPointId = 0;

}

/*!

    \internal

    \brief

    \return

*/

QGestureRecognizer::Result HbPanGestureLogic::handleMousePress(

        Qt::GestureState gestureState,

        HbPanGesture *gesture,

        QObject *watched,

{

    // Just ignore situations that are not interesting at all.

    if ( !( gestureState == Qt::NoGesture && me->button() == Qt::LeftButton ) )

    {

        return QGestureRecognizer::Ignore;

    }

    gesture->setHotSpot( me->globalPos() );

    gesture->setStartPos( me->globalPos() );

    gesture->setOffset( QPointF( 0,0 ) );

    gesture->setLastOffset( QPointF( 0,0 ) );

    QPointF scenePos = HbGestureUtils::mapToScene(watched, me->globalPos());

    gesture->d_ptr->mSceneStartPos       = scenePos;

    gesture->d_ptr->mSceneOffset         = HbGestureUtils::mapToScene(watched, QPointF(0,0));

    gesture->d_ptr->mSceneLastOffset     = HbGestureUtils::mapToScene(watched, QPointF(0,0));

    gesture->d_ptr->mThresholdSquare = HbDefaultPanThreshold * HbDeviceProfile::current().ppmValue();

    gesture->d_ptr->mThresholdSquare = gesture->d_ptr->mThresholdSquare * gesture->d_ptr->mThresholdSquare;

    qreal velocityThreshold = HbPanVelocityUpdateThreshold * HbDeviceProfile::current().ppmValue();

    gesture->d_ptr->mAxisX.resetRecorder(velocityThreshold);

    gesture->d_ptr->mAxisY.resetRecorder(velocityThreshold);

    gesture->d_ptr->mSceneAxisX.resetRecorder(velocityThreshold);

    gesture->d_ptr->mSceneAxisY.resetRecorder(velocityThreshold);

    return QGestureRecognizer::MayBeGesture;

}

/*!

    \internal

    \brief

    \return

*/

QGestureRecognizer::Result HbPanGestureLogic::handleMouseMove(

        Qt::GestureState gestureState,

        HbPanGesture *gesture,

        QObject *watched,

{

    if ( !me->buttons().testFlag(Qt::LeftButton))

    {

        return QGestureRecognizer::Ignore;

    }

    QPointF offset = me->globalPos() - gesture->startPos().toPoint();

    gesture->setLastOffset( gesture->offset().toPoint() );

    gesture->setOffset( offset );

    gesture->d_ptr->mSceneLastOffset = gesture->d_ptr->mSceneOffset;

    gesture->d_ptr->mSceneOffset =

            HbGestureUtils::mapToScene(watched, me->globalPos()) - gesture->d_ptr->mSceneStartPos;

    QPointF scenePos = HbGestureUtils::mapToScene(watched, me->globalPos());

    QGraphicsView* view = qobject_cast<QGraphicsView*>(watched->parent());

    if (view) {

        QGraphicsScene* scene = view->scene();

        if (scene && scene->property(HbPrivate::OverridingGesture.latin1()).isValid() &&

            scene->property(HbPrivate::OverridingGesture.latin1()).toInt() != Qt::PanGesture) {

            return QGestureRecognizer::MayBeGesture;

        }

    }

    if (gestureState == Qt::NoGesture && (offset.x() * offset.x() + offset.y() * offset.y()) <= gesture->d_ptr->mThresholdSquare) {

        return QGestureRecognizer::MayBeGesture;

    }

    // Hotspot is updated on the press and on events after the gesture started.

    // Here we are checking the previously set gestureState.

    if (gestureState == Qt::GestureStarted || gestureState == Qt::GestureUpdated) {

        gesture->setHotSpot( me->globalPos() );

    }

    return QGestureRecognizer::TriggerGesture;

}

/*!

    \internal

    \brief

    \return

*/

QGestureRecognizer::Result HbPanGestureLogic::handleMouseRelease(

        Qt::GestureState gestureState,

        HbPanGesture *gesture,

        QObject *watched,

{

    Q_UNUSED(me);

    Q_UNUSED(gesture);

    Q_UNUSED(watched);

    if ( gestureState == Qt::GestureStarted || gestureState == Qt::GestureUpdated )

    {

        return QGestureRecognizer::FinishGesture;

    }

    else

    {

        QPointF offset(gesture->offset());

        bool thresholdExceeded = (offset.x() * offset.x() + offset.y() * offset.y()) > gesture->d_ptr->mThresholdSquare;

        if( thresholdExceeded ) {

            QGraphicsView* view = qobject_cast<QGraphicsView*>(watched->parent());

            if (view) {

                QGraphicsScene* scene = view->scene();

                if (scene && scene->property(HbPrivate::OverridingGesture.latin1()).isValid() &&

                    scene->property(HbPrivate::OverridingGesture.latin1()).toInt() != Qt::PanGesture) {

                    return QGestureRecognizer::CancelGesture;

                }

            }

            return QGestureRecognizer::FinishGesture;

        }

        return QGestureRecognizer::CancelGesture;

    }

}

/*!

    \internal

    \brief

    \return

*/

QGestureRecognizer::Result HbPanGestureLogic::handleTouchBegin(

        Qt::GestureState gestureState,

        HbPanGesture *gesture,

        QObject *watched,

{

    gesture->d_ptr->mFollowedTouchPointId = getNextId(te);

    if(gesture->d_ptr->mFollowedTouchPointId == -1 && gestureState != Qt::NoGesture) {

        return QGestureRecognizer::FinishGesture; // if all touchpoints are released

    }

    QTouchEvent::TouchPoint tp = followedTouchPoint(te, gesture);

    QPointF scenePos = HbGestureUtils::mapToScene(watched, tp.screenPos());

    gesture->setHotSpot(tp.screenPos()) ;

    gesture->setStartPos(tp.screenPos());

    gesture->setOffset( QPointF( 0,0 ) );

    gesture->setLastOffset( QPointF( 0,0 ) );

    gesture->d_ptr->mSceneStartPos       = scenePos;

    gesture->d_ptr->mSceneOffset         = QPointF(0,0);

    gesture->d_ptr->mSceneLastOffset     = QPointF(0,0);

    qreal defaultThreshold = HbDefaultPanThreshold * HbDeviceProfile::current().ppmValue();

    gesture->d_ptr->mThresholdSquare = defaultThreshold * defaultThreshold;

    gesture->d_ptr->mAxisX.resetRecorder(defaultThreshold);

    gesture->d_ptr->mAxisY.resetRecorder(defaultThreshold);

    gesture->d_ptr->mSceneAxisX.resetRecorder(defaultThreshold);

    gesture->d_ptr->mSceneAxisY.resetRecorder(defaultThreshold);

    if (gestureState != Qt::NoGesture) {

        return QGestureRecognizer::Ignore;

    } else {

        return QGestureRecognizer::MayBeGesture;

    }

}

/*!

    \internal

    \brief

    \return

*/

QGestureRecognizer::Result HbPanGestureLogic::handleTouchMove(

        Qt::GestureState gestureState,

        HbPanGesture *gesture,

        QObject *watched,

{

    QTouchEvent::TouchPoint tp = followedTouchPoint(te, gesture);

    // touch event handling has already started

    // need to update position and offset

    QPointF offset = tp.screenPos() - gesture->startPos();

    if (tp.lastScreenPos() == tp.screenPos()) {

        return QGestureRecognizer::Ignore;

    }

    if (gestureState == Qt::NoGesture && (offset.x() * offset.x() + offset.y() * offset.y()) <= gesture->d_ptr->mThresholdSquare) {

        return QGestureRecognizer::MayBeGesture;

    }

    // Hotspot is updated on the press and on events after the gesture started.

    // Here we are checking the previously set gestureState.

    if (gestureState == Qt::GestureStarted || gestureState == Qt::GestureUpdated) {

        gesture->setHotSpot( tp.screenPos() );

    }

    gesture->setLastOffset( gesture->offset().toPoint() );

    gesture->setOffset( offset );

    gesture->d_ptr->mSceneLastOffset = gesture->d_ptr->mSceneOffset;

    gesture->d_ptr->mSceneOffset =

            HbGestureUtils::mapToScene(watched, tp.screenPos()) - gesture->d_ptr->mSceneStartPos;

    QPointF scenePos = HbGestureUtils::mapToScene(watched, tp.screenPos());

    QGraphicsView* view = qobject_cast<QGraphicsView*>(watched->parent());

    if (view) {

        QGraphicsScene* scene = view->scene();

        if (scene && scene->property(HbPrivate::OverridingGesture.latin1()).isValid() &&

            scene->property(HbPrivate::OverridingGesture.latin1()).toInt() != Qt::PanGesture) {

            return QGestureRecognizer::MayBeGesture;

        }

    }

    return QGestureRecognizer::TriggerGesture;

}

/*!

    \internal

    \brief

    \return

*/

QGestureRecognizer::Result HbPanGestureLogic::handleTouchEnd(

        Qt::GestureState gestureState,

        HbPanGesture *gesture,

        QObject *watched,

{

    Q_UNUSED(te);

    Q_UNUSED(gesture);

    Q_UNUSED(watched);

    if ( gestureState == Qt::GestureStarted || gestureState == Qt::GestureUpdated )

    {

        return QGestureRecognizer::FinishGesture;

    }

    else

    {

        return QGestureRecognizer::CancelGesture;

    }

}

/*!

    \internal

    \brief

    \return

*/

QGestureRecognizer::Result HbPanGestureLogic::recognize(

        Qt::GestureState gestureState,

        HbPanGesture *gesture,

        QObject *watched,

        QEvent *event,

{

    if ( isMouseEvent(event->type()) )

    {

        if (gesture->d_ptr->mIgnoreMouseEvents) {

            return QGestureRecognizer::Ignore;

        }

        QMouseEvent* me = static_cast<QMouseEvent*>(event);

        switch(event->type())

        {

        case QEvent::MouseButtonDblClick:

        case QEvent::MouseButtonPress:

        case QEvent::MouseMove:

        case QEvent::MouseButtonRelease:

        default: break;

        }

    }

    if (isTouchEvent(event->type()) && watched->isWidgetType() ) {

        QTouchEvent *te = static_cast<QTouchEvent *>(event);

        switch(event->type())

        {

        case QEvent::TouchBegin:

        case QEvent::TouchUpdate: {

                gesture->d_ptr->mIgnoreMouseEvents = true;

                if (followedTouchPoint(te, gesture).state() == Qt::TouchPointReleased) {

                    //qDebug() << "---- Finger changed ----";

                }

                if (followedTouchPoint(te, gesture).state() == Qt::TouchPointMoved) {

                }

                break;

            }

        case QEvent::TouchEnd:

            //qDebug() << "===== TOUCHEND ======" ;

            gesture->d_ptr->mIgnoreMouseEvents = false;

        default:

            break;

        }

    }

    return QGestureRecognizer::Ignore;

}

/*!

    \internal

    \brief

    \return

*/

int HbPanGestureLogic::followedTouchPointIndex(QTouchEvent *te, HbPanGesture *gesture)

{

    for(int index(0); index < te->touchPoints().count(); index++) {

        if (te->touchPoints().at(index).id() == gesture->d_ptr->mFollowedTouchPointId) {

            return index;

        }

    }

    Q_ASSERT(false);

    return -1;

}

/*!

    \internal

    \brief

    \return

*/

int HbPanGestureLogic::getNextId(QTouchEvent *te)

{

    for (int i(0); i < te->touchPoints().count(); i++) {

        if (te->touchPoints().at(i).state() != Qt::TouchPointReleased) {

            return te->touchPoints().at(i).id();

        }

    }

    return -1;

}