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

**

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

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the QtGui module 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 "qgesture.h"

#include "private/qgesture_p.h"

QT_BEGIN_NAMESPACE

 /*!

    \class QGesture

    \since 4.6

    \ingroup gestures

    \brief The QGesture class represents a gesture, containing properties that

    describe the corresponding user input.

    Gesture objects are not constructed directly by developers. They are created by

    the QGestureRecognizer object that is registered with the application; see

    QApplication::registerGestureRecognizer().

    \section1 Gesture Properties

    The class has a list of properties that can be queried by the user to get

    some gesture-specific arguments. For example, the pinch gesture has a scale

    factor that is exposed as a property.

    Developers of custom gesture recognizers can add additional properties in

    order to provide additional information about a gesture. This can be done

    by adding new dynamic properties to a QGesture object, or by subclassing

    the QGesture class (or one of its subclasses).

    \section1 Lifecycle of a Gesture Object

    A QGesture instance is created when the application calls QWidget::grabGesture()

    or QGraphicsObject::grabGesture() to configure a widget or graphics object (the

    target object) for gesture input. One gesture object is created for each target

    object.

    The registered gesture recognizer monitors the input events for the target

    object via its \l{QGestureRecognizer::}{filterEvent()} function, updating the

    properties of the gesture object as required.

    The gesture object may be delivered to the target object in a QGestureEvent if

    the corresponding gesture is active or has just been canceled. Each event that

    is delivered contains a list of gesture objects, since support for more than

    one gesture may be enabled for the target object. Due to the way events are

    handled in Qt, gesture events may be filtered by other objects.

    \sa QGestureEvent, QGestureRecognizer

*/

/*!

    Constructs a new gesture object with the given \a parent.

    QGesture objects are created by gesture recognizers in the

    QGestureRecognizer::createGesture() function.

*/

QGesture::QGesture(QObject *parent)

    : QObject(*new QGesturePrivate, parent)

{

    d_func()->gestureType = Qt::CustomGesture;

}

/*!

    \internal

*/

QGesture::QGesture(QGesturePrivate &dd, QObject *parent)

    : QObject(dd, parent)

{

}

/*!

    Destroys the gesture object.

*/

QGesture::~QGesture()

{

}

/*!

    \property QGesture::state

    \brief the current state of the gesture

*/

/*!

    \property QGesture::gestureType

    \brief the type of the gesture

*/

/*!

    \property QGesture::hotSpot

    \brief The point that is used to find the receiver for the gesture event.

    The hot-spot is a point in the global coordinate system, use

    QWidget::mapFromGlobal() or QGestureEvent::mapToScene() to get a

    local hot-spot.

    If the hot-spot is not set, the targetObject is used as the receiver of the

    gesture event.

*/

/*!

    \property QGesture::hasHotSpot

    \brief whether the gesture has a hot-spot

*/

/*!

    \property QGesture::targetObject

    \brief the target object which will receive the gesture event if the hotSpot is

    not set

*/

Qt::GestureType QGesture::gestureType() const

{

    return d_func()->gestureType;

}

Qt::GestureState QGesture::state() const

{

    return d_func()->state;

}

QPointF QGesture::hotSpot() const

{

    return d_func()->hotSpot;

}

void QGesture::setHotSpot(const QPointF &value)

{

    Q_D(QGesture);

    d->hotSpot = value;

    d->isHotSpotSet = true;

}

bool QGesture::hasHotSpot() const

{

    return d_func()->isHotSpotSet;

}

void QGesture::unsetHotSpot()

{

    d_func()->isHotSpotSet = false;

}

/*!

    \class QPanGesture

    \since 4.6

    \brief The QPanGesture class describes a panning gesture made by the user.

    \ingroup gestures

    \image pangesture.png

    \sa {Gestures Programming}, QPinchGesture, QSwipeGesture

*/

/*!

    \property QPanGesture::totalOffset

    \brief the total offset from the first input position to the current input

    position

    The total offset measures the total change in position of the user's input

    covered by the gesture on the input device.

*/

/*!

    \property QPanGesture::lastOffset

    \brief the last offset recorded for this gesture

    The last offset contains the change in position of the user's input as

    reported in the \l offset property when a previous gesture event was

    delivered for this gesture.

    If no previous event was delivered with information about this gesture

    (i.e., this gesture object contains information about the first movement

    in the gesture) then this property contains a zero size.

*/

/*!

    \property QPanGesture::offset

    \brief the offset from the previous input position to the current input

    position

    The offset measures the change in position of the user's input on the

    input device.

*/

/*!

    \property QPanGesture::acceleration

*/

/*!

    \internal

*/

QPanGesture::QPanGesture(QObject *parent)

    : QGesture(*new QPanGesturePrivate, parent)

{

    d_func()->gestureType = Qt::PanGesture;

}

QPointF QPanGesture::totalOffset() const

{

    return d_func()->totalOffset;

}

QPointF QPanGesture::lastOffset() const

{

    return d_func()->lastOffset;

}

QPointF QPanGesture::offset() const

{

    return d_func()->offset;

}

qreal QPanGesture::acceleration() const

{

    return d_func()->acceleration;

}

void QPanGesture::setTotalOffset(const QPointF &value)

{

    d_func()->totalOffset = value;

}

void QPanGesture::setLastOffset(const QPointF &value)

{

    d_func()->lastOffset = value;

}

void QPanGesture::setOffset(const QPointF &value)

{

    d_func()->offset = value;

}

void QPanGesture::setAcceleration(qreal value)

{

    d_func()->acceleration = value;

}

/*!

    \class QPinchGesture

    \since 4.6

    \brief The QPinchGesture class describes a pinch gesture made my the user.

    \ingroup multitouch

    \ingroup gestures

    A pinch gesture is a form of multitouch user input in which the user typically

    touches two points on the input device with a thumb and finger, before moving

    them closer together or further apart to change the scale factor, zoom, or level

    of detail of the user interface.

    \image pinchgesture.png

    Instead of repeatedly applying the same pinching gesture, the user may

    continue to touch the input device in one place, and apply a second touch

    to a new point, continuing the gesture. When this occurs, gesture events

    will continue to be delivered to the target object, containing an instance

    of QPinchGesture in the Qt::GestureUpdated state.

    \sa {Gestures Programming}, QPanGesture, QSwipeGesture

*/

/*!

    \enum QPinchGesture::WhatChange

    This enum describes the changes that can occur to the properties of

    the gesture object.

    \value ScaleFactorChanged The scale factor held by scaleFactor changed.

    \value RotationAngleChanged The rotation angle held by rotationAngle changed.

    \value CenterPointChanged The center point held by centerPoint changed.

    \sa whatChanged

*/

/*!

    \property QPinchGesture::whatChanged

    \brief the property of the gesture that has changed

    This property indicates which of the other properties has changed since

    the previous gesture event included information about this gesture. You

    can use this information to determine which aspect of your user interface

    needs to be updated.

    \sa scaleFactor, rotationAngle, centerPoint

*/

/*!

    \property QPinchGesture::totalScaleFactor

    \brief the total scale factor

    The total scale factor measures the total change in scale factor from the

    original value to the current scale factor.

    \sa scaleFactor, lastScaleFactor

*/

/*!

    \property QPinchGesture::lastScaleFactor

    \brief the last scale factor recorded for this gesture

    The last scale factor contains the scale factor reported in the

    \l scaleFactor property when a previous gesture event included

    information about this gesture.

    If no previous event was delivered with information about this gesture

    (i.e., this gesture object contains information about the first movement

    in the gesture) then this property contains zero.

    \sa scaleFactor, totalScaleFactor

*/

/*!

    \property QPinchGesture::scaleFactor

    \brief the current scale factor

    The scale factor measures the scale factor associated with the distance

    between two of the user's inputs on a multitouch device.

    \sa totalScaleFactor, lastScaleFactor

*/

/*!

    \property QPinchGesture::totalRotationAngle

    \brief the total angle covered by the gesture

    This total angle measures the complete angle covered by the gesture. Usually, this

    is equal to the value held by the \l rotationAngle property, except in the case where

    the user performs multiple rotations by removing and repositioning one of the touch

    points, as described above. In this case, the total angle will be the sum of the

    rotation angles for the multiple stages of the gesture.

    \sa rotationAngle, lastRotationAngle

*/

/*!

    \property QPinchGesture::lastRotationAngle

    \brief the last reported angle covered by the gesture motion

    The last rotation angle is the angle as reported in the \l rotationAngle property

    when a previous gesture event was delivered for this gesture.

    \sa rotationAngle, totalRotationAngle

*/

/*!

    \property QPinchGesture::rotationAngle

    \brief the angle covered by the gesture motion

    \sa totalRotationAngle, lastRotationAngle

*/

/*!

    \property QPinchGesture::startCenterPoint

    \brief the starting position of the center point

    \sa centerPoint, lastCenterPoint

*/

/*!

    \property QPinchGesture::lastCenterPoint

    \brief the last position of the center point recorded for this gesture

    \sa centerPoint, startCenterPoint

*/

/*!

    \property QPinchGesture::centerPoint

    \brief the current center point

    The center point is the midpoint between the two input points in the gesture.

    \sa startCenterPoint, lastCenterPoint

*/

/*!

    \internal

*/

QPinchGesture::QPinchGesture(QObject *parent)

    : QGesture(*new QPinchGesturePrivate, parent)

{

    d_func()->gestureType = Qt::PinchGesture;

}

QPinchGesture::WhatChanged QPinchGesture::whatChanged() const

{

    return d_func()->whatChanged;

}

void QPinchGesture::setWhatChanged(QPinchGesture::WhatChanged value)

{

    d_func()->whatChanged = value;

}

QPointF QPinchGesture::startCenterPoint() const

{

    return d_func()->startCenterPoint;

}

QPointF QPinchGesture::lastCenterPoint() const

{

    return d_func()->lastCenterPoint;

}

QPointF QPinchGesture::centerPoint() const

{

    return d_func()->centerPoint;

}

void QPinchGesture::setStartCenterPoint(const QPointF &value)

{

    d_func()->startCenterPoint = value;

}

void QPinchGesture::setLastCenterPoint(const QPointF &value)

{

    d_func()->lastCenterPoint = value;

}

void QPinchGesture::setCenterPoint(const QPointF &value)

{

    d_func()->centerPoint = value;

}

qreal QPinchGesture::totalScaleFactor() const

{

    return d_func()->totalScaleFactor;

}

qreal QPinchGesture::lastScaleFactor() const

{

    return d_func()->lastScaleFactor;

}

qreal QPinchGesture::scaleFactor() const

{

    return d_func()->scaleFactor;

}

void QPinchGesture::setTotalScaleFactor(qreal value)

{

    d_func()->totalScaleFactor = value;

}

void QPinchGesture::setLastScaleFactor(qreal value)

{

    d_func()->lastScaleFactor = value;

}

void QPinchGesture::setScaleFactor(qreal value)

{

    d_func()->scaleFactor = value;

}

qreal QPinchGesture::totalRotationAngle() const

{

    return d_func()->totalRotationAngle;

}

qreal QPinchGesture::lastRotationAngle() const

{

    return d_func()->lastRotationAngle;

}

qreal QPinchGesture::rotationAngle() const

{

    return d_func()->rotationAngle;

}

void QPinchGesture::setTotalRotationAngle(qreal value)

{

    d_func()->totalRotationAngle = value;

}

void QPinchGesture::setLastRotationAngle(qreal value)

{

    d_func()->lastRotationAngle = value;

}

void QPinchGesture::setRotationAngle(qreal value)

{

    d_func()->rotationAngle = value;

}

/*!

    \class QSwipeGesture

    \since 4.6

    \brief The QSwipeGesture class describes a swipe gesture made by the user.

    \ingroup gestures

    \image swipegesture.png