1190 lines
33 KiB
C++
1190 lines
33 KiB
C++
/****************************************************************************
|
|
**
|
|
** Copyright (C) 2016 The Qt Company Ltd.
|
|
** Contact: https://www.qt.io/licensing/
|
|
**
|
|
** This file is part of the QtWidgets module of the Qt Toolkit.
|
|
**
|
|
** $QT_BEGIN_LICENSE:LGPL$
|
|
** Commercial License Usage
|
|
** Licensees holding valid commercial Qt licenses may use this file in
|
|
** accordance with the commercial license agreement provided with the
|
|
** Software or, alternatively, in accordance with the terms contained in
|
|
** a written agreement between you and The Qt Company. For licensing terms
|
|
** and conditions see https://www.qt.io/terms-conditions. For further
|
|
** information use the contact form at https://www.qt.io/contact-us.
|
|
**
|
|
** GNU Lesser General Public License Usage
|
|
** Alternatively, this file may be used under the terms of the GNU Lesser
|
|
** General Public License version 3 as published by the Free Software
|
|
** Foundation and appearing in the file LICENSE.LGPL3 included in the
|
|
** packaging of this file. Please review the following information to
|
|
** ensure the GNU Lesser General Public License version 3 requirements
|
|
** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
|
|
**
|
|
** GNU General Public License Usage
|
|
** Alternatively, this file may be used under the terms of the GNU
|
|
** General Public License version 2.0 or (at your option) the GNU General
|
|
** Public license version 3 or any later version approved by the KDE Free
|
|
** Qt Foundation. The licenses are as published by the Free Software
|
|
** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
|
|
** included in the packaging of this file. Please review the following
|
|
** information to ensure the GNU General Public License requirements will
|
|
** be met: https://www.gnu.org/licenses/gpl-2.0.html and
|
|
** https://www.gnu.org/licenses/gpl-3.0.html.
|
|
**
|
|
** $QT_END_LICENSE$
|
|
**
|
|
****************************************************************************/
|
|
|
|
#include "qgesture.h"
|
|
#include "private/qgesture_p.h"
|
|
#include "private/qstandardgestures_p.h"
|
|
#if QT_CONFIG(graphicsview)
|
|
#include "qgraphicsview.h"
|
|
#endif
|
|
|
|
#include <private/qdebug_p.h>
|
|
#ifndef QT_NO_GESTURES
|
|
|
|
QT_BEGIN_NAMESPACE
|
|
|
|
/*!
|
|
\class QGesture
|
|
\since 4.6
|
|
\ingroup gestures
|
|
\inmodule QtWidgets
|
|
|
|
\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
|
|
QGestureRecognizer::registerRecognizer().
|
|
|
|
For an overview of gesture handling in Qt and information on using gestures
|
|
in your applications, see the \l{Gestures in Widgets and Graphics View} document.
|
|
|
|
\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 implicitly created when needed and is owned by Qt.
|
|
Developers should never destroy them or store them for later use as Qt may
|
|
destroy particular instances of them and create new ones to replace them.
|
|
|
|
The registered gesture recognizer monitors the input events for the target
|
|
object via its \l{QGestureRecognizer::}{recognize()} 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::create() 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::mapToGraphicsScene() to get a
|
|
local hot-spot.
|
|
|
|
The hot-spot should be set by the gesture recognizer to allow gesture event
|
|
delivery to a QGraphicsObject.
|
|
*/
|
|
|
|
/*!
|
|
\property QGesture::hasHotSpot
|
|
\brief whether the gesture has a hot-spot
|
|
*/
|
|
|
|
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;
|
|
}
|
|
|
|
/*!
|
|
\property QGesture::gestureCancelPolicy
|
|
\brief the policy for deciding what happens on accepting a gesture
|
|
|
|
On accepting one gesture Qt can automatically cancel other gestures
|
|
that belong to other targets. The policy is normally set to not cancel
|
|
any other gestures and can be set to cancel all active gestures in the
|
|
context. For example for all child widgets.
|
|
*/
|
|
|
|
/*!
|
|
\enum QGesture::GestureCancelPolicy
|
|
|
|
This enum describes how accepting a gesture can cancel other gestures
|
|
automatically.
|
|
|
|
\value CancelNone On accepting this gesture no other gestures will be affected.
|
|
|
|
\value CancelAllInContext On accepting this gesture all gestures that are
|
|
active in the context (respecting the Qt::GestureFlag that were specified
|
|
when subscribed to the gesture) will be cancelled.
|
|
*/
|
|
|
|
void QGesture::setGestureCancelPolicy(GestureCancelPolicy policy)
|
|
{
|
|
Q_D(QGesture);
|
|
d->gestureCancelPolicy = static_cast<uint>(policy);
|
|
}
|
|
|
|
QGesture::GestureCancelPolicy QGesture::gestureCancelPolicy() const
|
|
{
|
|
Q_D(const QGesture);
|
|
return static_cast<GestureCancelPolicy>(d->gestureCancelPolicy);
|
|
}
|
|
|
|
/*!
|
|
\class QPanGesture
|
|
\since 4.6
|
|
\brief The QPanGesture class describes a panning gesture made by the user.
|
|
\ingroup gestures
|
|
\inmodule QtWidgets
|
|
|
|
\image pangesture.png
|
|
|
|
For an overview of gesture handling in Qt and information on using gestures
|
|
in your applications, see the \l{Gestures in Widgets and Graphics View} document.
|
|
|
|
\sa QPinchGesture, QSwipeGesture
|
|
*/
|
|
|
|
/*!
|
|
\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 total offset from the first input position to the current input
|
|
position
|
|
|
|
The offset measures the total change in position of the user's input
|
|
covered by the gesture on the input device.
|
|
*/
|
|
|
|
/*!
|
|
\property QPanGesture::delta
|
|
\brief the offset from the previous input position to the current input
|
|
|
|
This is essentially the same as the difference between offset() and
|
|
lastOffset().
|
|
*/
|
|
|
|
/*!
|
|
\property QPanGesture::acceleration
|
|
\brief the acceleration in the motion of the touch point for this gesture
|
|
*/
|
|
|
|
/*!
|
|
\property QPanGesture::horizontalVelocity
|
|
\brief the horizontal component of the motion of the touch point for this
|
|
gesture
|
|
\since 4.7.1
|
|
\internal
|
|
|
|
\sa verticalVelocity, acceleration
|
|
*/
|
|
|
|
/*!
|
|
\property QPanGesture::verticalVelocity
|
|
\brief the vertical component of the motion of the touch point for this
|
|
gesture
|
|
\since 4.7.1
|
|
\internal
|
|
|
|
\sa horizontalVelocity, acceleration
|
|
*/
|
|
|
|
/*!
|
|
\internal
|
|
*/
|
|
QPanGesture::QPanGesture(QObject *parent)
|
|
: QGesture(*new QPanGesturePrivate, parent)
|
|
{
|
|
d_func()->gestureType = Qt::PanGesture;
|
|
}
|
|
|
|
/*!
|
|
Destructor.
|
|
*/
|
|
QPanGesture::~QPanGesture()
|
|
{
|
|
}
|
|
|
|
QPointF QPanGesture::lastOffset() const
|
|
{
|
|
return d_func()->lastOffset;
|
|
}
|
|
|
|
QPointF QPanGesture::offset() const
|
|
{
|
|
return d_func()->offset;
|
|
}
|
|
|
|
QPointF QPanGesture::delta() const
|
|
{
|
|
Q_D(const QPanGesture);
|
|
return d->offset - d->lastOffset;
|
|
}
|
|
|
|
qreal QPanGesture::acceleration() const
|
|
{
|
|
return d_func()->acceleration;
|
|
}
|
|
|
|
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 by the user.
|
|
\ingroup touch
|
|
\ingroup gestures
|
|
\inmodule QtWidgets
|
|
|
|
A pinch gesture is a form of touch 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.
|
|
|
|
For an overview of gesture handling in Qt and information on using gestures
|
|
in your applications, see the \l{Gestures in Widgets and Graphics View} document.
|
|
|
|
\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 QPanGesture, QSwipeGesture
|
|
*/
|
|
|
|
/*!
|
|
\enum QPinchGesture::ChangeFlag
|
|
|
|
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 changeFlags, totalChangeFlags
|
|
*/
|
|
|
|
/*!
|
|
\property QPinchGesture::totalChangeFlags
|
|
\brief the property of the gesture that has change
|
|
|
|
This property indicates which of the other properties has changed since the
|
|
gesture has started. You can use this information to determine which aspect
|
|
of your user interface needs to be updated.
|
|
|
|
\sa changeFlags, scaleFactor, rotationAngle, centerPoint
|
|
*/
|
|
|
|
/*!
|
|
\property QPinchGesture::changeFlags
|
|
\brief the property of the gesture that has changed in the current step
|
|
|
|
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 totalChangeFlags, 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 touch 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;
|
|
}
|
|
|
|
/*!
|
|
Destructor.
|
|
*/
|
|
QPinchGesture::~QPinchGesture()
|
|
{
|
|
}
|
|
|
|
QPinchGesture::ChangeFlags QPinchGesture::totalChangeFlags() const
|
|
{
|
|
return d_func()->totalChangeFlags;
|
|
}
|
|
|
|
void QPinchGesture::setTotalChangeFlags(QPinchGesture::ChangeFlags value)
|
|
{
|
|
d_func()->totalChangeFlags = value;
|
|
}
|
|
|
|
QPinchGesture::ChangeFlags QPinchGesture::changeFlags() const
|
|
{
|
|
return d_func()->changeFlags;
|
|
}
|
|
|
|
void QPinchGesture::setChangeFlags(QPinchGesture::ChangeFlags value)
|
|
{
|
|
d_func()->changeFlags = 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
|
|
\inmodule QtWidgets
|
|
|
|
\image swipegesture.png
|
|
|
|
For an overview of gesture handling in Qt and information on using gestures
|
|
in your applications, see the \l{Gestures in Widgets and Graphics View} document.
|
|
|
|
\sa QPanGesture, QPinchGesture
|
|
*/
|
|
|
|
/*!
|
|
\enum QSwipeGesture::SwipeDirection
|
|
|
|
This enum describes the possible directions for the gesture's motion
|
|
along the horizontal and vertical axes.
|
|
|
|
\value NoDirection The gesture had no motion associated with it on a particular axis.
|
|
\value Left The gesture involved a horizontal motion to the left.
|
|
\value Right The gesture involved a horizontal motion to the right.
|
|
\value Up The gesture involved an upward vertical motion.
|
|
\value Down The gesture involved a downward vertical motion.
|
|
*/
|
|
|
|
/*!
|
|
\property QSwipeGesture::horizontalDirection
|
|
\brief the horizontal direction of the gesture
|
|
|
|
If the gesture has a horizontal component, the horizontal direction
|
|
is either Left or Right; otherwise, it is NoDirection.
|
|
|
|
\sa verticalDirection, swipeAngle
|
|
*/
|
|
|
|
/*!
|
|
\property QSwipeGesture::verticalDirection
|
|
\brief the vertical direction of the gesture
|
|
|
|
If the gesture has a vertical component, the vertical direction
|
|
is either Up or Down; otherwise, it is NoDirection.
|
|
|
|
\sa horizontalDirection, swipeAngle
|
|
*/
|
|
|
|
/*!
|
|
\property QSwipeGesture::swipeAngle
|
|
\brief the angle of the motion associated with the gesture
|
|
|
|
If the gesture has either a horizontal or vertical component, the
|
|
swipe angle describes the angle between the direction of motion and the
|
|
x-axis as defined using the standard widget
|
|
\l{Coordinate System}{coordinate system}.
|
|
|
|
\sa horizontalDirection, verticalDirection
|
|
*/
|
|
|
|
/*!
|
|
\property QSwipeGesture::velocity
|
|
\since 4.7.1
|
|
\internal
|
|
*/
|
|
|
|
/*!
|
|
\internal
|
|
*/
|
|
QSwipeGesture::QSwipeGesture(QObject *parent)
|
|
: QGesture(*new QSwipeGesturePrivate, parent)
|
|
{
|
|
d_func()->gestureType = Qt::SwipeGesture;
|
|
}
|
|
|
|
/*!
|
|
Destructor.
|
|
*/
|
|
QSwipeGesture::~QSwipeGesture()
|
|
{
|
|
}
|
|
|
|
QSwipeGesture::SwipeDirection QSwipeGesture::horizontalDirection() const
|
|
{
|
|
Q_D(const QSwipeGesture);
|
|
if (d->swipeAngle < 0 || d->swipeAngle == 90 || d->swipeAngle == 270)
|
|
return QSwipeGesture::NoDirection;
|
|
else if (d->swipeAngle < 90 || d->swipeAngle > 270)
|
|
return QSwipeGesture::Right;
|
|
else
|
|
return QSwipeGesture::Left;
|
|
}
|
|
|
|
QSwipeGesture::SwipeDirection QSwipeGesture::verticalDirection() const
|
|
{
|
|
Q_D(const QSwipeGesture);
|
|
if (d->swipeAngle <= 0 || d->swipeAngle == 180)
|
|
return QSwipeGesture::NoDirection;
|
|
else if (d->swipeAngle < 180)
|
|
return QSwipeGesture::Up;
|
|
else
|
|
return QSwipeGesture::Down;
|
|
}
|
|
|
|
qreal QSwipeGesture::swipeAngle() const
|
|
{
|
|
return d_func()->swipeAngle;
|
|
}
|
|
|
|
void QSwipeGesture::setSwipeAngle(qreal value)
|
|
{
|
|
d_func()->swipeAngle = value;
|
|
}
|
|
|
|
/*!
|
|
\class QTapGesture
|
|
\since 4.6
|
|
\brief The QTapGesture class describes a tap gesture made by the user.
|
|
\ingroup gestures
|
|
\inmodule QtWidgets
|
|
|
|
For an overview of gesture handling in Qt and information on using gestures
|
|
in your applications, see the \l{Gestures in Widgets and Graphics View} document.
|
|
|
|
\sa QPanGesture, QPinchGesture
|
|
*/
|
|
|
|
/*!
|
|
\property QTapGesture::position
|
|
\brief the position of the tap
|
|
*/
|
|
|
|
/*!
|
|
\internal
|
|
*/
|
|
QTapGesture::QTapGesture(QObject *parent)
|
|
: QGesture(*new QTapGesturePrivate, parent)
|
|
{
|
|
d_func()->gestureType = Qt::TapGesture;
|
|
}
|
|
|
|
/*!
|
|
Destructor.
|
|
*/
|
|
QTapGesture::~QTapGesture()
|
|
{
|
|
}
|
|
|
|
QPointF QTapGesture::position() const
|
|
{
|
|
return d_func()->position;
|
|
}
|
|
|
|
void QTapGesture::setPosition(const QPointF &value)
|
|
{
|
|
d_func()->position = value;
|
|
}
|
|
/*!
|
|
\class QTapAndHoldGesture
|
|
\since 4.6
|
|
\brief The QTapAndHoldGesture class describes a tap-and-hold (aka LongTap)
|
|
gesture made by the user.
|
|
\ingroup gestures
|
|
\inmodule QtWidgets
|
|
|
|
For an overview of gesture handling in Qt and information on using gestures
|
|
in your applications, see the \l{Gestures in Widgets and Graphics View} document.
|
|
|
|
\sa QPanGesture, QPinchGesture
|
|
*/
|
|
|
|
/*!
|
|
\property QTapAndHoldGesture::position
|
|
\brief the position of the tap
|
|
*/
|
|
|
|
/*!
|
|
\internal
|
|
*/
|
|
QTapAndHoldGesture::QTapAndHoldGesture(QObject *parent)
|
|
: QGesture(*new QTapAndHoldGesturePrivate, parent)
|
|
{
|
|
d_func()->gestureType = Qt::TapAndHoldGesture;
|
|
}
|
|
|
|
/*!
|
|
Destructor.
|
|
*/
|
|
QTapAndHoldGesture::~QTapAndHoldGesture()
|
|
{
|
|
}
|
|
|
|
QPointF QTapAndHoldGesture::position() const
|
|
{
|
|
return d_func()->position;
|
|
}
|
|
|
|
void QTapAndHoldGesture::setPosition(const QPointF &value)
|
|
{
|
|
d_func()->position = value;
|
|
}
|
|
|
|
/*!
|
|
Set the timeout, in milliseconds, before the gesture triggers.
|
|
|
|
The recognizer will detect a touch down and if \a msecs
|
|
later the touch is still down, it will trigger the QTapAndHoldGesture.
|
|
The default value is 700 milliseconds.
|
|
*/
|
|
void QTapAndHoldGesture::setTimeout(int msecs)
|
|
{
|
|
QTapAndHoldGesturePrivate::Timeout = msecs;
|
|
}
|
|
|
|
/*!
|
|
Gets the timeout, in milliseconds, before the gesture triggers.
|
|
|
|
The recognizer will detect a touch down and if timeout()
|
|
later the touch is still down, it will trigger the QTapAndHoldGesture.
|
|
The default value is 700 milliseconds.
|
|
*/
|
|
int QTapAndHoldGesture::timeout()
|
|
{
|
|
return QTapAndHoldGesturePrivate::Timeout;
|
|
}
|
|
|
|
int QTapAndHoldGesturePrivate::Timeout = 700; // in ms
|
|
|
|
|
|
/*!
|
|
\class QGestureEvent
|
|
\since 4.6
|
|
\ingroup events
|
|
\ingroup gestures
|
|
\inmodule QtWidgets
|
|
|
|
\brief The QGestureEvent class provides the description of triggered gestures.
|
|
|
|
The QGestureEvent class contains a list of gestures, which can be obtained using the
|
|
gestures() function.
|
|
|
|
The gestures are either active or canceled. A list of those that are currently being
|
|
executed can be obtained using the activeGestures() function. A list of those which
|
|
were previously active and have been canceled can be accessed using the
|
|
canceledGestures() function. A gesture might be canceled if the current window loses
|
|
focus, for example, or because of a timeout, or for other reasons.
|
|
|
|
If the event handler does not accept the event by calling the generic
|
|
QEvent::accept() function, all individual QGesture object that were not
|
|
accepted and in the Qt::GestureStarted state will be propagated up the
|
|
parent widget chain until a widget accepts them individually, by calling
|
|
QGestureEvent::accept() for each of them, or an event filter consumes the
|
|
event.
|
|
|
|
\section1 Further Reading
|
|
|
|
For an overview of gesture handling in Qt and information on using gestures
|
|
in your applications, see the \l{Gestures in Widgets and Graphics View} document.
|
|
|
|
\sa QGesture, QGestureRecognizer,
|
|
QWidget::grabGesture(), QGraphicsObject::grabGesture()
|
|
*/
|
|
|
|
/*!
|
|
Creates new QGestureEvent containing a list of \a gestures.
|
|
*/
|
|
QGestureEvent::QGestureEvent(const QList<QGesture *> &gestures)
|
|
: QEvent(QEvent::Gesture), m_gestures(gestures), m_widget(0)
|
|
|
|
{
|
|
}
|
|
|
|
/*!
|
|
Destroys QGestureEvent.
|
|
*/
|
|
QGestureEvent::~QGestureEvent()
|
|
{
|
|
}
|
|
|
|
/*!
|
|
Returns all gestures that are delivered in the event.
|
|
*/
|
|
QList<QGesture *> QGestureEvent::gestures() const
|
|
{
|
|
return m_gestures;
|
|
}
|
|
|
|
/*!
|
|
Returns a gesture object by \a type.
|
|
*/
|
|
QGesture *QGestureEvent::gesture(Qt::GestureType type) const
|
|
{
|
|
for (int i = 0; i < m_gestures.size(); ++i)
|
|
if (m_gestures.at(i)->gestureType() == type)
|
|
return m_gestures.at(i);
|
|
return 0;
|
|
}
|
|
|
|
/*!
|
|
Returns a list of active (not canceled) gestures.
|
|
*/
|
|
QList<QGesture *> QGestureEvent::activeGestures() const
|
|
{
|
|
QList<QGesture *> gestures;
|
|
for (QGesture *gesture : m_gestures) {
|
|
if (gesture->state() != Qt::GestureCanceled)
|
|
gestures.append(gesture);
|
|
}
|
|
return gestures;
|
|
}
|
|
|
|
/*!
|
|
Returns a list of canceled gestures.
|
|
*/
|
|
QList<QGesture *> QGestureEvent::canceledGestures() const
|
|
{
|
|
QList<QGesture *> gestures;
|
|
for (QGesture *gesture : m_gestures) {
|
|
if (gesture->state() == Qt::GestureCanceled)
|
|
gestures.append(gesture);
|
|
}
|
|
return gestures;
|
|
}
|
|
|
|
/*!
|
|
Sets the accept flag of the given \a gesture object to the specified \a value.
|
|
|
|
Setting the accept flag indicates that the event receiver wants the \a gesture.
|
|
Unwanted gestures may be propagated to the parent widget.
|
|
|
|
By default, gestures in events of type QEvent::Gesture are accepted, and
|
|
gestures in QEvent::GestureOverride events are ignored.
|
|
|
|
For convenience, the accept flag can also be set with
|
|
\l{QGestureEvent::accept()}{accept(gesture)}, and cleared with
|
|
\l{QGestureEvent::ignore()}{ignore(gesture)}.
|
|
*/
|
|
void QGestureEvent::setAccepted(QGesture *gesture, bool value)
|
|
{
|
|
if (gesture)
|
|
setAccepted(gesture->gestureType(), value);
|
|
}
|
|
|
|
/*!
|
|
Sets the accept flag of the given \a gesture object, the equivalent of calling
|
|
\l{QGestureEvent::setAccepted()}{setAccepted(gesture, true)}.
|
|
|
|
Setting the accept flag indicates that the event receiver wants the
|
|
gesture. Unwanted gestures may be propagated to the parent widget.
|
|
|
|
\sa QGestureEvent::ignore()
|
|
*/
|
|
void QGestureEvent::accept(QGesture *gesture)
|
|
{
|
|
if (gesture)
|
|
setAccepted(gesture->gestureType(), true);
|
|
}
|
|
|
|
/*!
|
|
Clears the accept flag parameter of the given \a gesture object, the equivalent
|
|
of calling \l{QGestureEvent::setAccepted()}{setAccepted(gesture, false)}.
|
|
|
|
Clearing the accept flag indicates that the event receiver does not
|
|
want the gesture. Unwanted gestures may be propagated to the parent widget.
|
|
|
|
\sa QGestureEvent::accept()
|
|
*/
|
|
void QGestureEvent::ignore(QGesture *gesture)
|
|
{
|
|
if (gesture)
|
|
setAccepted(gesture->gestureType(), false);
|
|
}
|
|
|
|
/*!
|
|
Returns \c true if the \a gesture is accepted; otherwise returns \c false.
|
|
*/
|
|
bool QGestureEvent::isAccepted(QGesture *gesture) const
|
|
{
|
|
return gesture ? isAccepted(gesture->gestureType()) : false;
|
|
}
|
|
|
|
/*!
|
|
Sets the accept flag of the given \a gestureType object to the specified
|
|
\a value.
|
|
|
|
Setting the accept flag indicates that the event receiver wants to receive
|
|
gestures of the specified type, \a gestureType. Unwanted gestures may be
|
|
propagated to the parent widget.
|
|
|
|
By default, gestures in events of type QEvent::Gesture are accepted, and
|
|
gestures in QEvent::GestureOverride events are ignored.
|
|
|
|
For convenience, the accept flag can also be set with
|
|
\l{QGestureEvent::accept()}{accept(gestureType)}, and cleared with
|
|
\l{QGestureEvent::ignore()}{ignore(gestureType)}.
|
|
*/
|
|
void QGestureEvent::setAccepted(Qt::GestureType gestureType, bool value)
|
|
{
|
|
setAccepted(false);
|
|
m_accepted[gestureType] = value;
|
|
}
|
|
|
|
/*!
|
|
Sets the accept flag of the given \a gestureType, the equivalent of calling
|
|
\l{QGestureEvent::setAccepted()}{setAccepted(gestureType, true)}.
|
|
|
|
Setting the accept flag indicates that the event receiver wants the
|
|
gesture. Unwanted gestures may be propagated to the parent widget.
|
|
|
|
\sa QGestureEvent::ignore()
|
|
*/
|
|
void QGestureEvent::accept(Qt::GestureType gestureType)
|
|
{
|
|
setAccepted(gestureType, true);
|
|
}
|
|
|
|
/*!
|
|
Clears the accept flag parameter of the given \a gestureType, the equivalent
|
|
of calling \l{QGestureEvent::setAccepted()}{setAccepted(gesture, false)}.
|
|
|
|
Clearing the accept flag indicates that the event receiver does not
|
|
want the gesture. Unwanted gestures may be propgated to the parent widget.
|
|
|
|
\sa QGestureEvent::accept()
|
|
*/
|
|
void QGestureEvent::ignore(Qt::GestureType gestureType)
|
|
{
|
|
setAccepted(gestureType, false);
|
|
}
|
|
|
|
/*!
|
|
Returns \c true if the gesture of type \a gestureType is accepted; otherwise
|
|
returns \c false.
|
|
*/
|
|
bool QGestureEvent::isAccepted(Qt::GestureType gestureType) const
|
|
{
|
|
return m_accepted.value(gestureType, true);
|
|
}
|
|
|
|
/*!
|
|
\internal
|
|
|
|
Sets the widget for this event to the \a widget specified.
|
|
*/
|
|
void QGestureEvent::setWidget(QWidget *widget)
|
|
{
|
|
m_widget = widget;
|
|
}
|
|
|
|
/*!
|
|
Returns the widget on which the event occurred.
|
|
*/
|
|
QWidget *QGestureEvent::widget() const
|
|
{
|
|
return m_widget;
|
|
}
|
|
|
|
#if QT_CONFIG(graphicsview)
|
|
/*!
|
|
Returns the scene-local coordinates if the \a gesturePoint is inside a
|
|
graphics view.
|
|
|
|
This functional might be useful when the gesture event is delivered to a
|
|
QGraphicsObject to translate a point in screen coordinates to scene-local
|
|
coordinates.
|
|
|
|
\sa QPointF::isNull()
|
|
*/
|
|
QPointF QGestureEvent::mapToGraphicsScene(const QPointF &gesturePoint) const
|
|
{
|
|
QWidget *w = widget();
|
|
if (w) // we get the viewport as widget, not the graphics view
|
|
w = w->parentWidget();
|
|
QGraphicsView *view = qobject_cast<QGraphicsView*>(w);
|
|
if (view) {
|
|
return view->mapToScene(view->mapFromGlobal(gesturePoint.toPoint()));
|
|
}
|
|
return QPointF();
|
|
}
|
|
#endif // QT_CONFIG(graphicsview)
|
|
|
|
#ifndef QT_NO_DEBUG_STREAM
|
|
|
|
static void formatGestureHeader(QDebug d, const char *className, const QGesture *gesture)
|
|
{
|
|
d << className << "(state=";
|
|
QtDebugUtils::formatQEnum(d, gesture->state());
|
|
if (gesture->hasHotSpot()) {
|
|
d << ",hotSpot=";
|
|
QtDebugUtils::formatQPoint(d, gesture->hotSpot());
|
|
}
|
|
}
|
|
|
|
Q_WIDGETS_EXPORT QDebug operator<<(QDebug d, const QGesture *gesture)
|
|
{
|
|
QDebugStateSaver saver(d);
|
|
d.nospace();
|
|
switch (gesture->gestureType()) {
|
|
case Qt::TapGesture:
|
|
formatGestureHeader(d, "QTapGesture", gesture);
|
|
d << ",position=";
|
|
QtDebugUtils::formatQPoint(d, static_cast<const QTapGesture*>(gesture)->position());
|
|
d << ')';
|
|
break;
|
|
case Qt::TapAndHoldGesture: {
|
|
const QTapAndHoldGesture *tap = static_cast<const QTapAndHoldGesture*>(gesture);
|
|
formatGestureHeader(d, "QTapAndHoldGesture", tap);
|
|
d << ",position=";
|
|
QtDebugUtils::formatQPoint(d, tap->position());
|
|
d << ",timeout=" << tap->timeout() << ')';
|
|
}
|
|
break;
|
|
case Qt::PanGesture: {
|
|
const QPanGesture *pan = static_cast<const QPanGesture*>(gesture);
|
|
formatGestureHeader(d, "QPanGesture", pan);
|
|
d << ",lastOffset=";
|
|
QtDebugUtils::formatQPoint(d, pan->lastOffset());
|
|
d << pan->lastOffset();
|
|
d << ",offset=";
|
|
QtDebugUtils::formatQPoint(d, pan->offset());
|
|
d << ",acceleration=" << pan->acceleration() << ",delta=";
|
|
QtDebugUtils::formatQPoint(d, pan->delta());
|
|
d << ')';
|
|
}
|
|
break;
|
|
case Qt::PinchGesture: {
|
|
const QPinchGesture *pinch = static_cast<const QPinchGesture*>(gesture);
|
|
formatGestureHeader(d, "QPinchGesture", pinch);
|
|
d << ",totalChangeFlags=" << pinch->totalChangeFlags()
|
|
<< ",changeFlags=" << pinch->changeFlags() << ",startCenterPoint=";
|
|
QtDebugUtils::formatQPoint(d, pinch->startCenterPoint());
|
|
d << ",lastCenterPoint=";
|
|
QtDebugUtils::formatQPoint(d, pinch->lastCenterPoint());
|
|
d << ",centerPoint=";
|
|
QtDebugUtils::formatQPoint(d, pinch->centerPoint());
|
|
d << ",totalScaleFactor=" << pinch->totalScaleFactor()
|
|
<< ",lastScaleFactor=" << pinch->lastScaleFactor()
|
|
<< ",scaleFactor=" << pinch->scaleFactor()
|
|
<< ",totalRotationAngle=" << pinch->totalRotationAngle()
|
|
<< ",lastRotationAngle=" << pinch->lastRotationAngle()
|
|
<< ",rotationAngle=" << pinch->rotationAngle() << ')';
|
|
}
|
|
break;
|
|
case Qt::SwipeGesture: {
|
|
const QSwipeGesture *swipe = static_cast<const QSwipeGesture*>(gesture);
|
|
formatGestureHeader(d, "QSwipeGesture", swipe);
|
|
d << ",horizontalDirection=";
|
|
QtDebugUtils::formatQEnum(d, swipe->horizontalDirection());
|
|
d << ",verticalDirection=";
|
|
QtDebugUtils::formatQEnum(d, swipe->verticalDirection());
|
|
d << ",swipeAngle=" << swipe->swipeAngle() << ')';
|
|
}
|
|
break;
|
|
default:
|
|
formatGestureHeader(d, "Custom gesture", gesture);
|
|
d << ",type=" << gesture->gestureType() << ')';
|
|
break;
|
|
}
|
|
return d;
|
|
}
|
|
|
|
Q_WIDGETS_EXPORT QDebug operator<<(QDebug d, const QGestureEvent *gestureEvent)
|
|
{
|
|
QDebugStateSaver saver(d);
|
|
d.nospace();
|
|
d << "QGestureEvent(" << gestureEvent->gestures() << ')';
|
|
return d;
|
|
}
|
|
|
|
#endif // !QT_NO_DEBUG_STREAM
|
|
QT_END_NAMESPACE
|
|
|
|
#include <moc_qgesture.cpp>
|
|
|
|
#endif // QT_NO_GESTURES
|