Revision control
Copy as Markdown
// Copyright (C) 2018 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
// Qt-Security score:significant reason:default
#include "qquickpointerhandler_p.h"
#include "qquickpointerhandler_p_p.h"
#include <QtQuick/private/qquickitem_p.h>
#include <QtQuick/private/qquickhandlerpoint_p.h>
#include <QtQuick/private/qquickdeliveryagent_p_p.h>
#include <QtGui/private/qinputdevice_p.h>
#include <QtCore/qpointer.h>
QT_BEGIN_NAMESPACE
Q_LOGGING_CATEGORY(lcPointerHandlerDispatch, "qt.quick.handler.dispatch")
Q_STATIC_LOGGING_CATEGORY(lcPointerHandlerGrab, "qt.quick.handler.grab")
Q_STATIC_LOGGING_CATEGORY(lcPointerHandlerActive, "qt.quick.handler.active")
/*!
\qmltype PointerHandler
\qmlabstract
\since 5.10
\nativetype QQuickPointerHandler
\inqmlmodule QtQuick
\brief Abstract handler for pointer events.
PointerHandler is the base class Input Handler (not registered as a QML type) for
events from any kind of pointing device (touch, mouse or graphics tablet).
*/
/*!
\class QQuickPointerHandler
\inmodule QtQuick
\internal
So far we only offer public QML API for Pointer Handlers, but we expect
in some future version of Qt to have public C++ API as well. This will open
up the possibility to instantiate handlers in custom items (which we should
begin doing in Qt Quick Controls in the near future), and to subclass to make
custom handlers (as TableView is already doing).
To make a custom Pointer Handler, first try to choose the parent class
according to your needs. If the gesture that you want to recognize could
involve multiple touchpoints (even if it could start with only one point),
subclass QQuickMultiPointHandler. If you are sure that you never want to
handle more than one QEventPoint, subclass QQuickSinglePointHandler.
*/
QQuickPointerHandler::QQuickPointerHandler(QQuickItem *parent)
: QQuickPointerHandler(*(new QQuickPointerHandlerPrivate), parent)
{
}
QQuickPointerHandler::QQuickPointerHandler(QQuickPointerHandlerPrivate &dd, QQuickItem *parent)
: QObject(dd, parent)
{
// When a handler is created in QML, the given parent is null, and we
// depend on QQuickItemPrivate::data_append() later when it's added to an
// item's DefaultProperty data property. But when a handler is created in
// C++ with a parent item, data_append() won't be called, and the caller
// shouldn't have to worry about it either.
if (parent)
QQuickItemPrivate::get(parent)->addPointerHandler(this);
}
QQuickPointerHandler::~QQuickPointerHandler()
{
QQuickItem *parItem = parentItem();
if (parItem) {
QQuickItemPrivate *p = QQuickItemPrivate::get(parItem);
p->extra.value().pointerHandlers.removeOne(this);
}
}
/*!
\qmlproperty real PointerHandler::margin
The margin beyond the bounds of the \l {PointerHandler::parent}{parent}
item within which an \l eventPoint can activate this handler. For example, on
a PinchHandler where the \l {PointerHandler::target}{target} is also the
\c parent, it's useful to set this to a distance at least half the width
of a typical user's finger, so that if the \c parent has been scaled down
to a very small size, the pinch gesture is still possible. Or, if a
TapHandler-based button is placed near the screen edge, it can be used
to comply with Fitts's Law: react to mouse clicks at the screen edge
even though the button is visually spaced away from the edge by a few pixels.
The default value is 0.
\image pointerHandlerMargin.png
{Rectangle with surrounding margin area for extended touch detection}
*/
qreal QQuickPointerHandler::margin() const
{
Q_D(const QQuickPointerHandler);
return d->m_margin;
}
void QQuickPointerHandler::setMargin(qreal pointDistanceThreshold)
{
Q_D(QQuickPointerHandler);
if (d->m_margin == pointDistanceThreshold)
return;
d->m_margin = pointDistanceThreshold;
if (auto *parent = parentItem()) {
QQuickItemPrivate *itemPriv = QQuickItemPrivate::get(parent);
// invalidate the cache: the new max margin may depend on this and other handlers
itemPriv->extra.value().biggestPointerHandlerMarginCache = -1;
}
emit marginChanged();
}
/*!
\qmlproperty int PointerHandler::dragThreshold
\since 5.15
The distance in pixels that the user must drag an \l eventPoint in order to
have it treated as a drag gesture.
The default value depends on the platform and screen resolution.
It can be reset back to the default value by setting it to undefined.
The behavior when a drag gesture begins varies in different handlers.
*/
int QQuickPointerHandler::dragThreshold() const
{
Q_D(const QQuickPointerHandler);
if (d->dragThreshold < 0)
return qApp->styleHints()->startDragDistance();
return d->dragThreshold;
}
void QQuickPointerHandler::setDragThreshold(int t)
{
Q_D(QQuickPointerHandler);
if (d->dragThreshold == t)
return;
if (t > std::numeric_limits<qint16>::max())
qWarning() << "drag threshold cannot exceed" << std::numeric_limits<qint16>::max();
d->dragThreshold = qint16(t);
emit dragThresholdChanged();
}
void QQuickPointerHandler::resetDragThreshold()
{
Q_D(QQuickPointerHandler);
if (d->dragThreshold < 0)
return;
d->dragThreshold = -1;
emit dragThresholdChanged();
}
/*!
\since 5.15
\qmlproperty Qt::CursorShape PointerHandler::cursorShape
This property holds the cursor shape that will appear whenever the mouse is
hovering over the \l parent item while \l active is \c true.
The available cursor shapes are:
\list
\li Qt.ArrowCursor
\li Qt.UpArrowCursor
\li Qt.CrossCursor
\li Qt.WaitCursor
\li Qt.IBeamCursor
\li Qt.SizeVerCursor
\li Qt.SizeHorCursor
\li Qt.SizeBDiagCursor
\li Qt.SizeFDiagCursor
\li Qt.SizeAllCursor
\li Qt.BlankCursor
\li Qt.SplitVCursor
\li Qt.SplitHCursor
\li Qt.PointingHandCursor
\li Qt.ForbiddenCursor
\li Qt.WhatsThisCursor
\li Qt.BusyCursor
\li Qt.OpenHandCursor
\li Qt.ClosedHandCursor
\li Qt.DragCopyCursor
\li Qt.DragMoveCursor
\li Qt.DragLinkCursor
\endlist
The default value is not set, which allows the \l {QQuickItem::cursor()}{cursor}
of \l parent item to appear. This property can be reset to the same initial
condition by setting it to undefined.
\note When this property has not been set, or has been set to \c undefined,
if you read the value it will return \c Qt.ArrowCursor.
\sa Qt::CursorShape, QQuickItem::cursor(), HoverHandler::cursorShape
*/
#if QT_CONFIG(cursor)
Qt::CursorShape QQuickPointerHandler::cursorShape() const
{
Q_D(const QQuickPointerHandler);
return d->cursorShape;
}
void QQuickPointerHandler::setCursorShape(Qt::CursorShape shape)
{
Q_D(QQuickPointerHandler);
if (d->cursorSet && shape == d->cursorShape)
return;
d->cursorShape = shape;
d->cursorSet = true;
d->cursorDirty = true;
if (auto *parent = parentItem()) {
QQuickItemPrivate *itemPriv = QQuickItemPrivate::get(parent);
itemPriv->hasCursorHandler = true;
itemPriv->setHasCursorInChild(true);
}
emit cursorShapeChanged();
}
void QQuickPointerHandler::resetCursorShape()
{
Q_D(QQuickPointerHandler);
if (!d->cursorSet)
return;
d->cursorShape = Qt::ArrowCursor;
d->cursorSet = false;
if (auto *parent = parentItem()) {
QQuickItemPrivate *itemPriv = QQuickItemPrivate::get(parent);
// Only clear hasCursorHandler if no other handler on this item still has cursorShape set.
// Multiple handlers with cursorShape are valid (e.g. two HoverHandlers for different devices).
bool otherHandlerHasCursor = false;
if (itemPriv->hasPointerHandlers()) {
for (QQuickPointerHandler *h : itemPriv->extra->pointerHandlers) {
if (h != this && h->isCursorShapeExplicitlySet()) {
otherHandlerHasCursor = true;
break;
}
}
}
if (!otherHandlerHasCursor) {
itemPriv->hasCursorHandler = false;
itemPriv->setHasCursorInChild(itemPriv->hasCursor);
}
}
emit cursorShapeChanged();
}
bool QQuickPointerHandler::isCursorShapeExplicitlySet() const
{
Q_D(const QQuickPointerHandler);
return d->cursorSet;
}
#endif
/*!
Notification that the grab has changed in some way which is relevant to this handler.
The \a grabber (subject) will be the Input Handler whose state is changing,
or null if the state change regards an Item.
The \a transition (verb) tells what happened.
The \a point (object) is the \l eventPoint that was grabbed or ungrabbed.
QQuickDeliveryAgent calls this function.
The Input Handler must react in whatever way is appropriate, and must
emit the relevant signals (for the benefit of QML code).
A subclass is allowed to override this virtual function, but must always
call its parent class's implementation in addition to (usually after)
whatever custom behavior it implements.
*/
void QQuickPointerHandler::onGrabChanged(QQuickPointerHandler *grabber, QPointingDevice::GrabTransition transition,
QPointerEvent *event, QEventPoint &point)
{
Q_UNUSED(event);
qCDebug(lcPointerHandlerGrab) << point << transition << grabber;
if (grabber == this) {
bool wasCanceled = false;
switch (transition) {
case QPointingDevice::GrabPassive:
case QPointingDevice::GrabExclusive:
break;
case QPointingDevice::CancelGrabPassive:
case QPointingDevice::CancelGrabExclusive:
wasCanceled = true; // the grab was stolen by something else
Q_FALLTHROUGH();
case QPointingDevice::UngrabPassive:
case QPointingDevice::UngrabExclusive:
setActive(false);
point.setAccepted(false);
if (auto par = parentItem()) {
Q_D(const QQuickPointerHandler);
par->setKeepMouseGrab(d->hadKeepMouseGrab);
par->setKeepTouchGrab(d->hadKeepTouchGrab);
}
break;
case QPointingDevice::OverrideGrabPassive:
// Passive grab is still there, but we won't receive point updates right now.
// No need to notify about this.
return;
}
if (wasCanceled)
emit canceled(point);
emit grabChanged(transition, point);
}
}
/*!
Acquire or give up a passive grab of the given \a point, according to the \a grab state.
Unlike the exclusive grab, multiple Input Handlers can have passive grabs
simultaneously. This means that each of them will receive further events
when the \a point moves, and when it is finally released. Typically an
Input Handler should acquire a passive grab as soon as a point is pressed,
if the handler's constraints do not clearly rule out any interest in that
point. For example, DragHandler needs a passive grab in order to watch the
movement of a point to see whether it will be dragged past the drag
threshold. When a handler is actively manipulating its \l target (that is,
when \l active is true), it may be able to do its work with only a passive
grab, or it may acquire an exclusive grab if the gesture clearly must not
be interpreted in another way by another handler.
*/
void QQuickPointerHandler::setPassiveGrab(QPointerEvent *event, const QEventPoint &point, bool grab)
{
qCDebug(lcPointerHandlerGrab) << this << point << grab << "via"
<< QQuickDeliveryAgentPrivate::currentOrItemDeliveryAgent(parentItem());
if (grab) {
event->addPassiveGrabber(point, this);
} else {
event->removePassiveGrabber(point, this);
}
}
/*!
Check whether it's OK to take an exclusive grab of the \a point.
The default implementation will call approveGrabTransition() to check this
handler's \l grabPermissions. If grabbing can be done only by taking over
the exclusive grab from an Item, approveGrabTransition() checks the Item's
\l keepMouseGrab or \l keepTouchGrab flags appropriately. If grabbing can
be done only by taking over another handler's exclusive grab, canGrab()
also calls approveGrabTransition() on the handler which is about to lose
its grab. Either one can deny the takeover.
*/
bool QQuickPointerHandler::canGrab(QPointerEvent *event, const QEventPoint &point)
{
QQuickPointerHandler *existingPhGrabber = qobject_cast<QQuickPointerHandler *>(event->exclusiveGrabber(point));
return approveGrabTransition(event, point, this) &&
(existingPhGrabber ? existingPhGrabber->approveGrabTransition(event, point, this) : true);
}
/*!
Check this handler's rules to see if \l proposedGrabber will be allowed to take
the exclusive grab. This function may be called twice: once on the instance which
will take the grab, and once on the instance which would thereby lose its grab,
in case of a takeover scenario.
*/
bool QQuickPointerHandler::approveGrabTransition(QPointerEvent *event, const QEventPoint &point, QObject *proposedGrabber)
{
Q_D(const QQuickPointerHandler);
bool allowed = false;
QObject* existingGrabber = event->exclusiveGrabber(point);
if (proposedGrabber == this) {
allowed = (existingGrabber == nullptr) || ((d->grabPermissions & CanTakeOverFromAnything) == CanTakeOverFromAnything);
if (existingGrabber) {
if (QQuickPointerHandler *existingPhGrabber = qobject_cast<QQuickPointerHandler *>(event->exclusiveGrabber(point))) {
if (!allowed && (d->grabPermissions & CanTakeOverFromHandlersOfDifferentType) &&
existingPhGrabber->metaObject()->className() != metaObject()->className())
allowed = true;
if (!allowed && (d->grabPermissions & CanTakeOverFromHandlersOfSameType) &&
existingPhGrabber->metaObject()->className() == metaObject()->className())
allowed = true;
} else if ((d->grabPermissions & CanTakeOverFromItems)) {
allowed = true;
QQuickItem * existingItemGrabber = qobject_cast<QQuickItem *>(event->exclusiveGrabber(point));
auto da = parentItem() ? QQuickItemPrivate::get(parentItem())->deliveryAgentPrivate()
: QQuickDeliveryAgentPrivate::currentEventDeliveryAgent ? static_cast<QQuickDeliveryAgentPrivate *>(
QQuickDeliveryAgentPrivate::get(QQuickDeliveryAgentPrivate::currentEventDeliveryAgent)) : nullptr;
const bool isTouchMouse = (da && da->isDeliveringTouchAsMouse());
if (existingItemGrabber &&
((existingItemGrabber->keepMouseGrab() &&
(QQuickDeliveryAgentPrivate::isMouseEvent(event) || isTouchMouse)) ||
(existingItemGrabber->keepTouchGrab() && QQuickDeliveryAgentPrivate::isTouchEvent(event)))) {
allowed = false;
// If the handler wants to steal the exclusive grab from an Item, the Item can usually veto
// by having its keepMouseGrab or keepTouchGrab flag set. But if the handler wants to
// steal from an ancestor Item (e.g. a Flickable), allow it: it needs to be able to function
// despite the ancestor's keep-grab flags. Flickable is aggressive about grabbing on press
// (for fear of missing updates), but handlers inside it use passive grabs first and expect
// to steal later. Note: we check isAncestorOf rather than filtersChildMouseEvents() because
// the ancestor may temporarily disable filtering (e.g. TableView disables it during resize drag setup)
// while still holding an exclusive grab that would otherwise block the handler.
if (existingItemGrabber->isAncestorOf(parentItem())) {
Q_ASSERT(da);
if ((existingItemGrabber->keepMouseGrab() &&
(QQuickDeliveryAgentPrivate::isMouseEvent(event) || (isTouchMouse && point.id() == da->touchMouseId))) ||
(existingItemGrabber->keepTouchGrab() && QQuickDeliveryAgentPrivate::isTouchEvent(event))) {
qCDebug(lcPointerHandlerGrab) << this << "steals from ancestor"
<< existingItemGrabber << "despite keep-grab flags"
<< existingItemGrabber->keepMouseGrab() << existingItemGrabber->keepTouchGrab();
allowed = true;
}
}
if (!allowed) {
qCDebug(lcPointerHandlerGrab) << this << "wants to grab point" << point.id()
<< "but declines to steal from grabber" << existingItemGrabber
<< "with keepMouseGrab=" << existingItemGrabber->keepMouseGrab()
<< "keepTouchGrab=" << existingItemGrabber->keepTouchGrab();
}
}
}
}
} else {
// proposedGrabber is different: that means this instance will lose its grab
if (proposedGrabber) {
if ((d->grabPermissions & ApprovesTakeOverByAnything) == ApprovesTakeOverByAnything)
allowed = true;
if (!allowed && (d->grabPermissions & ApprovesTakeOverByHandlersOfDifferentType) &&
proposedGrabber->metaObject()->className() != metaObject()->className())
allowed = true;
if (!allowed && (d->grabPermissions & ApprovesTakeOverByHandlersOfSameType) &&
proposedGrabber->metaObject()->className() == metaObject()->className())
allowed = true;
if (!allowed && (d->grabPermissions & ApprovesTakeOverByItems) && proposedGrabber->inherits("QQuickItem"))
allowed = true;
} else {
if (d->grabPermissions & ApprovesCancellation)
allowed = true;
}
}
qCDebug(lcPointerHandlerGrab) << "point" << Qt::hex << point.id() << "permission" <<
QMetaEnum::fromType<GrabPermissions>().valueToKeys(grabPermissions()) <<
':' << this << (allowed ? "approved from" : "denied from") <<
existingGrabber << "to" << proposedGrabber;
return allowed;
}
/*!
\qmlproperty flags QtQuick::PointerHandler::grabPermissions
This property specifies the permissions when this handler's logic decides
to take over the exclusive grab, or when it is asked to approve grab
takeover or cancellation by another handler.
\value PointerHandler.TakeOverForbidden
This handler neither takes from nor gives grab permission to any type of Item or Handler.
\value PointerHandler.CanTakeOverFromHandlersOfSameType
This handler can take the exclusive grab from another handler of the same class.
\value PointerHandler.CanTakeOverFromHandlersOfDifferentType
This handler can take the exclusive grab from any kind of handler.
\value PointerHandler.CanTakeOverFromItems
This handler can take the exclusive grab from any type of Item.
\value PointerHandler.CanTakeOverFromAnything
This handler can take the exclusive grab from any type of Item or Handler.
\value PointerHandler.ApprovesTakeOverByHandlersOfSameType
This handler gives permission for another handler of the same class to take the grab.
\value PointerHandler.ApprovesTakeOverByHandlersOfDifferentType
This handler gives permission for any kind of handler to take the grab.
\value PointerHandler.ApprovesTakeOverByItems
This handler gives permission for any kind of Item to take the grab.
\value PointerHandler.ApprovesCancellation
This handler will allow its grab to be set to null.
\value PointerHandler.ApprovesTakeOverByAnything
This handler gives permission for any type of Item or Handler to take the grab.
The default is
\c {PointerHandler.CanTakeOverFromItems | PointerHandler.CanTakeOverFromHandlersOfDifferentType | PointerHandler.ApprovesTakeOverByAnything}
which allows most takeover scenarios but avoids e.g. two PinchHandlers fighting
over the same touchpoints.
*/
QQuickPointerHandler::GrabPermissions QQuickPointerHandler::grabPermissions() const
{
Q_D(const QQuickPointerHandler);
return static_cast<QQuickPointerHandler::GrabPermissions>(d->grabPermissions);
}
void QQuickPointerHandler::setGrabPermissions(GrabPermissions grabPermission)
{
Q_D(QQuickPointerHandler);
if (d->grabPermissions == grabPermission)
return;
d->grabPermissions = grabPermission;
emit grabPermissionChanged();
}
/*!
Overridden only because QQmlParserStatus requires it.
*/
void QQuickPointerHandler::classBegin()
{
}
/*!
Overridden from QQmlParserStatus to ensure that parentItem() sets its
cursor if this handler's \l cursorShape property has been set, and that
this handler is added to the parent item. If it was declared as a named property
rather than declared directly inside an Item, data_append() will miss adding it.
*/
void QQuickPointerHandler::componentComplete()
{
Q_D(const QQuickPointerHandler);
if (auto *parent = parentItem()) {
QQuickItemPrivate *itemPriv = QQuickItemPrivate::get(parent);
itemPriv->addPointerHandler(this);
if (d->cursorSet) {
itemPriv->hasCursorHandler = true;
itemPriv->setHasCursorInChild(true);
}
}
}
/*! \internal
\deprecated You should handle the event during delivery by overriding
handlePointerEventImpl() or QQuickSinglePointHandler::handleEventPoint().
Therefore currentEvent() should not be needed. It is here only because
onActiveChanged() does not take the event as an argument.
*/
QPointerEvent *QQuickPointerHandler::currentEvent()
{
Q_D(const QQuickPointerHandler);
return d->currentEvent;
}
/*!
Acquire or give up the exclusive grab of the given \a point, according to
the \a grab state, and subject to the rules: canGrab(), and the rule not to
relinquish another handler's grab. Returns true if permission is granted,
or if the exclusive grab has already been acquired or relinquished as
specified. Returns false if permission is denied either by this handler or
by the handler or item from which this handler would take over
*/
bool QQuickPointerHandler::setExclusiveGrab(QPointerEvent *ev, const QEventPoint &point, bool grab)
{
// If the handler loses its grab because its window is deactivated, there's no QPointerEvent.
if (!ev)
return true;
if ((grab && ev->exclusiveGrabber(point) == this) || (!grab && ev->exclusiveGrabber(point) != this))
return true;
// TODO m_hadKeepMouseGrab m_hadKeepTouchGrab
bool allowed = true;
if (grab) {
allowed = canGrab(ev, point);
} else {
QQuickPointerHandler *existingPhGrabber = qobject_cast<QQuickPointerHandler *>(ev->exclusiveGrabber(point));
// Ask before allowing one handler to cancel another's grab
if (existingPhGrabber && existingPhGrabber != this && !existingPhGrabber->approveGrabTransition(ev, point, nullptr))
allowed = false;
}
qCDebug(lcPointerHandlerGrab) << point << (grab ? "grab" : "ungrab") << (allowed ? "allowed" : "forbidden") <<
ev->exclusiveGrabber(point) << "->" << (grab ? this : nullptr);
if (allowed)
ev->setExclusiveGrabber(point, grab ? this : nullptr);
return allowed;
}
/*!
Cancel any existing grab of the given \a point.
*/
void QQuickPointerHandler::cancelAllGrabs(QPointerEvent *event, QEventPoint &point)
{
qCDebug(lcPointerHandlerGrab) << point;
if (event->exclusiveGrabber(point) == this) {
event->setExclusiveGrabber(point, nullptr);
onGrabChanged(this, QPointingDevice::CancelGrabExclusive, event, point);
}
if (event->removePassiveGrabber(point, this))
onGrabChanged(this, QPointingDevice::CancelGrabPassive, event, point);
}
QPointF QQuickPointerHandler::eventPos(const QEventPoint &point) const
{
return (target() ? target()->mapFromScene(point.scenePosition()) : point.scenePosition());
}
/*!
Returns \c true if margin() > 0 and \a point is within the margin beyond
QQuickItem::boundingRect(), or else returns QQuickItem::contains()
QEventPoint::position() effectively (because parentContains(scenePosition)
calls QQuickItem::mapFromScene()).
*/
bool QQuickPointerHandler::parentContains(const QEventPoint &point) const
{
return parentContains(point.position(), point.scenePosition());
}
/*!
Returns \c true if \a scenePosition is within the margin() beyond
QQuickItem::boundingRect() (if margin > 0), or parentItem() contains
\a scenePosition according to QQuickItem::contains(). (So if the \l margin
property is set, that overrides the bounds-check, and QQuickItem::contains()
is not called.) As a precheck, it's also required that the window contains
\a scenePosition mapped to global coordinates, if parentItem() is in a window.
*/
bool QQuickPointerHandler::parentContains(const QPointF &localPosition, const QPointF &scenePosition) const
{
if (QQuickItem *par = parentItem()) {
if (par->window()) {
QRectF windowGeometry = par->window()->geometry();
if (!par->window()->isTopLevel())
windowGeometry = QRectF(QWindowPrivate::get(par->window())->globalPosition(), par->window()->size());
QPointF screenPosition = par->window()->mapToGlobal(scenePosition);
if (!windowGeometry.contains(screenPosition))
return false;
}
qreal m = margin();
if (m > 0)
return localPosition.x() >= -m && localPosition.y() >= -m &&
localPosition.x() <= par->width() + m && localPosition.y() <= par->height() + m;
return par->contains(localPosition);
} else if (parent() && parent()->inherits("QQuick3DModel")) {
// If the parent is from Qt Quick 3D, assume that
// bounds checking was already done, as part of picking.
return true;
}
return false;
}
/*!
\qmlproperty bool QtQuick::PointerHandler::enabled
If a PointerHandler is disabled, it will reject all events
and no signals will be emitted.
If a PointerHandler's \l parent is \l {Item::enabled}{disabled},
the handler will also be effectively disabled, even when the \c enabled
property remains \c true.
\note HoverHandler behaves differently: see the documentation of its
\l {HoverHandler::}{enabled} property for more information.
*/
bool QQuickPointerHandler::enabled() const
{
Q_D(const QQuickPointerHandler);
return d->enabled;
}
void QQuickPointerHandler::setEnabled(bool enabled)
{
Q_D(QQuickPointerHandler);
if (d->enabled == enabled)
return;
d->enabled = enabled;
d->onEnabledChanged();
emit enabledChanged();
}
/*!
\qmlproperty Item QtQuick::PointerHandler::target
The Item which this handler will manipulate.
By default, it is the same as the \l [QML] {parent}, the Item within which
the handler is declared. However, it can sometimes be useful to set the
target to a different Item, in order to handle events within one item
but manipulate another; or to \c null, to disable the default behavior
and do something else instead.
*/
QQuickItem *QQuickPointerHandler::target() const
{
Q_D(const QQuickPointerHandler);
if (!d->targetExplicitlySet)
return parentItem();
return d->target;
}
void QQuickPointerHandler::setTarget(QQuickItem *target)
{
Q_D(QQuickPointerHandler);
d->targetExplicitlySet = true;
if (d->target == target)
return;
QQuickItem *oldTarget = d->target;
d->target = target;
onTargetChanged(oldTarget);
emit targetChanged();
}
/*!
\qmlproperty Item QtQuick::PointerHandler::parent
The \l Item which is the scope of the handler; the Item in which it was
declared. The handler will handle events on behalf of this Item, which
means a pointer event is relevant if at least one of its
\l {eventPoint}{eventPoints} occurs within the Item's interior. Initially
\l [QML] {target} {target()} is the same, but it can be reassigned.
\sa {target}, QObject::parent()
*/
/*! \internal
We still haven't shipped official support for declaring handlers in
QtQuick3D.Model objects. Many prerequisites are in place for that, so we
should try to keep it working; but there are issues with getting
DragHandler to drag its target intuitively in 3D space, for example.
TapHandler would work well enough.
\note When a handler is declared in a \l [QtQuick3D] {Model}{QtQuick3D.Model}
object, the parent is not an Item, therefore this property is \c null.
*/
QQuickItem *QQuickPointerHandler::parentItem() const
{
return qmlobject_cast<QQuickItem *>(QObject::parent());
}
void QQuickPointerHandler::setParentItem(QQuickItem *p)
{
Q_D(QQuickPointerHandler);
if (QObject::parent() == p)
return;
qCDebug(lcHandlerParent) << "reparenting handler" << this << ":" << parent() << "->" << p;
auto *oldParent = static_cast<QQuickItem *>(QObject::parent());
if (oldParent)
QQuickItemPrivate::get(oldParent)->removePointerHandler(this);
setParent(p);
if (p)
QQuickItemPrivate::get(p)->addPointerHandler(this);
d->onParentChanged(oldParent, p);
emit parentChanged();
}
/*! \internal
Pointer Handlers do most of their work in implementations of virtual functions
that are called directly from QQuickItem, not by direct event handling.
But it's convenient to deliver TouchCancel events via QCoreApplication::sendEvent().
Perhaps it will turn out that more events could be delivered this way.
*/
bool QQuickPointerHandler::event(QEvent *e)
{
switch (e->type()) {
case QEvent::TouchCancel: {
auto te = static_cast<QTouchEvent *>(e);
for (int i = 0; i < te->pointCount(); ++i)
onGrabChanged(this, QPointingDevice::CancelGrabExclusive, te, te->point(i));
return true;
break;
}
default:
return QObject::event(e);
break;
}
}
/*! \internal
The entry point to handle the \a event: it's called from
QQuickItemPrivate::handlePointerEvent(), begins with wantsPointerEvent(),
and calls handlePointerEventImpl() if that returns \c true.
*/
void QQuickPointerHandler::handlePointerEvent(QPointerEvent *event)
{
Q_D(QQuickPointerHandler);
bool wants = wantsPointerEvent(event);
qCDebug(lcPointerHandlerDispatch) << metaObject()->className() << objectName()
<< "on" << parent()->metaObject()->className() << parent()->objectName()
<< (wants ? "WANTS" : "DECLINES") << event;
d->currentEvent = event;
if (wants) {
handlePointerEventImpl(event);
d->lastEventTime = event->timestamp();
} else {
#if QT_CONFIG(gestures)
if (event->type() != QEvent::NativeGesture)
#endif
setActive(false);
for (int i = 0; i < event->pointCount(); ++i) {
auto &pt = event->point(i);
if (event->exclusiveGrabber(pt) == this && pt.state() != QEventPoint::Stationary)
event->setExclusiveGrabber(pt, nullptr);
}
}
d->currentEvent = nullptr;
QQuickPointerHandlerPrivate::deviceDeliveryTargets(event->device()).append(this);
}
/*!
It is the responsibility of this function to decide whether the \a event
could be relevant at all to this handler, as a preliminary check.
Returns \c true if this handler would like handlePointerEventImpl() to be called.
If it returns \c false, the handler will be deactivated: \c setActive(false)
will be called, and any remaining exclusive grab will be relinquished,
as a fail-safe.
If you override this function, you should call the immediate parent class
implementation (and return \c false if it returns \c false); that in turn
calls its parent class implementation, and so on.
QQuickSinglePointHandler::wantsPointerEvent() and
QQuickMultiPointHandler::wantsPointerEvent() call wantsEventPoint(), which
is also virtual. You usually can get the behavior you want by subclassing
the appropriate handler type, overriding
QQuickSinglePointHandler::handleEventPoint() or handlePointerEventImpl(),
and perhaps overriding wantsEventPoint() if needed.
\sa wantsEventPoint(), QQuickPointerDeviceHandler::wantsPointerEvent(),
QQuickMultiPointHandler::wantsPointerEvent(), QQuickSinglePointHandler::wantsPointerEvent()
*/
bool QQuickPointerHandler::wantsPointerEvent(QPointerEvent *event)
{
Q_D(const QQuickPointerHandler);
Q_UNUSED(event);
return d->enabled;
}
/*!
Returns \c true if the given \a point (as part of \a event) could be
relevant at all to this handler, as a preliminary check.
If you override this function, you should call the immediate parent class
implementation (and return \c false if it returns \c false); that in turn
calls its parent class implementation, and so on.
In particular, the bounds checking is done here: the base class
QQuickPointerHandler::wantsEventPoint() calls parentContains(point)
(which allows the flexibility promised by margin(), QQuickItem::contains()
and QQuickItem::containmentMask()). Pointer Handlers can receive
QEventPoints that are outside the parent item's bounds: this allows some
flexibility for dealing with multi-point gestures in which one or more
fingers have strayed outside the bounds, and yet the gesture is still
unambiguously intended for the target() item.
You should not generally react to the \a event or \a point here, but it's
ok to set state to remember what needs to be done in your overridden
handlePointerEventImpl() or QQuickSinglePointHandler::handleEventPoint().
*/
bool QQuickPointerHandler::wantsEventPoint(const QPointerEvent *event, const QEventPoint &point)
{
Q_UNUSED(event);
bool ret = event->exclusiveGrabber(point) == this ||
event->passiveGrabbers(point).contains(this) || parentContains(point);
qCDebug(lcPointerHandlerDispatch) << Qt::hex << point.id() << "@" << point.scenePosition()
<< metaObject()->className() << objectName() << ret;
return ret;
}
/*!
\readonly
\qmlproperty bool QtQuick::PointerHandler::active
This holds \c true whenever this Input Handler has taken sole responsibility
for handing one or more \l {eventPoint}{eventPoints}, by successfully taking an
exclusive grab of those points. This means that it is keeping its properties
up-to-date according to the movements of those eventPoints and actively
manipulating its \l target (if any).
*/
bool QQuickPointerHandler::active() const
{
Q_D(const QQuickPointerHandler);
return d->active;
}
void QQuickPointerHandler::setActive(bool active)
{
Q_D(QQuickPointerHandler);
if (d->active != active) {
qCDebug(lcPointerHandlerActive) << this << d->active << "->" << active;
d->active = active;
onActiveChanged();
emit activeChanged();
}
}
/*!
This function can be overridden to implement whatever behavior a specific
subclass is intended to have:
\list
\li Handle all the event's QPointerEvent::points() for which
wantsEventPoint() already returned \c true.
\li Call setPassiveGrab() setExclusiveGrab() or cancelAllGrabs() as
necessary.
\li Call QEvent::accept() to stop propagation, or ignore() to allow it
to keep going.
\endlist
*/
void QQuickPointerHandler::handlePointerEventImpl(QPointerEvent *event)
{
Q_UNUSED(event);
}
/*!
\qmlsignal QtQuick::PointerHandler::grabChanged(PointerDevice::GrabTransition transition, eventPoint point)
This signal is emitted when the grab has changed in some way which is
relevant to this handler.
The \a transition (verb) tells what happened.
The \a point (object) is the point that was grabbed or ungrabbed.
Valid values for \a transition are:
\value PointerDevice.GrabExclusive
This handler has taken primary responsibility for handling the \a point.
\value PointerDevice.UngrabExclusive
This handler has given up its previous exclusive grab.
\value PointerDevice.CancelGrabExclusive
This handler's exclusive grab has been taken over or cancelled.
\value PointerDevice.GrabPassive
This handler has acquired a passive grab, to monitor the \a point.
\value PointerDevice.UngrabPassive
This handler has given up its previous passive grab.
\value PointerDevice.CancelGrabPassive
This handler's previous passive grab has terminated abnormally.
*/
/*!
\qmlsignal QtQuick::PointerHandler::canceled(eventPoint point)
If this handler has already grabbed the given \a point, this signal is
emitted when the grab is stolen by a different Pointer Handler or Item.
*/
/*!
\class QQuickPointerHandlerPrivate
\inmodule QtQuick
\internal
*/
QQuickPointerHandlerPrivate::QQuickPointerHandlerPrivate()
: grabPermissions(QQuickPointerHandler::CanTakeOverFromItems |
QQuickPointerHandler::CanTakeOverFromHandlersOfDifferentType |
QQuickPointerHandler::ApprovesTakeOverByAnything)
, cursorShape(Qt::ArrowCursor)
, enabled(true)
, active(false)
, targetExplicitlySet(false)
, hadKeepMouseGrab(false)
, hadKeepTouchGrab(false)
, cursorSet(false)
, cursorDirty(false)
{
}
/*! \internal
Returns \c true if the movement delta \a d in pixels along the \a axis
exceeds QQuickPointerHandler::dragThreshold() \e or QEventPoint::velocity()
exceeds QStyleHints::startDragVelocity().
\sa QQuickDeliveryAgentPrivate::dragOverThreshold()
*/
template <typename TEventPoint>
bool QQuickPointerHandlerPrivate::dragOverThreshold(qreal d, Qt::Axis axis, const TEventPoint &p) const
{
Q_Q(const QQuickPointerHandler);
QStyleHints *styleHints = qApp->styleHints();
bool overThreshold = qRound(qAbs(d)) > q->dragThreshold();
const bool dragVelocityLimitAvailable = (styleHints->startDragVelocity() > 0);
if (!overThreshold && dragVelocityLimitAvailable) {
qreal velocity = qreal(axis == Qt::XAxis ? p.velocity().x() : p.velocity().y());
overThreshold |= qAbs(velocity) > styleHints->startDragVelocity();
}
return overThreshold;
}
/*!
Returns \c true if the movement \a delta in pixels exceeds
QQuickPointerHandler::dragThreshold().
\sa QQuickDeliveryAgentPrivate::dragOverThreshold()
*/
bool QQuickPointerHandlerPrivate::dragOverThreshold(QVector2D delta) const
{
Q_Q(const QQuickPointerHandler);
const int threshold = q->dragThreshold();
return qRound(qAbs(delta.x())) > threshold || qRound(qAbs(delta.y())) > threshold;
}
/*!
Returns \c true if the movement delta of \a point in pixels
(calculated as QEventPoint::scenePosition() - QEventPoint::scenePressPosition())
exceeds QQuickPointerHandler::dragThreshold().
\sa QQuickDeliveryAgentPrivate::dragOverThreshold()
*/
bool QQuickPointerHandlerPrivate::dragOverThreshold(const QEventPoint &point) const
{
QPointF delta = point.scenePosition() - point.scenePressPosition();
return (dragOverThreshold(delta.x(), Qt::XAxis, point) ||
dragOverThreshold(delta.y(), Qt::YAxis, point));
}
QList<QObject *> &QQuickPointerHandlerPrivate::deviceDeliveryTargets(const QInputDevice *device)
{
return QQuickDeliveryAgentPrivate::deviceExtra(device)->deliveryTargets;
}
QT_END_NAMESPACE
#include "moc_qquickpointerhandler_p.cpp"