FCL/sf/mw/qt: comparison src/gui/kernel/qgesture.cpp

equal deleted inserted replaced

-:56cd8111b7f7
+:41300fa6a67c
 \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().
+QGestureRecognizer::registerRecognizer().
 \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
 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()
+A QGesture instance is implicitly created when needed and is owned by Qt.
-or QGraphicsObject::grabGesture() to configure a widget or graphics object (the
+Developers should never destroy them or store them for later use as Qt may
-target object) for gesture input. One gesture object is created for each target
+destroy particular instances of them and create new ones to replace them.
-object.
 The registered gesture recognizer monitors the input events for the target
-object via its \l{QGestureRecognizer::}{filterEvent()} function, updating the
+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
 /*!
 Constructs a new gesture object with the given \a parent.
 QGesture objects are created by gesture recognizers in the
-QGestureRecognizer::createGesture() function.
+QGestureRecognizer::create() function.
 */
 QGesture::QGesture(QObject *parent)
 : QObject(*new QGesturePrivate, parent)
 {
 d_func()->gestureType = Qt::CustomGesture;
 \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
+QWidget::mapFromGlobal() or QGestureEvent::mapToGraphicsScene() to get a
 local hot-spot.
-If the hot-spot is not set, the targetObject is used as the receiver of the
+The hot-spot should be set by the gesture recognizer to allow gesture event
-gesture event.
+delivery to a QGraphicsObject.
 */
 /*!
 \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;
 }
 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
 \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
 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
-position
+This is essentially the same as the difference between offset() and
-The offset measures the change in position of the user's input on the
+lastOffset().
-input device.
 */
 /*!
 \property QPanGesture::acceleration
 */
 : 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;
 }
+QPointF QPanGesture::delta() const
+{
+Q_D(const QPanGesture);
+return d->offset - d->lastOffset;
+}
 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;
 \sa {Gestures Programming}, QPanGesture, QSwipeGesture
 */
 /*!
-\enum QPinchGesture::WhatChange
+\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 whatChanged
+\sa changeFlags, totalChangeFlags
 */
 /*!
-\property QPinchGesture::whatChanged
+\property QPinchGesture::totalChangeFlags
-\brief the property of the gesture that has changed
+\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 scaleFactor, rotationAngle, centerPoint
+\sa totalChangeFlags, scaleFactor, rotationAngle, centerPoint
 */
 /*!
 \property QPinchGesture::totalScaleFactor
 \brief the total scale factor
 : QGesture(*new QPinchGesturePrivate, parent)
 {
 d_func()->gestureType = Qt::PinchGesture;
 }
-QPinchGesture::WhatChanged QPinchGesture::whatChanged() const
+QPinchGesture::ChangeFlags QPinchGesture::totalChangeFlags() const
 {
-return d_func()->whatChanged;
+return d_func()->totalChangeFlags;
 }
-void QPinchGesture::setWhatChanged(QPinchGesture::WhatChanged value)
+void QPinchGesture::setTotalChangeFlags(QPinchGesture::ChangeFlags value)
 {
-d_func()->whatChanged = 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;
 }
 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
+\sa {Gestures Programming}, 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;
+}
+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
+\sa {Gestures Programming}, 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;
+}
+QPointF QTapAndHoldGesture::position() const
+{
+return d_func()->position;
+}
+void QTapAndHoldGesture::setPosition(const QPointF &value)
+{
+d_func()->position = value;
+}
 QT_END_NAMESPACE

changeset 3	41300fa6a67c
parent 0	1918ee327afb
child 4	3b1da2848fc7