/****************************************************************************
**
** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the QML Gesture Area plugin of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** No Commercial Usage
** This file contains pre-release code and may not be distributed.
** You may use this file in accordance with the terms and conditions
** contained in the Technology Preview License Agreement accompanying
** this package.
**
** GNU Lesser General Public License Usage
** Alternatively, 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 qt-info@nokia.com.
**
**
**
**
**
**
**
**
** $QT_END_LICENSE$
**
****************************************************************************/

#include "qdeclarativegesturerecognizers_p.h"
#include "qgesture.h"
#include "qevent.h"
#include "qwidget.h"
#include "qabstractscrollarea.h"
#include <qgraphicssceneevent.h>
#include <QtCore/QElapsedTimer>
#include "qdebug.h"

#include "qmath.h"

#ifndef QT_NO_GESTURES

QT_BEGIN_NAMESPACE

Q_DECLARE_METATYPE(QElapsedTimer)

static const int PanGestureMovementThreshold = 30;

QPanGestureRecognizer::QPanGestureRecognizer()
{
}

QGesture *QPanGestureRecognizer::create(QObject *target)
{
    if (target && target->isWidgetType()) {
#if defined(Q_OS_WIN) && !defined(QT_NO_NATIVE_GESTURES)
        // for scroll areas on Windows we want to use native gestures instead
        if (!qobject_cast<QAbstractScrollArea *>(target->parent()))
            static_cast<QWidget *>(target)->setAttribute(Qt::WA_AcceptTouchEvents);
#else
        static_cast<QWidget *>(target)->setAttribute(Qt::WA_AcceptTouchEvents);
#endif
    } else if (target) {
        return 0;
    }
    return new QPanGesture;
}

QGestureRecognizer::Result QPanGestureRecognizer::recognize(QGesture *state,
                                                            QObject *,
                                                            QEvent *event)
{
    QPanGesture *q = static_cast<QPanGesture *>(state);

    QGestureRecognizer::Result result;
    switch (event->type()) {
    case QEvent::TouchBegin: {
        const QTouchEvent *ev = static_cast<const QTouchEvent *>(event);
        q->setProperty("gotTouched", true);
        QTouchEvent::TouchPoint p = ev->touchPoints().at(0);
        q->setOffset(QPointF());
        q->setLastOffset(QPointF());
        QElapsedTimer pressTime;
        pressTime.start();
        q->setProperty("pressTime", QVariant::fromValue(pressTime));

        result = QGestureRecognizer::MayBeGesture;
        break;
    }
    case QEvent::TouchEnd: {
        const QTouchEvent *ev = static_cast<const QTouchEvent *>(event);
        if (q->state() != Qt::NoGesture) {
            if (ev->deviceType() == QTouchEvent::TouchScreen && ev->touchPoints().size() == 1) {
                QTouchEvent::TouchPoint p1 = ev->touchPoints().at(0);
                q->setLastOffset(q->offset());
                q->setOffset(QPointF(p1.pos().x() - p1.startPos().x(), p1.pos().y() - p1.startPos().y()));
            } else if (ev->deviceType() == QTouchEvent::TouchPad && ev->touchPoints().size() == 2) {
                QTouchEvent::TouchPoint p1 = ev->touchPoints().at(0);
                QTouchEvent::TouchPoint p2 = ev->touchPoints().at(1);
                q->setLastOffset(q->offset());
                q->setOffset(QPointF(p1.pos().x() - p1.startPos().x() + p2.pos().x() - p2.startPos().x(),
                                     p1.pos().y() - p1.startPos().y() + p2.pos().y() - p2.startPos().y()) / 2);

            }
            result = QGestureRecognizer::FinishGesture;
        } else {
            result = QGestureRecognizer::CancelGesture;
        }
        break;
    }
    case QEvent::TouchUpdate: {
        bool deviceAndTouchPointsOK = false;
        const QTouchEvent *ev = static_cast<const QTouchEvent *>(event);
        QTouchEvent::TouchPoint p1;
        if (ev->deviceType() == QTouchEvent::TouchScreen && ev->touchPoints().size() == 1) {
            deviceAndTouchPointsOK = true;
            p1 = ev->touchPoints().at(0);
            q->setLastOffset(q->offset());
            q->setOffset(QPointF(p1.pos().x() - p1.startPos().x(), p1.pos().y() - p1.startPos().y()));
        } else if (ev->deviceType() == QTouchEvent::TouchPad && ev->touchPoints().size() >= 2) {
            deviceAndTouchPointsOK = true;
            p1 = ev->touchPoints().at(0);
            QTouchEvent::TouchPoint p2 = ev->touchPoints().at(1);
            q->setLastOffset(q->offset());
            q->setOffset(QPointF(p1.pos().x() - p1.startPos().x() + p2.pos().x() - p2.startPos().x(),
                                 p1.pos().y() - p1.startPos().y() + p2.pos().y() - p2.startPos().y()) / 2);
        }
        QPointF offset = q->offset();
        if (deviceAndTouchPointsOK &&
            (offset.x() > 10  || offset.y() > 10 ||
            offset.x() < -10 || offset.y() < -10)) {
            q->setHotSpot(p1.startScreenPos());
            result = QGestureRecognizer::TriggerGesture;
        } else {
            result = QGestureRecognizer::MayBeGesture;
        }
        break;
    }

    case QEvent::MouseButtonPress:
        if (!q->property("gotTouched").toBool()) {
            QMouseEvent *ev = static_cast<QMouseEvent *>(event);
            if (ev->buttons() == Qt::LeftButton && !(ev->modifiers() & Qt::ControlModifier)) {
                QPoint globalPos = ev->globalPos();
                q->setProperty("startPosition", globalPos);
                q->setProperty("lastPos", globalPos);
                state->setHotSpot(globalPos);
                state->setHandled(false);

                QElapsedTimer pressTime;
                pressTime.start();
                q->setProperty("pressTime",QVariant::fromValue(pressTime));
                q->setProperty("lastPosTime",QVariant::fromValue(pressTime));

                ev->accept();
            }
        }
        return QGestureRecognizer::MayBeGesture;

    case QEvent::MouseMove:
        if (!q->property("gotTouched").toBool()) {
            QMouseEvent *ev = static_cast<QMouseEvent *>(event);
            QPoint startPosition = q->property("startPosition").toPoint();
            if (!startPosition.isNull()) {
                QPoint delta = ev->globalPos() - startPosition;
                if (state->state() != Qt::GestureStarted || state->state() != Qt::GestureUpdated) {
                    if (delta.manhattanLength() > PanGestureMovementThreshold || q->property("pressTime").value<QElapsedTimer>().elapsed() > 200) {
                        q->setLastOffset(q->offset());
                        q->setOffset(delta);

                        QPoint lastPos = q->property("lastPos").toPoint();
                        QElapsedTimer lastPosTime = q->property("lastPosTime").value<QElapsedTimer>();
                        qreal xVelocity = q->horizontalVelocity();
                        qreal yVelocity = q->verticalVelocity();

                        qreal elapsed = qreal(lastPosTime.restart()) / 1000.;
                        q->setProperty("lastPosTime", QVariant::fromValue(lastPosTime));
                        if (elapsed <= 0)
                            elapsed = 1;
                        int dx = ev->globalPos().x() - lastPos.x();
                        xVelocity += dx / elapsed;
                        xVelocity /= 2;
                        q->setHorizontalVelocity(xVelocity);
                        int dy = ev->globalPos().y() - lastPos.y();
                        yVelocity += dy / elapsed;
                        yVelocity /= 2;
                        q->setVerticalVelocity(yVelocity);

                        q->setProperty("lastPos",ev->globalPos());
                        return QGestureRecognizer::TriggerGesture;
                    }
                }
            }
        }
        return QGestureRecognizer::Ignore;

    case QEvent::MouseButtonRelease:
        if (!q->property("gotTouched").toBool()) {
            if(q->state() != Qt::NoGesture) {
                QMouseEvent *ev = static_cast<QMouseEvent *>(event);
                if (q->property("lastPosTime").value<QElapsedTimer>().elapsed() > 100) {
                    // if we drag then pause before release we should not cause a flick.
                    q->setHorizontalVelocity(0);
                    q->setVerticalVelocity(0);
                } else {
                    // FlickThreshold determines how far the "mouse" must have moved
                    // before we perform a flick.
                    static const int FlickThreshold = 20;

                    // Really slow flicks can be annoying.
                    static const int minimumFlickVelocity = 200;

                    qreal xVelocity = q->horizontalVelocity();
                    if (qAbs(xVelocity) > 10 && qAbs(ev->globalPos().x() - q->property("startPosition").toPoint().x()) > FlickThreshold) {
                        if (qAbs(xVelocity) < minimumFlickVelocity)
                            q->setHorizontalVelocity(xVelocity < 0 ? -minimumFlickVelocity : minimumFlickVelocity);
                    }
                    qreal yVelocity = q->verticalVelocity();
                    if (qAbs(yVelocity) > 10 && qAbs(ev->globalPos().y() - q->property("startPosition").toPoint().y()) > FlickThreshold) {
                        if (qAbs(yVelocity) < minimumFlickVelocity)
                            q->setVerticalVelocity(yVelocity < 0 ? -minimumFlickVelocity : minimumFlickVelocity);
                    }
                }
                if (!q->property("startPosition").toPoint().isNull() && !q->lastOffset().isNull()) {
                    return QGestureRecognizer::FinishGesture;
                }
            }
        }
        return QGestureRecognizer::CancelGesture;

    default:
        result = QGestureRecognizer::Ignore;
        break;
    }
    return result;
}

void QPanGestureRecognizer::reset(QGesture *state)
{
    if (!state)
        return;
    QPanGesture *pan = static_cast<QPanGesture*>(state);
    pan->setProperty("startPosition", QPoint());
    pan->setLastOffset(QPointF());
    pan->setOffset(QPointF());
    pan->setAcceleration(0);
    pan->setProperty("gotTouched",false);
    QElapsedTimer pressTime = pan->property("pressTime").value<QElapsedTimer>();
    pressTime.invalidate();
    pan->setProperty("pressTime",QVariant::fromValue(pressTime));
    QElapsedTimer lastPosTime = pan->property("lastPosTime").value<QElapsedTimer>();
    lastPosTime.invalidate();
    pan->setProperty("lastPosTime", QVariant::fromValue(lastPosTime));
    pan->setProperty("lastPos",QPoint());
    pan->setHorizontalVelocity(0);
    pan->setVerticalVelocity(0);

    QGestureRecognizer::reset(state);
}


//
// QPinchGestureRecognizer
//
/*
QPinchGestureRecognizer::QPinchGestureRecognizer()
{
}

QGesture *QPinchGestureRecognizer::create(QObject *target)
{
    if (target) {
        if (target->isWidgetType())
            static_cast<QWidget *>(target)->setAttribute(Qt::WA_AcceptTouchEvents);
        else
            return 0;
    }
    return new QPinchGesture;
}

QGestureRecognizer::Result QPinchGestureRecognizer::recognize(QGesture *state,
                                                              QObject *obj,
                                                              QEvent *event)
{
    QPinchGesture *q = static_cast<QPinchGesture *>(state);
    QPinchGesturePrivate *d = q->d_func();

    QGestureRecognizer::Result result;

    switch (event->type()) {
    case QEvent::TouchBegin: {
        d->gotTouched = true;
        result = QGestureRecognizer::MayBeGesture;
        break;
    }
    case QEvent::TouchEnd: {
        if (q->state() != Qt::NoGesture) {
            result = QGestureRecognizer::FinishGesture;
        } else {
            result = QGestureRecognizer::CancelGesture;
        }
        break;
    }
    case QEvent::TouchUpdate: {
        const QTouchEvent *ev = static_cast<const QTouchEvent *>(event);
        d->changeFlags = 0;
        if (ev->touchPoints().size() == 2) {
            QTouchEvent::TouchPoint p1 = ev->touchPoints().at(0);
            QTouchEvent::TouchPoint p2 = ev->touchPoints().at(1);

            d->hotSpot = p1.screenPos();
            d->isHotSpotSet = true;

            if (d->isNewSequence) {
                d->startPosition[0] = p1.screenPos();
                d->startPosition[1] = p2.screenPos();
            }
            QLineF line(p1.screenPos(), p2.screenPos());
            QLineF lastLine(p1.lastScreenPos(),  p2.lastScreenPos());
            QLineF tmp(line);
            tmp.setLength(line.length() / 2.);
            QPointF centerPoint = tmp.p2();

            d->lastCenterPoint = d->centerPoint;
            d->centerPoint = centerPoint;
            d->changeFlags |= QPinchGesture::CenterPointChanged;

            const qreal scaleFactor = line.length() / lastLine.length();

            if (d->isNewSequence) {
                d->lastScaleFactor = scaleFactor;
                d->lastCenterPoint = centerPoint;
            } else {
                d->lastScaleFactor = d->scaleFactor;
            }
            d->scaleFactor = scaleFactor;
            d->totalScaleFactor = d->totalScaleFactor * scaleFactor;
            d->changeFlags |= QPinchGesture::ScaleFactorChanged;

            qreal angle = QLineF(p1.screenPos(), p2.screenPos()).angle();
            if (angle > 180)
                angle -= 360;
            qreal startAngle = QLineF(p1.startScreenPos(), p2.startScreenPos()).angle();
            if (startAngle > 180)
                startAngle -= 360;
            const qreal rotationAngle = startAngle - angle;
            if (d->isNewSequence)
                d->lastRotationAngle = rotationAngle;
            else
                d->lastRotationAngle = d->rotationAngle;
            d->rotationAngle = rotationAngle;
            d->totalRotationAngle += d->rotationAngle - d->lastRotationAngle;
            d->changeFlags |= QPinchGesture::RotationAngleChanged;

            d->totalChangeFlags |= d->changeFlags;
            if(p1.state() == Qt::TouchPointReleased || p2.state() == Qt::TouchPointReleased)
                d->isNewSequence = true;
            else
                d->isNewSequence = false;
            result = QGestureRecognizer::TriggerGesture;
        } else {
            d->isNewSequence = true;
            if (q->state() != Qt::NoGesture)
                result = QGestureRecognizer::Ignore;
            else
                result = QGestureRecognizer::FinishGesture;
        }
        break;
    }

    case QEvent::Wheel: {
        QWheelEvent *ev = static_cast<QWheelEvent *>(event);
        const Qt::KeyboardModifiers ctrlShiftMask = Qt::ControlModifier | Qt::ShiftModifier;
        if (ev->modifiers() & (Qt::ControlModifier | Qt::ShiftModifier)) {
            q->setHotSpot(ev->globalPos());

            bool isNewSequence = q->state() == Qt::NoGesture;

            d->lastCenterPoint = d->centerPoint;
            d->centerPoint = ev->globalPos();

            d->changeFlags = 0;

            if (ev->modifiers() & Qt::ControlModifier) {
                d->lastScaleFactor = d->scaleFactor;
                if (ev->delta() > 0)
                    d->scaleFactor = 1.1 * qAbs(ev->delta()) / 8. / 15.;
                else
                    d->scaleFactor = 0.9 / qAbs(ev->delta() / 8. / 15.);
                d->changeFlags |= QPinchGesture::ScaleFactorChanged;
            } else if (ev->modifiers() & Qt::ShiftModifier) {
                d->lastRotationAngle = d->rotationAngle;
                d->rotationAngle += ev->delta() / 8. / 15.;
                d->changeFlags |= QPinchGesture::RotationAngleChanged;
            }

            if (isNewSequence) {
                d->lastCenterPoint = d->centerPoint;
                d->lastScaleFactor = d->scaleFactor;
                d->lastRotationAngle = d->rotationAngle;
            }

            int timerId = q->property("timerid").toInt();
            if (timerId)
                q->killTimer(timerId);
            q->setProperty("timerid", q->startTimer(400));
            return QGestureRecognizer::TriggerGesture | QGestureRecognizer::ConsumeEventHint;
        }
        return QGestureRecognizer::Ignore;
    }
    case QEvent::MouseButtonPress:
        if (q->property("timerid").toInt()) {
            return QGestureRecognizer::FinishGesture;
        }
        return QGestureRecognizer::Ignore;

    case QEvent::Timer: {
        int timerId = state->property("timerid").toInt();
        if (obj == state && timerId) {
            state->killTimer(timerId);
            d->changeFlags = 0;
            return QGestureRecognizer::FinishGesture | QGestureRecognizer::ConsumeEventHint;
        }
    }

    default:
        result = QGestureRecognizer::Ignore;
        break;
    }
    return result;
}

void QPinchGestureRecognizer::reset(QGesture *state)
{
    if (!state)
        return;
    QPinchGesture *pinch = static_cast<QPinchGesture *>(state);
    QPinchGesturePrivate *d = pinch->d_func();

    d->totalChangeFlags = d->changeFlags = 0;

    d->startCenterPoint = d->lastCenterPoint = d->centerPoint = QPointF();
    d->totalScaleFactor = d->lastScaleFactor = d->scaleFactor = 1;
    d->totalRotationAngle = d->lastRotationAngle = d->rotationAngle = 0;

    d->isNewSequence = true;
    d->startPosition[0] = d->startPosition[1] = QPointF();

    d->gotTouched = false;

    int timerId = state->property("timerid").toInt();
    if (timerId) {
        state->killTimer(timerId);
        state->setProperty("timerid", QVariant());
    }
    QGestureRecognizer::reset(state);
}

//
// QSwipeGestureRecognizer
//

QSwipeGestureRecognizer::QSwipeGestureRecognizer()
{
}

QGesture *QSwipeGestureRecognizer::create(QObject *target)
{
    if (target) {
        if (target->isWidgetType())
            static_cast<QWidget *>(target)->setAttribute(Qt::WA_AcceptTouchEvents);
        else
            return 0;
    }
    return new QSwipeGesture;
}

QGestureRecognizer::Result QSwipeGestureRecognizer::recognize(QGesture *state,
                                                              QObject *,
                                                              QEvent *event)
{
    QSwipeGesture *q = static_cast<QSwipeGesture *>(state);
    QSwipeGesturePrivate *d = q->d_func();

    QGestureRecognizer::Result result;

    switch (event->type()) {
    case QEvent::TouchBegin: {
        d->gotTouched = true;
        d->velocityValue = 1;
        d->time.start();
        d->started = true;
        result = QGestureRecognizer::MayBeGesture;
        break;
    }
    case QEvent::TouchEnd: {
        if (q->state() != Qt::NoGesture) {
            result = QGestureRecognizer::FinishGesture;
        } else {
            result = QGestureRecognizer::CancelGesture;
        }
        break;
    }
    case QEvent::TouchUpdate: {
        const QTouchEvent *ev = static_cast<const QTouchEvent *>(event);
        if (!d->started)
            result = QGestureRecognizer::CancelGesture;
        else if (ev->touchPoints().size() == 2) {
            QTouchEvent::TouchPoint p1 = ev->touchPoints().at(0);
            QTouchEvent::TouchPoint p2 = ev->touchPoints().at(1);

            if (d->lastPositions[0].isNull()) {
                d->lastPositions[0] = p1.startScreenPos().toPoint();
                d->lastPositions[1] = p2.startScreenPos().toPoint();
            }
            d->hotSpot = p1.screenPos();
            d->isHotSpotSet = true;

            int xDistance = (p1.screenPos().x() - d->lastPositions[0].x() +
                             p2.screenPos().x() - d->lastPositions[1].x()) / 2;
            int yDistance = (p1.screenPos().y() - d->lastPositions[0].y() +
                             p2.screenPos().y() - d->lastPositions[1].y()) / 2;
            int absXDistance = qAbs(xDistance);
            int absYDistance = qAbs(yDistance);

            const int distance = absXDistance >= absYDistance ? absXDistance : absYDistance;
            int elapsedTime = d->time.restart();
            if (!elapsedTime)
                elapsedTime = 1;
            d->velocityValue = 0.9 * d->velocityValue + distance / elapsedTime;
            d->swipeAngle = QLineF(p1.startScreenPos(), p1.screenPos()).angle();

            static const int MoveThreshold = 50;
            if (absXDistance > MoveThreshold || absYDistance > MoveThreshold) {
                // measure the distance to check if the direction changed
                d->lastPositions[0] = p1.screenPos().toPoint();
                d->lastPositions[1] = p2.screenPos().toPoint();
                QSwipeGesture::SwipeDirection horizontal =
                        xDistance > 0 ? QSwipeGesture::Right : QSwipeGesture::Left;
                QSwipeGesture::SwipeDirection vertical =
                        yDistance > 0 ? QSwipeGesture::Down : QSwipeGesture::Up;
                if (d->verticalDirection == QSwipeGesture::NoDirection)
                    d->verticalDirection = vertical;
                if (d->horizontalDirection == QSwipeGesture::NoDirection)
                    d->horizontalDirection = horizontal;
                if (d->verticalDirection != vertical || d->horizontalDirection != horizontal) {
                    // the user has changed the direction!
                    result = QGestureRecognizer::CancelGesture;
                }
                result = QGestureRecognizer::TriggerGesture;
            } else {
                if (q->state() != Qt::NoGesture)
                    result = QGestureRecognizer::TriggerGesture;
                else
                    result = QGestureRecognizer::MayBeGesture;
            }
        } else if (ev->touchPoints().size() > 2) {
            result = QGestureRecognizer::CancelGesture;
        } else { // less than 2 touch points
            if (d->started && (ev->touchPointStates() & Qt::TouchPointPressed))
                result = QGestureRecognizer::CancelGesture;
            else if (d->started)
                result = QGestureRecognizer::Ignore;
            else
                result = QGestureRecognizer::MayBeGesture;
        }
        break;
    }

    case QEvent::MouseButtonPress: {
        if(!d->gotTouched) {
            const QMouseEvent *ev = static_cast<const QMouseEvent *>(event);
            d->velocityValue = 1;
            d->time.start();
            d->started = true;
            state->setHotSpot(ev->globalPos());
            return QGestureRecognizer::MayBeGesture;
        }
        return QGestureRecognizer::Ignore;
    }
    case QEvent::MouseButtonRelease: {
        if(!d->gotTouched) {
            if (q->state() != Qt::NoGesture) {
                result = QGestureRecognizer::FinishGesture;
            } else {
                result = QGestureRecognizer::CancelGesture;
            }
        } else
            result = QGestureRecognizer::Ignore;
        break;
    }

    case QEvent::MouseMove: {
        if(!d->gotTouched) {
            const QMouseEvent *ev = static_cast<const QMouseEvent *>(event);
            if (!d->started)
                result = QGestureRecognizer::CancelGesture;
            else {
                if (d->lastPositions[0].isNull()) {
                    d->lastPositions[0] = ev->pos();
                }

                int xDistance = (ev->x() - d->lastPositions[0].x());
                int yDistance = (ev->y() - d->lastPositions[0].y());
                int absXDistance = qAbs(xDistance);
                int absYDistance = qAbs(yDistance);

                const int distance = absXDistance >= absYDistance ? absXDistance : absYDistance;
                int elapsedTime = d->time.restart();
                if (!elapsedTime)
                    elapsedTime = 1;
                d->velocityValue = 0.9 * d->velocityValue + distance / elapsedTime;
                d->swipeAngle = QLineF(d->lastPositions[0], ev->pos()).angle();

                static const int MoveThreshold = 50;
                if (absXDistance > MoveThreshold || absYDistance > MoveThreshold) {
                    // measure the distance to check if the direction changed
                    d->lastPositions[0] = ev->pos();
                    QSwipeGesture::SwipeDirection horizontal =
                            xDistance > 0 ? QSwipeGesture::Right : QSwipeGesture::Left;
                    QSwipeGesture::SwipeDirection vertical =
                            yDistance > 0 ? QSwipeGesture::Down : QSwipeGesture::Up;
                    if (d->verticalDirection == QSwipeGesture::NoDirection)
                        d->verticalDirection = vertical;
                    if (d->horizontalDirection == QSwipeGesture::NoDirection)
                        d->horizontalDirection = horizontal;
                    if (d->verticalDirection != vertical || d->horizontalDirection != horizontal) {
                        // the user has changed the direction!
                        result = QGestureRecognizer::CancelGesture;
                    }
                    result = QGestureRecognizer::TriggerGesture;
                } else {
                    if (q->state() != Qt::NoGesture)
                        result = QGestureRecognizer::TriggerGesture;
                    else
                        result = QGestureRecognizer::MayBeGesture;
                }
            }
        } else
            result = QGestureRecognizer::Ignore;
        break;
    }
    default:
        result = QGestureRecognizer::Ignore;
        break;
    }
    return result;
}

void QSwipeGestureRecognizer::reset(QGesture *state)
{
    if (!state)
        return;
    QSwipeGesture *q = static_cast<QSwipeGesture *>(state);
    QSwipeGesturePrivate *d = q->d_func();

    d->verticalDirection = d->horizontalDirection = QSwipeGesture::NoDirection;
    d->swipeAngle = 0;
    d->gotTouched = false;

    d->lastPositions[0] = d->lastPositions[1] = d->lastPositions[2] = QPoint();
    d->started = false;
    d->velocityValue = 0;
    d->time.invalidate();

    QGestureRecognizer::reset(state);
}

//
// QTapGestureRecognizer
//

QTapGestureRecognizer::QTapGestureRecognizer()
{
}

QGesture *QTapGestureRecognizer::create(QObject *target)
{
    if (target) {
        if (target->isWidgetType())
            static_cast<QWidget *>(target)->setAttribute(Qt::WA_AcceptTouchEvents);
        else
            return 0;
    }
    return new QTapGesture;
}

QGestureRecognizer::Result QTapGestureRecognizer::recognize(QGesture *state,
                                                            QObject *,
                                                            QEvent *event)
{
    QTapGesture *q = static_cast<QTapGesture *>(state);
    QTapGesturePrivate *d = q->d_func();

    QGestureRecognizer::Result result = QGestureRecognizer::CancelGesture;

    switch (event->type()) {
    case QEvent::TouchBegin: {
        d->gotTouched = true;
        const QTouchEvent *ev = static_cast<const QTouchEvent *>(event);
        d->position = ev->touchPoints().at(0).pos();
        q->setHotSpot(ev->touchPoints().at(0).screenPos());
        result = QGestureRecognizer::TriggerGesture;
        break;
    }
    case QEvent::TouchUpdate:
    case QEvent::TouchEnd: {
        const QTouchEvent *ev = static_cast<const QTouchEvent *>(event);
        if (q->state() != Qt::NoGesture && ev->touchPoints().size() == 1) {
            QTouchEvent::TouchPoint p = ev->touchPoints().at(0);
            QPoint delta = p.pos().toPoint() - p.startPos().toPoint();
            enum { TapRadius = 40 };
            if (delta.manhattanLength() <= TapRadius) {
                if (event->type() == QEvent::TouchEnd)
                    result = QGestureRecognizer::FinishGesture;
                else
                    result = QGestureRecognizer::TriggerGesture;
            }
        }
        break;
    }

    case QEvent::MouseButtonPress:
        if (!d->gotTouched) {
            QMouseEvent *ev = static_cast<QMouseEvent *>(event);
            if (!(ev->modifiers() & Qt::ControlModifier)) {
                state->setProperty("position", ev->globalPos());
                state->setHotSpot(ev->globalPos());
                state->setHandled(false);
                event->accept();
                return QGestureRecognizer::TriggerGesture | QGestureRecognizer::ConsumeEventHint;
            }
        }
        return QGestureRecognizer::Ignore;

    case QEvent::MouseMove:
        return QGestureRecognizer::Ignore;

    case QEvent::MouseButtonRelease:
        if (!d->gotTouched) {
            if (state->state() == Qt::GestureStarted) {
                return QGestureRecognizer::FinishGesture;
            }
        }
        return QGestureRecognizer::Ignore;

    case QEvent::Gesture: {
        // We check for other gesture events: TapAndHold and Pan both cancel the simple Tap
        QGestureEvent *ge = static_cast<QGestureEvent *>(event);
        if (ge->gesture(Qt::PanGesture) || ge->gesture(Qt::TapAndHoldGesture)) {
            if (state->state() == Qt::GestureStarted || state->state() == Qt::GestureUpdated)
                return QGestureRecognizer::CancelGesture;
        }
        return QGestureRecognizer::Ignore;
    }

    default:
        result = QGestureRecognizer::Ignore;
        break;
    }
    return result;
}

void QTapGestureRecognizer::reset(QGesture *state)
{
    if (!state)
        return;
    QTapGesture *q = static_cast<QTapGesture *>(state);
    QTapGesturePrivate *d = q->d_func();

    d->position = QPointF();

    QGestureRecognizer::reset(state);
}

//
// QTapAndHoldGestureRecognizer
//

QTapAndHoldGestureRecognizer::QTapAndHoldGestureRecognizer()
{
}

QGesture *QTapAndHoldGestureRecognizer::create(QObject *target)
{
    if (target) {
        if (target->isWidgetType())
            static_cast<QWidget *>(target)->setAttribute(Qt::WA_AcceptTouchEvents);
        else
            return 0;
    }
    return new QTapAndHoldGesture;
}

QGestureRecognizer::Result
QTapAndHoldGestureRecognizer::recognize(QGesture *state, QObject *object,
                                        QEvent *event)
{
    QTapAndHoldGesture *q = static_cast<QTapAndHoldGesture *>(state);
    QTapAndHoldGesturePrivate *d = q->d_func();

    if (object == state && event->type() == QEvent::Timer) {
        q->killTimer(d->timerId);
        d->timerId = 0;
        return QGestureRecognizer::FinishGesture | QGestureRecognizer::ConsumeEventHint;
    }

    const QTouchEvent *ev = static_cast<const QTouchEvent *>(event);
//    const QMouseEvent *me = static_cast<const QMouseEvent *>(event);
#ifndef QT_NO_GRAPHICSVIEW
    const QMouseEvent *gsme = static_cast<const QMouseEvent *>(event);
#endif

    enum { TapRadius = 40 };

    switch (event->type()) {
#ifndef QT_NO_GRAPHICSVIEW
    case QEvent::MouseButtonPress:
        d->position = gsme->globalPos();
        q->setHotSpot(d->position);
        if (d->timerId)
            q->killTimer(d->timerId);
        d->timerId = q->startTimer(QTapAndHoldGesturePrivate::Timeout);
        return QGestureRecognizer::MayBeGesture; // we don't show a sign of life until the timeout
#endif
//    case QEvent::MouseButtonPress:
//        d->position = me->globalPos();
//        q->setHotSpot(d->position);
//        if (d->timerId)
//            q->killTimer(d->timerId);
//        d->timerId = q->startTimer(QTapAndHoldGesturePrivate::Timeout);
//        return QGestureRecognizer::MayBeGesture; // we don't show a sign of life until the timeout
    case QEvent::TouchBegin:
        d->position = ev->touchPoints().at(0).startScreenPos();
        q->setHotSpot(d->position);
        if (d->timerId)
            q->killTimer(d->timerId);
        d->timerId = q->startTimer(QTapAndHoldGesturePrivate::Timeout);
        return QGestureRecognizer::MayBeGesture; // we don't show a sign of life until the timeout
#ifndef QT_NO_GRAPHICSVIEW
    case QEvent::MouseButtonRelease:
#endif
//    case QEvent::MouseButtonRelease:
    case QEvent::TouchEnd:
        return QGestureRecognizer::CancelGesture; // get out of the MayBeGesture state
    case QEvent::TouchUpdate:
        if (d->timerId && ev->touchPoints().size() == 1) {
            QTouchEvent::TouchPoint p = ev->touchPoints().at(0);
            QPoint delta = p.pos().toPoint() - p.startPos().toPoint();
            if (delta.manhattanLength() <= TapRadius)
                return QGestureRecognizer::MayBeGesture;
        }
        return QGestureRecognizer::CancelGesture;
//    case QEvent::MouseMove: {
//        QPoint delta = me->globalPos() - d->position.toPoint();
//        if (d->timerId && delta.manhattanLength() <= TapRadius)
//            return QGestureRecognizer::MayBeGesture;
//        return QGestureRecognizer::CancelGesture;
//    }
#ifndef QT_NO_GRAPHICSVIEW
    case QEvent::MouseMove: {
        QPoint delta = gsme->globalPos() - d->position.toPoint();
        if (d->timerId && delta.manhattanLength() <= TapRadius)
            return QGestureRecognizer::MayBeGesture;
        return QGestureRecognizer::CancelGesture;
    }
#endif
    default:
        return QGestureRecognizer::Ignore;
    }
}

void QTapAndHoldGestureRecognizer::reset(QGesture *state)
{
    if (!state)
        return;
    QTapAndHoldGesture *q = static_cast<QTapAndHoldGesture *>(state);
    QTapAndHoldGesturePrivate *d = q->d_func();

    d->position = QPointF();
    if (d->timerId)
        q->killTimer(d->timerId);
    d->timerId = 0;

    QGestureRecognizer::reset(state);
}*/

QT_END_NAMESPACE

#endif // QT_NO_GESTURES