diff options
Diffstat (limited to 'src/quick/handlers')
24 files changed, 1366 insertions, 616 deletions
diff --git a/src/quick/handlers/handlers.pri b/src/quick/handlers/handlers.pri index 8bd74d95da..111a526ce2 100644 --- a/src/quick/handlers/handlers.pri +++ b/src/quick/handlers/handlers.pri @@ -1,17 +1,24 @@ HEADERS += \ $$PWD/qquickdraghandler_p.h \ + $$PWD/qquickhandlerpoint_p.h \ $$PWD/qquickhandlersmodule_p.h \ + $$PWD/qquickhoverhandler_p.h \ $$PWD/qquickmultipointhandler_p.h \ $$PWD/qquickpinchhandler_p.h \ $$PWD/qquickpointerdevicehandler_p.h \ + $$PWD/qquickpointerdevicehandler_p_p.h \ $$PWD/qquickpointerhandler_p.h \ + $$PWD/qquickpointerhandler_p_p.h \ $$PWD/qquickpointhandler_p.h \ $$PWD/qquicksinglepointhandler_p.h \ $$PWD/qquicktaphandler_p.h \ + $$PWD/qquickdragaxis_p.h SOURCES += \ $$PWD/qquickdraghandler.cpp \ + $$PWD/qquickhandlerpoint.cpp \ $$PWD/qquickhandlersmodule.cpp \ + $$PWD/qquickhoverhandler.cpp \ $$PWD/qquickmultipointhandler.cpp \ $$PWD/qquickpinchhandler.cpp \ $$PWD/qquickpointerdevicehandler.cpp \ @@ -19,4 +26,4 @@ SOURCES += \ $$PWD/qquickpointhandler.cpp \ $$PWD/qquicksinglepointhandler.cpp \ $$PWD/qquicktaphandler.cpp \ - + $$PWD/qquickdragaxis.cpp diff --git a/src/quick/handlers/qquickdragaxis.cpp b/src/quick/handlers/qquickdragaxis.cpp new file mode 100644 index 0000000000..5efe19b2fe --- /dev/null +++ b/src/quick/handlers/qquickdragaxis.cpp @@ -0,0 +1,75 @@ +/**************************************************************************** +** +** Copyright (C) 2017 The Qt Company Ltd. +** Contact: https://www.qt.io/licensing/ +** +** This file is part of the QtQuick 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 "qquickdragaxis_p.h" +#include <limits> + +QQuickDragAxis::QQuickDragAxis() + : m_minimum(-std::numeric_limits<qreal>::max()) + , m_maximum(std::numeric_limits<qreal>::max()) + , m_enabled(true) +{ +} + +void QQuickDragAxis::setMinimum(qreal minimum) +{ + if (m_minimum == minimum) + return; + + m_minimum = minimum; + emit minimumChanged(); +} + +void QQuickDragAxis::setMaximum(qreal maximum) +{ + if (m_maximum == maximum) + return; + + m_maximum = maximum; + emit maximumChanged(); +} + +void QQuickDragAxis::setEnabled(bool enabled) +{ + if (m_enabled == enabled) + return; + + m_enabled = enabled; + emit enabledChanged(); +} + diff --git a/src/quick/handlers/qquickdragaxis_p.h b/src/quick/handlers/qquickdragaxis_p.h new file mode 100644 index 0000000000..2c2e0a426d --- /dev/null +++ b/src/quick/handlers/qquickdragaxis_p.h @@ -0,0 +1,87 @@ +/**************************************************************************** +** +** Copyright (C) 2017 The Qt Company Ltd. +** Contact: https://www.qt.io/licensing/ +** +** This file is part of the QtQuick 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$ +** +****************************************************************************/ + +#ifndef QQUICKDRAGAXIS_P_H +#define QQUICKDRAGAXIS_P_H + +// +// W A R N I N G +// ------------- +// +// This file is not part of the Qt API. It exists purely as an +// implementation detail. This header file may change from version to +// version without notice, or even be removed. +// +// We mean it. +// + +#include <QtCore/qobject.h> +#include <QtCore/qglobal.h> + +class Q_AUTOTEST_EXPORT QQuickDragAxis : public QObject +{ + Q_OBJECT + Q_PROPERTY(qreal minimum READ minimum WRITE setMinimum NOTIFY minimumChanged) + Q_PROPERTY(qreal maximum READ maximum WRITE setMaximum NOTIFY maximumChanged) + Q_PROPERTY(bool enabled READ enabled WRITE setEnabled NOTIFY enabledChanged) + +public: + QQuickDragAxis(); + + qreal minimum() const { return m_minimum; } + void setMinimum(qreal minimum); + + qreal maximum() const { return m_maximum; } + void setMaximum(qreal maximum); + + bool enabled() const { return m_enabled; } + void setEnabled(bool enabled); + +signals: + void minimumChanged(); + void maximumChanged(); + void enabledChanged(); + +private: + qreal m_minimum; + qreal m_maximum; + bool m_enabled; +}; + +#endif // QQUICKDRAGAXIS_P_H diff --git a/src/quick/handlers/qquickdraghandler.cpp b/src/quick/handlers/qquickdraghandler.cpp index 5e540b3615..8bb8612fb3 100644 --- a/src/quick/handlers/qquickdraghandler.cpp +++ b/src/quick/handlers/qquickdraghandler.cpp @@ -52,7 +52,7 @@ QT_BEGIN_NAMESPACE \brief Handler for dragging. DragHandler is a handler that is used to interactively move an Item. - Like other Pointer Handlers, by default it is fully functional, and + Like other Input Handlers, by default it is fully functional, and manipulates its \l {PointerHandler::target} {target}. \snippet pointerHandlers/dragHandler.qml 0 @@ -243,39 +243,6 @@ void QQuickDragHandler::setTranslation(const QVector2D &trans) applied to the \l {PointerHandler::target} {target}. If \c enabled is true, vertical dragging is allowed. */ -QQuickDragAxis::QQuickDragAxis() - : m_minimum(-DBL_MAX) - , m_maximum(DBL_MAX) - , m_enabled(true) -{ -} - -void QQuickDragAxis::setMinimum(qreal minimum) -{ - if (m_minimum == minimum) - return; - - m_minimum = minimum; - emit minimumChanged(); -} - -void QQuickDragAxis::setMaximum(qreal maximum) -{ - if (m_maximum == maximum) - return; - - m_maximum = maximum; - emit maximumChanged(); -} - -void QQuickDragAxis::setEnabled(bool enabled) -{ - if (m_enabled == enabled) - return; - - m_enabled = enabled; - emit enabledChanged(); -} /*! \readonly diff --git a/src/quick/handlers/qquickdraghandler_p.h b/src/quick/handlers/qquickdraghandler_p.h index 363df31a64..7ba1021924 100644 --- a/src/quick/handlers/qquickdraghandler_p.h +++ b/src/quick/handlers/qquickdraghandler_p.h @@ -52,39 +52,10 @@ // #include "qquicksinglepointhandler_p.h" +#include "qquickdragaxis_p.h" QT_BEGIN_NAMESPACE -class Q_AUTOTEST_EXPORT QQuickDragAxis : public QObject -{ - Q_OBJECT - Q_PROPERTY(qreal minimum READ minimum WRITE setMinimum NOTIFY minimumChanged) - Q_PROPERTY(qreal maximum READ maximum WRITE setMaximum NOTIFY maximumChanged) - Q_PROPERTY(bool enabled READ enabled WRITE setEnabled NOTIFY enabledChanged) - -public: - QQuickDragAxis(); - - qreal minimum() const { return m_minimum; } - void setMinimum(qreal minimum); - - qreal maximum() const { return m_maximum; } - void setMaximum(qreal maximum); - - bool enabled() const { return m_enabled; } - void setEnabled(bool enabled); - -signals: - void minimumChanged(); - void maximumChanged(); - void enabledChanged(); - -private: - qreal m_minimum; - qreal m_maximum; - bool m_enabled; -}; - class Q_AUTOTEST_EXPORT QQuickDragHandler : public QQuickSinglePointHandler { Q_OBJECT diff --git a/src/quick/handlers/qquickhandlerpoint.cpp b/src/quick/handlers/qquickhandlerpoint.cpp new file mode 100644 index 0000000000..4bd5d2cbfb --- /dev/null +++ b/src/quick/handlers/qquickhandlerpoint.cpp @@ -0,0 +1,351 @@ +/**************************************************************************** +** +** Copyright (C) 2018 The Qt Company Ltd. +** Contact: https://www.qt.io/licensing/ +** +** This file is part of the QtQuick 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 "qquickhandlerpoint_p.h" +#include "private/qquickevents_p_p.h" + +QT_BEGIN_NAMESPACE +Q_DECLARE_LOGGING_CATEGORY(DBG_TOUCH_TARGET) + +/*! + \qmltype HandlerPoint + \instantiates QQuickHandlerPoint + \inqmlmodule Qt.labs.handlers + \ingroup qtquick-handlers + \brief An event point. + + A QML representation of a QQuickEventPoint. + + It's possible to make bindings to properties of a \l SinglePointHandler's + current point. For example: + + \snippet pointerHandlers/dragHandlerNullTarget.qml 0 + + The point is kept up-to-date when the DragHandler is actively responding to + an EventPoint; but when the point is released, or the current point is + being handled by a different handler, \c position.x and \c position.y are 0. + + \note This is practically identical to QtQuick::EventPoint; however an + EventPoint is a long-lived QObject which is invalidated between gestures + and reused for subsequent event deliveries. Continuous bindings to its + properties are not possible, and an individual handler cannot rely on it + outside the period when that point is part of an active gesture which that + handler is handling. HandlerPoint is a Q_GADGET that the handler owns. + This allows you to make lifetime bindings to its properties. + + \sa SinglePointHandler::point +*/ + +QQuickHandlerPoint::QQuickHandlerPoint() + : m_id(0) + , m_rotation(0) + , m_pressure(0) +{} + +void QQuickHandlerPoint::reset() +{ + m_id = 0; + m_uniqueId = QPointingDeviceUniqueId(); + m_position = QPointF(); + m_scenePosition = QPointF(); + m_pressPosition = QPointF(); + m_scenePressPosition = QPointF(); + m_sceneGrabPosition = QPointF(); + m_velocity = QVector2D(); + m_rotation = 0; + m_pressure = 0; + m_ellipseDiameters = QSizeF(); + m_pressedButtons = Qt::NoButton; + m_pressedModifiers = Qt::NoModifier; +} + +void QQuickHandlerPoint::reset(const QQuickEventPoint *point) +{ + m_id = point->pointId(); + const QQuickPointerEvent *event = point->pointerEvent(); + switch (point->state()) { + case QQuickEventPoint::Pressed: + m_pressPosition = point->position(); + m_scenePressPosition = point->scenePosition(); + m_pressedButtons = event->buttons(); + break; + case QQuickEventPoint::Released: + reset(); + return; + default: + m_pressedButtons = event->buttons(); + break; + } + m_pressedModifiers = event->modifiers(); + if (event->asPointerTouchEvent()) { + const QQuickEventTouchPoint *tp = static_cast<const QQuickEventTouchPoint *>(point); + m_uniqueId = tp->uniqueId(); + m_rotation = tp->rotation(); + m_pressure = tp->pressure(); + m_ellipseDiameters = tp->ellipseDiameters(); + } else if (event->asPointerTabletEvent()) { + // TODO + } else { + m_uniqueId = event->device()->uniqueId(); + m_rotation = 0; + m_pressure = event->buttons() ? 1 : 0; + m_ellipseDiameters = QSizeF(); + } + m_position = point->position(); + m_scenePosition = point->scenePosition(); + if (point->state() == QQuickEventPoint::Updated) + m_velocity = point->velocity(); +} + +void QQuickHandlerPoint::reset(const QVector<QQuickEventPoint *> &points) +{ + if (points.isEmpty()) { + qWarning("reset: no points"); + return; + } + if (points.count() == 1) { + reset(points.first()); + return; + } + // all points are required to be from the same event + const QQuickPointerEvent *event = points.first()->pointerEvent(); + QPointF posSum; + QPointF scenePosSum; + QVector2D velocitySum; + qreal pressureSum = 0; + QSizeF ellipseDiameterSum; + bool press = false; + const QQuickPointerTouchEvent *touchEvent = event->asPointerTouchEvent(); + for (const QQuickEventPoint *point : qAsConst(points)) { + posSum += point->position(); + scenePosSum += point->scenePosition(); + velocitySum += point->velocity(); + if (touchEvent) { + pressureSum += static_cast<const QQuickEventTouchPoint *>(point)->pressure(); + ellipseDiameterSum += static_cast<const QQuickEventTouchPoint *>(point)->ellipseDiameters(); + } + if (point->state() == QQuickEventPoint::Pressed) + press = true; + } + m_id = 0; + m_uniqueId = QPointingDeviceUniqueId(); + m_pressedButtons = event->buttons(); + m_pressedModifiers = event->modifiers(); + m_position = posSum / points.size(); + m_scenePosition = scenePosSum / points.size(); + if (press) { + m_pressPosition = m_position; + m_scenePressPosition = m_scenePosition; + } + m_velocity = velocitySum / points.size(); + m_rotation = 0; // averaging the rotations of all the points isn't very sensible + m_pressure = pressureSum / points.size(); + m_ellipseDiameters = ellipseDiameterSum / points.size(); +} + +/*! + \readonly + \qmlproperty int QtQuick::HandlerPoint::id + \brief The ID number of the point + + During a touch gesture, from the time that the first finger is pressed + until the last finger is released, each touchpoint will have a unique ID + number. Likewise, if input from multiple devices occurs (for example + simultaneous mouse and touch presses), all the current event points from + all the devices will have unique IDs. + + \note Do not assume that id numbers start at zero or that they are + sequential. Such an assumption is often false due to the way the underlying + drivers work. + + \sa QTouchEvent::TouchPoint::id +*/ + +/*! + \readonly + \qmlproperty PointingDeviceUniqueId QtQuick::HandlerPoint::uniqueId + \brief The unique ID of the point, if any + + This is normally empty, because touchscreens cannot uniquely identify fingers. + + On some types of touchscreens, especially those using TUIO drivers, + it's possible to use recognizable physical tokens (fiducial objects) + in addition to fingers. So if this point is a touch point, and + uniqueId is set, it is the identifier for such an object. + + On a graphics tablet, each type of stylus or other tool often has a unique + ID or serial number, which can be useful to respond in different ways to + different tools. + + Interpreting the contents of this ID requires knowledge of the hardware and + drivers in use. + + \sa QTabletEvent::uniqueId, QtQuick::TouchPoint::uniqueId, QtQuick::EventTouchPoint::uniqueId +*/ + +/*! + \readonly + \qmlproperty QPointF QtQuick::HandlerPoint::position + \brief The position within the \c parent Item + + This is the position of the event point relative to the bounds of + the \l {PointerHandler::parent} {parent}. +*/ + +/*! + \readonly + \qmlproperty QPointF QtQuick::HandlerPoint::scenePosition + \brief The position within the scene + + This is the position of the event point relative to the bounds of the Qt + Quick scene (typically the whole window). +*/ + +/*! + \readonly + \qmlproperty QPointF QtQuick::HandlerPoint::pressPosition + \brief The pressed position within the \c parent Item + + This is the position at which this point was pressed, relative to the + bounds of the \l {PointerHandler::parent} {parent}. +*/ + +/*! + \readonly + \qmlproperty QPointF QtQuick::HandlerPoint::scenePressPosition + \brief The pressed position within the scene + + This is the position at which this point was pressed, in the coordinate + system of the \l {Qt Quick Scene Graph}{scene graph}. +*/ + +/*! + \readonly + \qmlproperty QPointF QtQuick::HandlerPoint::sceneGrabPosition + \brief The grabbed position within the scene + + If this point has been grabbed by a Pointer Handler or an Item, it means + that object has taken sole responsibility for handling the movement and the + release if this point. In that case, this is the position at which the grab + occurred, in the coordinate system of the \l {Qt Quick Scene Graph}{scene graph}. +*/ + +/*! + \readonly + \qmlproperty enum QtQuick::HandlerPoint::pressedButtons + \brief Which mouse or stylus buttons are currently pressed + + \sa MouseArea::pressedButtons +*/ + +/*! + \readonly + \qmlproperty enum QtQuick::HandlerPoint::modifiers + \brief Which modifier keys are currently pressed + + This property holds the keyboard modifiers that were pressed at the time + the event occurred. + + \sa MouseArea::modifiers +*/ + +/*! + \readonly + \qmlproperty QVector2D QtQuick::HandlerPoint::velocity + \brief A vector representing the average speed and direction of movement + + This is a velocity vector pointing in the direction of movement, in logical + pixels per second. It has x and y components, at least one of which will be + nonzero when this point is in motion. It holds the average recent velocity: + how fast and in which direction the event point has been moving recently. + + \sa QtQuick::EventPoint::velocity, QtQuick::TouchPoint::velocity, QTouchEvent::TouchPoint::velocity +*/ + +/*! + \readonly + \qmlproperty qreal QtQuick::HandlerPoint::rotation + + This property holds the rotation angle of the stylus on a graphics tablet + or the contact patch of a touchpoint on a touchscreen. + + It is valid only with certain tablet stylus devices and touchscreens that + can measure the rotation angle. Otherwise, it will be zero. +*/ + +/*! + \readonly + \qmlproperty qreal QtQuick::HandlerPoint::pressure + + This property tells how hard the user is pressing the stylus on a graphics + tablet or the finger against a touchscreen, in the range from \c 0 (no + measurable pressure) to \c 1.0 (maximum pressure which the device can + measure). + + It is valid only with certain tablets and touchscreens that can measure + pressure. Otherwise, it will be zero. +*/ + +/*! + \readonly + \qmlproperty size QtQuick::HandlerPoint::ellipseDiameters + + This property holds the diameters of the contact patch, if the event + comes from a touchpoint and the device provides this information. + + A touchpoint is modeled as an elliptical area where the finger is pressed + against the touchscreen. (In fact, it could also be modeled as a bitmap; + but in that case we expect an elliptical bounding estimate to be fitted to + the contact patch before the event is sent.) The harder the user presses, + the larger the contact patch; so, these diameters provide an alternate way + of detecting pressure, in case the device does not include a separate + pressure sensor. The ellipse is centered on \l scenePosition (\l position + in the PointerHandler's Item's local coordinates). The \l rotation property + provides the rotation of the ellipse, if known. It is expected that if the + \l rotation is zero, the \l {QSize::height}{height} is the larger dimension + (the major axis), because of the usual hand position, reaching upward or + outward across the surface. + + If the contact patch is unknown, or the device is not a touchscreen, + these values will be zero. + + \sa QtQuick::EventTouchPoint::ellipseDiameters, QtQuick::TouchPoint::ellipseDiameters, QTouchEvent::TouchPoint::ellipseDiameters +*/ + +QT_END_NAMESPACE diff --git a/src/quick/handlers/qquickhandlerpoint_p.h b/src/quick/handlers/qquickhandlerpoint_p.h new file mode 100644 index 0000000000..1dff52942a --- /dev/null +++ b/src/quick/handlers/qquickhandlerpoint_p.h @@ -0,0 +1,120 @@ +/**************************************************************************** +** +** Copyright (C) 2018 The Qt Company Ltd. +** Contact: https://www.qt.io/licensing/ +** +** This file is part of the QtQuick 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$ +** +****************************************************************************/ + +#ifndef QQUICKHANDLERPOINT_H +#define QQUICKHANDLERPOINT_H + +// +// W A R N I N G +// ------------- +// +// This file is not part of the Qt API. It exists purely as an +// implementation detail. This header file may change from version to +// version without notice, or even be removed. +// +// We mean it. +// + +#include "qquickpointerdevicehandler_p.h" + +QT_BEGIN_NAMESPACE + +class QQuickMultiPointHandler; +class QQuickSinglePointHandler; + +class Q_QUICK_PRIVATE_EXPORT QQuickHandlerPoint { + Q_GADGET + Q_PROPERTY(int id READ id) + Q_PROPERTY(QPointingDeviceUniqueId uniqueId READ uniqueId) + Q_PROPERTY(QPointF position READ position) + Q_PROPERTY(QPointF scenePosition READ scenePosition) + Q_PROPERTY(QPointF pressPosition READ pressPosition) + Q_PROPERTY(QPointF scenePressPosition READ scenePressPosition) + Q_PROPERTY(QPointF sceneGrabPosition READ sceneGrabPosition) + Q_PROPERTY(Qt::MouseButtons pressedButtons READ pressedButtons) + Q_PROPERTY(Qt::KeyboardModifiers modifiers READ modifiers) + Q_PROPERTY(QVector2D velocity READ velocity) + Q_PROPERTY(qreal rotation READ rotation) + Q_PROPERTY(qreal pressure READ pressure) + Q_PROPERTY(QSizeF ellipseDiameters READ ellipseDiameters) + +public: + QQuickHandlerPoint(); + + int id() const { return m_id; } + Qt::MouseButtons pressedButtons() const { return m_pressedButtons; } + Qt::KeyboardModifiers modifiers() const { return m_pressedModifiers; } + QPointF pressPosition() const { return m_pressPosition; } + QPointF scenePressPosition() const { return m_scenePressPosition; } + QPointF sceneGrabPosition() const { return m_sceneGrabPosition; } + QPointF position() const { return m_position; } + QPointF scenePosition() const { return m_scenePosition; } + QVector2D velocity() const { return m_velocity; } + qreal rotation() const { return m_rotation; } + qreal pressure() const { return m_pressure; } + QSizeF ellipseDiameters() const { return m_ellipseDiameters; } + QPointingDeviceUniqueId uniqueId() const { return m_uniqueId; } + + void reset(); + void reset(const QQuickEventPoint *point); + void reset(const QVector<QQuickEventPoint *> &points); + +private: + int m_id; + QPointingDeviceUniqueId m_uniqueId; + Qt::MouseButtons m_pressedButtons; + Qt::KeyboardModifiers m_pressedModifiers; + QPointF m_position; + QPointF m_scenePosition; + QPointF m_pressPosition; + QPointF m_scenePressPosition; + QPointF m_sceneGrabPosition; + QVector2D m_velocity; + qreal m_rotation; + qreal m_pressure; + QSizeF m_ellipseDiameters; + friend class QQuickMultiPointHandler; + friend class QQuickSinglePointHandler; +}; + +QT_END_NAMESPACE + +QML_DECLARE_TYPE(QQuickHandlerPoint) + +#endif // QQUICKHANDLERPOINT_H diff --git a/src/quick/handlers/qquickhandlersmodule.cpp b/src/quick/handlers/qquickhandlersmodule.cpp index c9e08fe4f2..814602c0bd 100644 --- a/src/quick/handlers/qquickhandlersmodule.cpp +++ b/src/quick/handlers/qquickhandlersmodule.cpp @@ -40,6 +40,7 @@ #include "qquickhandlersmodule_p.h" #include "qquickpointerhandler_p.h" #include "qquickdraghandler_p.h" +#include "qquickhoverhandler_p.h" #include "qquickpinchhandler_p.h" #include "qquickpointhandler_p.h" #include "qquicktaphandler_p.h" @@ -87,6 +88,7 @@ static void qt_quickhandlers_defineModule(const char *uri, int major, int minor) qmlRegisterType<QQuickDragHandler>(uri,major,minor,"DragHandler"); qmlRegisterUncreatableType<QQuickDragAxis>(uri, major, minor, "DragAxis", QQuickDragHandler::tr("DragAxis is only available as a grouped property of DragHandler")); + qmlRegisterType<QQuickHoverHandler>(uri,major,minor,"HoverHandler"); qmlRegisterType<QQuickPinchHandler>(uri,major,minor,"PinchHandler"); qmlRegisterType<QQuickTapHandler>(uri,major,minor,"TapHandler"); qRegisterMetaType<QQuickHandlerPoint>(); diff --git a/src/quick/handlers/qquickhoverhandler.cpp b/src/quick/handlers/qquickhoverhandler.cpp new file mode 100644 index 0000000000..430722bd93 --- /dev/null +++ b/src/quick/handlers/qquickhoverhandler.cpp @@ -0,0 +1,107 @@ +/**************************************************************************** +** +** Copyright (C) 2018 The Qt Company Ltd. +** Contact: https://www.qt.io/licensing/ +** +** This file is part of the QtQuick 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 "qquickhoverhandler_p.h" + +QT_BEGIN_NAMESPACE + +Q_LOGGING_CATEGORY(lcHoverHandler, "qt.quick.handler.hover") + +/*! + \qmltype HoverHandler + \instantiates QQuickHoverHandler + \inqmlmodule QtQuick + \ingroup qtquick-handlers + \brief Handler for mouse and tablet hover + + HoverHandler detects a hovering cursor. Since touchscreens don't generally + offer hover events, in practice it detects a hovering mouse or tablet stylus. + + \sa MouseArea +*/ + +QQuickHoverHandler::QQuickHoverHandler(QObject *parent) + : QQuickSinglePointHandler(parent) + , m_hovered(false) +{ + // Rule out the touchscreen for now (can be overridden in QML in case a hover-detecting touchscreen exists) + setAcceptedDevices(static_cast<QQuickPointerDevice::DeviceType>( + static_cast<int>(QQuickPointerDevice::AllDevices) ^ static_cast<int>(QQuickPointerDevice::TouchScreen))); +} + +QQuickHoverHandler::~QQuickHoverHandler() +{ + QQuickItemPrivate *parItemPrivate = QQuickItemPrivate::get(parentItem()); + parItemPrivate->setHasHoverInChild(false); +} + +void QQuickHoverHandler::componentComplete() +{ + parentItem()->setAcceptHoverEvents(true); + QQuickItemPrivate::get(parentItem())->setHasHoverInChild(true); +} + +bool QQuickHoverHandler::wantsPointerEvent(QQuickPointerEvent *event) +{ + QQuickEventPoint *point = event->point(0); + if (QQuickPointerDeviceHandler::wantsPointerEvent(event) && wantsEventPoint(point)) { + // assume this is a mouse event, so there's only one point + setPointId(point->pointId()); + return true; + } + setHovered(false); + return false; +} + +void QQuickHoverHandler::handleEventPoint(QQuickEventPoint *point) +{ + setHovered(true); + setPassiveGrab(point); +} + +void QQuickHoverHandler::setHovered(bool hovered) +{ + if (m_hovered != hovered) { + qCDebug(lcHoverHandler) << objectName() << "hovered" << m_hovered << "->" << hovered; + m_hovered = hovered; + emit hoveredChanged(); + } +} + +QT_END_NAMESPACE diff --git a/src/quick/handlers/qquickhoverhandler_p.h b/src/quick/handlers/qquickhoverhandler_p.h new file mode 100644 index 0000000000..876d01761b --- /dev/null +++ b/src/quick/handlers/qquickhoverhandler_p.h @@ -0,0 +1,91 @@ +/**************************************************************************** +** +** Copyright (C) 2018 The Qt Company Ltd. +** Contact: https://www.qt.io/licensing/ +** +** This file is part of the QtQuick 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$ +** +****************************************************************************/ + +#ifndef QQUICKHOVERHANDLER_H +#define QQUICKHOVERHANDLER_H + +// +// W A R N I N G +// ------------- +// +// This file is not part of the Qt API. It exists purely as an +// implementation detail. This header file may change from version to +// version without notice, or even be removed. +// +// We mean it. +// + +#include "qquickitem.h" +#include "qevent.h" +#include "qquicksinglepointhandler_p.h" +#include <QtCore/qbasictimer.h> + +QT_BEGIN_NAMESPACE + +class Q_AUTOTEST_EXPORT QQuickHoverHandler : public QQuickSinglePointHandler +{ + Q_OBJECT + Q_PROPERTY(bool hovered READ isHovered NOTIFY hoveredChanged) + +public: + explicit QQuickHoverHandler(QObject *parent = 0); + ~QQuickHoverHandler(); + + bool isHovered() const { return m_hovered; } + +Q_SIGNALS: + void hoveredChanged(); + +protected: + void componentComplete() override; + bool wantsPointerEvent(QQuickPointerEvent *event) override; + void handleEventPoint(QQuickEventPoint *point) override; + +private: + void setHovered(bool hovered); + +private: + bool m_hovered; +}; + +QT_END_NAMESPACE + +QML_DECLARE_TYPE(QQuickHoverHandler) + +#endif // QQUICKHOVERHANDLER_H diff --git a/src/quick/handlers/qquickmultipointhandler.cpp b/src/quick/handlers/qquickmultipointhandler.cpp index d595b4c9b4..9a3732ff84 100644 --- a/src/quick/handlers/qquickmultipointhandler.cpp +++ b/src/quick/handlers/qquickmultipointhandler.cpp @@ -63,7 +63,6 @@ QQuickMultiPointHandler::QQuickMultiPointHandler(QObject *parent, int minimumPoi : QQuickPointerDeviceHandler(parent) , m_minimumPointCount(minimumPointCount) , m_maximumPointCount(-1) - , m_pointDistanceThreshold(0) { } @@ -81,7 +80,7 @@ bool QQuickMultiPointHandler::wantsPointerEvent(QQuickPointerEvent *event) return true; #endif - if (sameAsCurrentPoints(event)) + if (hasCurrentPoints(event)) return true; const QVector<QQuickEventPoint *> candidatePoints = eligiblePoints(event); @@ -91,12 +90,24 @@ bool QQuickMultiPointHandler::wantsPointerEvent(QQuickPointerEvent *event) return ret; } +void QQuickMultiPointHandler::handlePointerEventImpl(QQuickPointerEvent *event) +{ + QQuickPointerHandler::handlePointerEventImpl(event); + m_centroid.reset(m_currentPoints); + emit centroidChanged(); +} + +void QQuickMultiPointHandler::onActiveChanged() +{ + if (active()) { + m_centroid.m_sceneGrabPosition = m_centroid.m_scenePosition; + } +} + QVector<QQuickEventPoint *> QQuickMultiPointHandler::eligiblePoints(QQuickPointerEvent *event) { QVector<QQuickEventPoint *> ret; int c = event->pointCount(); - QRectF parentBounds = parentItem()->mapRectToScene(parentItem()->boundingRect()) - .marginsAdded(QMarginsF(m_pointDistanceThreshold, m_pointDistanceThreshold, m_pointDistanceThreshold, m_pointDistanceThreshold)); // If one or more points are newly pressed or released, all non-released points are candidates for this handler. // In other cases however, do not steal the grab: that is, if a point has a grabber, // it's not a candidate for this handler. @@ -108,7 +119,7 @@ QVector<QQuickEventPoint *> QQuickMultiPointHandler::eligiblePoints(QQuickPointe if (exclusiveGrabber && exclusiveGrabber != this) continue; } - if (p->state() != QQuickEventPoint::Released && parentBounds.contains(p->scenePosition())) + if (p->state() != QQuickEventPoint::Released && wantsEventPoint(p)) ret << p; } return ret; @@ -122,7 +133,7 @@ QVector<QQuickEventPoint *> QQuickMultiPointHandler::eligiblePoints(QQuickPointe If a smaller number of touchpoints are in contact with the \l {PointerHandler::parent}{parent}, they will be ignored. - Any ignored points are eligible to activate other Pointer Handlers that + Any ignored points are eligible to activate other Input Handlers that have different constraints, on the same Item or on other Items. The default value is 2. @@ -148,7 +159,7 @@ void QQuickMultiPointHandler::setMinimumPointCount(int c) chosen in the order that they are pressed, and the remaining points will be ignored. - Any ignored points are eligible to activate other Pointer Handlers that + Any ignored points are eligible to activate other Input Handlers that have different constraints, on the same Item or on other Items. The default value is the same as \l minimumPointCount. @@ -162,34 +173,11 @@ void QQuickMultiPointHandler::setMaximumPointCount(int maximumPointCount) emit maximumPointCountChanged(); } -/*! - \qmlproperty real MultiPointHandler::pointDistanceThreshold - - The margin beyond the bounds of the \l {PointerHandler::parent}{parent} - item within which a touch point 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. - - The default value is 0. - - \image pointDistanceThreshold.png -*/ -void QQuickMultiPointHandler::setPointDistanceThreshold(qreal pointDistanceThreshold) -{ - if (m_pointDistanceThreshold == pointDistanceThreshold) - return; - - m_pointDistanceThreshold = pointDistanceThreshold; - emit pointDistanceThresholdChanged(); -} - -bool QQuickMultiPointHandler::sameAsCurrentPoints(QQuickPointerEvent *event) +bool QQuickMultiPointHandler::hasCurrentPoints(QQuickPointerEvent *event) { bool ret = true; int c = event->pointCount(); - if (c != m_currentPoints.size()) + if (c < m_currentPoints.size()) return false; // TODO optimize: either ensure the points are sorted, // or use std::equal with a predicate @@ -207,27 +195,6 @@ bool QQuickMultiPointHandler::sameAsCurrentPoints(QQuickPointerEvent *event) return ret; } -// TODO make templates for these functions somehow? -QPointF QQuickMultiPointHandler::touchPointCentroid() -{ - QPointF ret; - if (Q_UNLIKELY(m_currentPoints.size() == 0)) - return ret; - for (QQuickEventPoint *point : qAsConst(m_currentPoints)) - ret += point->scenePosition(); - return ret / m_currentPoints.size(); -} - -QVector2D QQuickMultiPointHandler::touchPointCentroidVelocity() -{ - QVector2D ret; - if (Q_UNLIKELY(m_currentPoints.size() == 0)) - return ret; - for (QQuickEventPoint *point : qAsConst(m_currentPoints)) - ret += point->velocity(); - return ret / m_currentPoints.size(); -} - qreal QQuickMultiPointHandler::averageTouchPointDistance(const QPointF &ref) { qreal ret = 0; diff --git a/src/quick/handlers/qquickmultipointhandler_p.h b/src/quick/handlers/qquickmultipointhandler_p.h index 67e550d387..06045771fb 100644 --- a/src/quick/handlers/qquickmultipointhandler_p.h +++ b/src/quick/handlers/qquickmultipointhandler_p.h @@ -53,6 +53,7 @@ #include "qquickitem.h" #include "qevent.h" +#include "qquickhandlerpoint_p.h" #include "qquickpointerdevicehandler_p.h" QT_BEGIN_NAMESPACE @@ -62,7 +63,7 @@ class Q_AUTOTEST_EXPORT QQuickMultiPointHandler : public QQuickPointerDeviceHand Q_OBJECT Q_PROPERTY(int minimumPointCount READ minimumPointCount WRITE setMinimumPointCount NOTIFY minimumPointCountChanged) Q_PROPERTY(int maximumPointCount READ maximumPointCount WRITE setMaximumPointCount NOTIFY maximumPointCountChanged) - Q_PROPERTY(qreal pointDistanceThreshold READ pointDistanceThreshold WRITE setPointDistanceThreshold NOTIFY pointDistanceThresholdChanged) + Q_PROPERTY(QQuickHandlerPoint centroid READ centroid NOTIFY centroidChanged) public: explicit QQuickMultiPointHandler(QObject *parent = nullptr, int minimumPointCount = 2); @@ -74,13 +75,13 @@ public: int maximumPointCount() const { return m_maximumPointCount >= 0 ? m_maximumPointCount : m_minimumPointCount; } void setMaximumPointCount(int maximumPointCount); - qreal pointDistanceThreshold() const { return m_pointDistanceThreshold; } - void setPointDistanceThreshold(qreal pointDistanceThreshold); + QQuickHandlerPoint centroid() const { return m_centroid; } signals: void minimumPointCountChanged(); void maximumPointCountChanged(); void pointDistanceThresholdChanged(); + void centroidChanged(); protected: struct PointData { @@ -91,10 +92,10 @@ protected: }; bool wantsPointerEvent(QQuickPointerEvent *event) override; - bool sameAsCurrentPoints(QQuickPointerEvent *event); + void handlePointerEventImpl(QQuickPointerEvent *event) override; + void onActiveChanged() override; + bool hasCurrentPoints(QQuickPointerEvent *event); QVector<QQuickEventPoint *> eligiblePoints(QQuickPointerEvent *event); - QPointF touchPointCentroid(); - QVector2D touchPointCentroidVelocity(); qreal averageTouchPointDistance(const QPointF &ref); qreal averageStartingDistance(const QPointF &ref); qreal averageTouchPointAngle(const QPointF &ref); @@ -106,9 +107,9 @@ protected: protected: QVector<QQuickEventPoint *> m_currentPoints; + QQuickHandlerPoint m_centroid; int m_minimumPointCount; int m_maximumPointCount; - qreal m_pointDistanceThreshold; }; QT_END_NAMESPACE diff --git a/src/quick/handlers/qquickpinchhandler.cpp b/src/quick/handlers/qquickpinchhandler.cpp index 57d851ed59..c251ae6d36 100644 --- a/src/quick/handlers/qquickpinchhandler.cpp +++ b/src/quick/handlers/qquickpinchhandler.cpp @@ -61,7 +61,7 @@ Q_LOGGING_CATEGORY(lcPinchHandler, "qt.quick.handler.pinch") \brief Handler for pinch gestures. PinchHandler is a handler that interprets a multi-finger gesture to - interactively rotate, zoom, and drag an Item. Like other Pointer Handlers, + interactively rotate, zoom, and drag an Item. Like other Input Handlers, by default it is fully functional, and manipulates its \l target, which is the Item within which it is declared. @@ -88,6 +88,7 @@ Q_LOGGING_CATEGORY(lcPinchHandler, "qt.quick.handler.pinch") QQuickPinchHandler::QQuickPinchHandler(QObject *parent) : QQuickMultiPointHandler(parent, 2) , m_activeScale(1) + , m_accumulatedScale(1) , m_activeRotation(0) , m_activeTranslation(0,0) , m_minimumScale(-qInf()) @@ -287,11 +288,11 @@ bool QQuickPinchHandler::wantsPointerEvent(QQuickPointerEvent *event) void QQuickPinchHandler::onActiveChanged() { + QQuickMultiPointHandler::onActiveChanged(); if (active()) { m_startMatrix = QMatrix4x4(); - m_startCentroid = touchPointCentroid(); - m_startAngles = angles(m_startCentroid); - m_startDistance = averageTouchPointDistance(m_startCentroid); + m_startAngles = angles(m_centroid.sceneGrabPosition()); + m_startDistance = averageTouchPointDistance(m_centroid.sceneGrabPosition()); m_activeRotation = 0; m_activeTranslation = QVector2D(); if (const QQuickItem *t = target()) { @@ -304,7 +305,7 @@ void QQuickPinchHandler::onActiveChanged() m_startMatrix.rotate(m_startRotation, 0, 0, -1); m_startMatrix.translate(-xformOrigin); } else { - m_startScale = 1; + m_startScale = m_accumulatedScale; m_startRotation = 0; } qCInfo(lcPinchHandler) << "activated with starting scale" << m_startScale << "rotation" << m_startRotation; @@ -319,6 +320,7 @@ void QQuickPinchHandler::handlePointerEventImpl(QQuickPointerEvent *event) for (QQuickEventPoint *point : qAsConst(m_currentPoints)) qCDebug(lcPinchHandler) << point->state() << point->sceneGrabPosition() << "->" << point->scenePosition(); } + QQuickMultiPointHandler::handlePointerEventImpl(event); qreal dist = 0; #if QT_CONFIG(gestures) @@ -328,8 +330,7 @@ void QQuickPinchHandler::handlePointerEventImpl(QQuickPointerEvent *event) m_activeScale = 1; m_activeRotation = 0; m_activeTranslation = QVector2D(); - m_centroid = QPointF(); - m_centroidVelocity = QVector2D(); + m_centroid.reset(); setActive(false); emit updated(); return; @@ -344,12 +345,9 @@ void QQuickPinchHandler::handlePointerEventImpl(QQuickPointerEvent *event) return; } if (!active()) { - m_centroid = gesture->point(0)->scenePosition(); setActive(true); - m_startCentroid = m_centroid; // Native gestures for 2-finger pinch do not allow dragging, so // the centroid won't move during the gesture, and translation stays at zero - m_centroidVelocity = QVector2D(); m_activeTranslation = QVector2D(); } } else @@ -374,17 +372,15 @@ void QQuickPinchHandler::handlePointerEventImpl(QQuickPointerEvent *event) return; } // TODO check m_pinchOrigin: right now it acts like it's set to PinchCenter - m_centroid = touchPointCentroid(); - m_centroidVelocity = touchPointCentroidVelocity(); // avoid mapping the minima and maxima, as they might have unmappable values // such as -inf/+inf. Because of this we perform the bounding to min/max in local coords. // 1. scale - dist = averageTouchPointDistance(m_centroid); + dist = averageTouchPointDistance(m_centroid.scenePosition()); m_activeScale = dist / m_startDistance; m_activeScale = qBound(m_minimumScale/m_startScale, m_activeScale, m_maximumScale/m_startScale); // 2. rotate - QVector<PointData> newAngles = angles(m_centroid); + QVector<PointData> newAngles = angles(m_centroid.scenePosition()); const qreal angleDelta = averageAngleDelta(m_startAngles, newAngles); m_activeRotation += angleDelta; m_startAngles = std::move(newAngles); @@ -396,20 +392,19 @@ void QQuickPinchHandler::handlePointerEventImpl(QQuickPointerEvent *event) QPointF centroidParentPos; QRectF bounds(m_minimumX, m_minimumY, m_maximumX - m_minimumX, m_maximumY - m_minimumY); if (target() && target()->parentItem()) { - centroidParentPos = target()->parentItem()->mapFromScene(m_centroid); + centroidParentPos = target()->parentItem()->mapFromScene(m_centroid.scenePosition()); centroidParentPos = QPointF(qBound(bounds.left(), centroidParentPos.x(), bounds.right()), qBound(bounds.top(), centroidParentPos.y(), bounds.bottom())); } const qreal totalRotation = m_startRotation + m_activeRotation; const qreal rotation = qBound(m_minimumRotation, totalRotation, m_maximumRotation); m_activeRotation += (rotation - totalRotation); //adjust for the potential bounding above - const qreal scale = m_startScale * m_activeScale; + m_accumulatedScale = m_startScale * m_activeScale; if (target() && target()->parentItem()) { // 3. Drag/translate - const QPointF centroidStartParentPos = target()->parentItem()->mapFromScene(m_startCentroid); + const QPointF centroidStartParentPos = target()->parentItem()->mapFromScene(m_centroid.sceneGrabPosition()); m_activeTranslation = QVector2D(centroidParentPos - centroidStartParentPos); - // apply rotation + scaling around the centroid - then apply translation. QMatrix4x4 mat; @@ -428,16 +423,16 @@ void QQuickPinchHandler::handlePointerEventImpl(QQuickPointerEvent *event) target()->setPosition(pos); target()->setRotation(rotation); - target()->setScale(scale); + target()->setScale(m_accumulatedScale); // TODO some translation inadvertently happens; try to hold the chosen pinch origin in place } else { - m_activeTranslation = QVector2D(m_centroid - m_startCentroid); + m_activeTranslation = QVector2D(m_centroid.scenePosition() - m_centroid.scenePressPosition()); } - qCDebug(lcPinchHandler) << "centroid" << m_startCentroid << "->" << m_centroid + qCDebug(lcPinchHandler) << "centroid" << m_centroid.scenePressPosition() << "->" << m_centroid.scenePosition() << ", distance" << m_startDistance << "->" << dist - << ", startScale" << m_startScale << "->" << scale + << ", startScale" << m_startScale << "->" << m_accumulatedScale << ", activeRotation" << m_activeRotation << ", rotation" << rotation << " from " << event->device()->type(); @@ -456,22 +451,25 @@ void QQuickPinchHandler::handlePointerEventImpl(QQuickPointerEvent *event) /*! \readonly - \qmlproperty QVector2D QtQuick::PinchHandler::centroidVelocity + \qmlproperty real QtQuick::PinchHandler::scale - The average velocity of the \l centroid: a vector representing the speed - and direction of movement of the whole group of touchpoints, in logical - pixels per second. + The scale factor that will automatically be set on the \l target if it is not null. + Otherwise, bindings can be used to do arbitrary things with this value. + While the pinch gesture is being performed, it is continuously multiplied by + \l activeScale; after the gesture ends, it stays the same; and when the next + pinch gesture begins, it begins to be multiplied by activeScale again. */ /*! \readonly - \qmlproperty real QtQuick::PinchHandler::scale - - The scale factor. It is 1.0 when the gesture begins, increases as the - touchpoints are spread apart, and decreases as the touchpoints are brought - together. If \l target is not null, this will be automatically applied to its - \l {Item::scale}{scale}. Otherwise, bindings can be used to do arbitrary - things with this value. + \qmlproperty real QtQuick::PinchHandler::activeScale + + The scale factor while the pinch gesture is being performed. + It is 1.0 when the gesture begins, increases as the touchpoints are spread + apart, and decreases as the touchpoints are brought together. + If \l target is not null, its \l {Item::scale}{scale} will be automatically + multiplied by this value. + Otherwise, bindings can be used to do arbitrary things with this value. */ /*! diff --git a/src/quick/handlers/qquickpinchhandler_p.h b/src/quick/handlers/qquickpinchhandler_p.h index 9a17971416..0d0630d2a9 100644 --- a/src/quick/handlers/qquickpinchhandler_p.h +++ b/src/quick/handlers/qquickpinchhandler_p.h @@ -66,9 +66,8 @@ class Q_AUTOTEST_EXPORT QQuickPinchHandler : public QQuickMultiPointHandler Q_PROPERTY(qreal minimumRotation READ minimumRotation WRITE setMinimumRotation NOTIFY minimumRotationChanged) Q_PROPERTY(qreal maximumRotation READ maximumRotation WRITE setMaximumRotation NOTIFY maximumRotationChanged) Q_PROPERTY(PinchOrigin pinchOrigin READ pinchOrigin WRITE setPinchOrigin NOTIFY pinchOriginChanged) - Q_PROPERTY(QPointF centroid READ centroid NOTIFY updated) - Q_PROPERTY(QVector2D centroidVelocity READ centroidVelocity NOTIFY updated) Q_PROPERTY(qreal scale READ scale NOTIFY updated) + Q_PROPERTY(qreal activeScale READ activeScale NOTIFY updated) Q_PROPERTY(qreal rotation READ rotation NOTIFY updated) Q_PROPERTY(QVector2D translation READ translation NOTIFY updated) Q_PROPERTY(qreal minimumX READ minimumX WRITE setMinimumX NOTIFY minimumXChanged) @@ -101,11 +100,9 @@ public: void setPinchOrigin(PinchOrigin pinchOrigin); QVector2D translation() const { return m_activeTranslation; } - qreal scale() const { return m_activeScale; } + qreal scale() const { return m_accumulatedScale; } + qreal activeScale() const { return m_activeScale; } qreal rotation() const { return m_activeRotation; } - QPointF centroid() const { return m_centroid; } - QVector2D centroidVelocity() const { return m_centroidVelocity; } - qreal minimumX() const { return m_minimumX; } void setMinimumX(qreal minX); qreal maximumX() const { return m_maximumX; } @@ -135,10 +132,9 @@ protected: private: // properties qreal m_activeScale; + qreal m_accumulatedScale; qreal m_activeRotation; QVector2D m_activeTranslation; - QPointF m_centroid; - QVector2D m_centroidVelocity; qreal m_minimumScale; qreal m_maximumScale; @@ -156,7 +152,6 @@ private: // internal qreal m_startScale; qreal m_startRotation; - QPointF m_startCentroid; qreal m_startDistance; QPointF m_startPos; diff --git a/src/quick/handlers/qquickpointerdevicehandler.cpp b/src/quick/handlers/qquickpointerdevicehandler.cpp index 06831613b6..7b9f6839b1 100644 --- a/src/quick/handlers/qquickpointerdevicehandler.cpp +++ b/src/quick/handlers/qquickpointerdevicehandler.cpp @@ -37,7 +37,7 @@ ** ****************************************************************************/ -#include "qquickpointerdevicehandler_p.h" +#include "qquickpointerdevicehandler_p_p.h" #include <private/qquickitem_p.h> #include <QMouseEvent> #include <QDebug> @@ -59,10 +59,12 @@ QT_BEGIN_NAMESPACE allow filtering based on device type, pointer type, or keyboard modifiers. */ QQuickPointerDeviceHandler::QQuickPointerDeviceHandler(QObject *parent) - : QQuickPointerHandler(parent) - , m_acceptedDevices(QQuickPointerDevice::AllDevices) - , m_acceptedPointerTypes(QQuickPointerDevice::AllPointerTypes) - , m_acceptedModifiers(Qt::KeyboardModifierMask) + : QQuickPointerHandler(*(new QQuickPointerDeviceHandlerPrivate), parent) +{ +} + +QQuickPointerDeviceHandler::QQuickPointerDeviceHandler(QQuickPointerDeviceHandlerPrivate &dd, QObject *parent) + : QQuickPointerHandler(dd, parent) { } @@ -70,6 +72,69 @@ QQuickPointerDeviceHandler::~QQuickPointerDeviceHandler() { } +QQuickPointerDevice::DeviceTypes QQuickPointerDeviceHandler::acceptedDevices() const +{ + Q_D(const QQuickPointerDeviceHandler); + return d->acceptedDevices; +} + +QQuickPointerDevice::PointerTypes QQuickPointerDeviceHandler::acceptedPointerTypes() const +{ + Q_D(const QQuickPointerDeviceHandler); + return d->acceptedPointerTypes; +} + +/*! + \qmlproperty int QtQuick::PointerDeviceHandler::acceptedButtons + + The mouse buttons which can activate this Pointer Handler. + + By default, this property is set to \l {QtQuick::MouseEvent::button} {Qt.LeftButton}. + It can be set to an OR combination of mouse buttons, and will ignore events + from other buttons. + + For example, a control could be made to respond to left and right clicks + in different ways, with two handlers: + + \qml + Item { + TapHandler { + onTapped: console.log("left clicked") + } + TapHandler { + acceptedButtons: Qt.RightButton + onTapped: console.log("right clicked") + } + } + \endqml + + \note Tapping on a touchscreen or tapping the stylus on a graphics tablet + emulates clicking the left mouse button. This behavior can be altered via + \l {PointerDeviceHandler::acceptedDevices}{acceptedDevices} or + \l {PointerDeviceHandler::acceptedPointerTypes}{acceptedPointerTypes}. +*/ +Qt::MouseButtons QQuickPointerDeviceHandler::acceptedButtons() const +{ + Q_D(const QQuickPointerDeviceHandler); + return d->acceptedButtons; +} + +void QQuickPointerDeviceHandler::setAcceptedButtons(Qt::MouseButtons buttons) +{ + Q_D(QQuickPointerDeviceHandler); + if (d->acceptedButtons == buttons) + return; + + d->acceptedButtons = buttons; + emit acceptedButtonsChanged(); +} + +Qt::KeyboardModifiers QQuickPointerDeviceHandler::acceptedModifiers() const +{ + Q_D(const QQuickPointerDeviceHandler); + return d->acceptedModifiers; +} + /*! \qmlproperty int PointerDeviceHandler::acceptedDevices @@ -98,10 +163,11 @@ QQuickPointerDeviceHandler::~QQuickPointerDeviceHandler() */ void QQuickPointerDeviceHandler::setAcceptedDevices(QQuickPointerDevice::DeviceTypes acceptedDevices) { - if (m_acceptedDevices == acceptedDevices) + Q_D(QQuickPointerDeviceHandler); + if (d->acceptedDevices == acceptedDevices) return; - m_acceptedDevices = acceptedDevices; + d->acceptedDevices = acceptedDevices; emit acceptedDevicesChanged(); } @@ -136,10 +202,11 @@ void QQuickPointerDeviceHandler::setAcceptedDevices(QQuickPointerDevice::DeviceT */ void QQuickPointerDeviceHandler::setAcceptedPointerTypes(QQuickPointerDevice::PointerTypes acceptedPointerTypes) { - if (m_acceptedPointerTypes == acceptedPointerTypes) + Q_D(QQuickPointerDeviceHandler); + if (d->acceptedPointerTypes == acceptedPointerTypes) return; - m_acceptedPointerTypes = acceptedPointerTypes; + d->acceptedPointerTypes = acceptedPointerTypes; emit acceptedPointerTypesChanged(); } @@ -171,26 +238,28 @@ void QQuickPointerDeviceHandler::setAcceptedPointerTypes(QQuickPointerDevice::Po */ void QQuickPointerDeviceHandler::setAcceptedModifiers(Qt::KeyboardModifiers acceptedModifiers) { - if (m_acceptedModifiers == acceptedModifiers) + Q_D(QQuickPointerDeviceHandler); + if (d->acceptedModifiers == acceptedModifiers) return; - m_acceptedModifiers = acceptedModifiers; + d->acceptedModifiers = acceptedModifiers; emit acceptedModifiersChanged(); } bool QQuickPointerDeviceHandler::wantsPointerEvent(QQuickPointerEvent *event) { + Q_D(QQuickPointerDeviceHandler); if (!QQuickPointerHandler::wantsPointerEvent(event)) return false; qCDebug(lcPointerHandlerDispatch) << objectName() - << "checking device type" << m_acceptedDevices - << "pointer type" << m_acceptedPointerTypes - << "modifiers" << m_acceptedModifiers; - if ((event->device()->type() & m_acceptedDevices) == 0) + << "checking device type" << d->acceptedDevices + << "pointer type" << d->acceptedPointerTypes + << "modifiers" << d->acceptedModifiers; + if ((event->device()->type() & d->acceptedDevices) == 0) return false; - if ((event->device()->pointerType() & m_acceptedPointerTypes) == 0) + if ((event->device()->pointerType() & d->acceptedPointerTypes) == 0) return false; - if (m_acceptedModifiers != Qt::KeyboardModifierMask && event->modifiers() != m_acceptedModifiers) + if (d->acceptedModifiers != Qt::KeyboardModifierMask && event->modifiers() != d->acceptedModifiers) return false; return true; } diff --git a/src/quick/handlers/qquickpointerdevicehandler_p.h b/src/quick/handlers/qquickpointerdevicehandler_p.h index 1638604ea7..4194769fd7 100644 --- a/src/quick/handlers/qquickpointerdevicehandler_p.h +++ b/src/quick/handlers/qquickpointerdevicehandler_p.h @@ -1,6 +1,6 @@ /**************************************************************************** ** -** Copyright (C) 2016 The Qt Company Ltd. +** Copyright (C) 2018 The Qt Company Ltd. ** Contact: https://www.qt.io/licensing/ ** ** This file is part of the QtQuick module of the Qt Toolkit. @@ -36,6 +36,7 @@ ** $QT_END_LICENSE$ ** ****************************************************************************/ +#include "qquickpointerhandler_p.h" #ifndef QQUICKPOINTERDEVICEHANDLER_H #define QQUICKPOINTERDEVICEHANDLER_H @@ -51,42 +52,45 @@ // We mean it. // -#include "qquickpointerhandler_p.h" - QT_BEGIN_NAMESPACE +class QQuickPointerDeviceHandlerPrivate; + class Q_AUTOTEST_EXPORT QQuickPointerDeviceHandler : public QQuickPointerHandler { Q_OBJECT Q_PROPERTY(QQuickPointerDevice::DeviceTypes acceptedDevices READ acceptedDevices WRITE setAcceptedDevices NOTIFY acceptedDevicesChanged) Q_PROPERTY(QQuickPointerDevice::PointerTypes acceptedPointerTypes READ acceptedPointerTypes WRITE setAcceptedPointerTypes NOTIFY acceptedPointerTypesChanged) + Q_PROPERTY(Qt::MouseButtons acceptedButtons READ acceptedButtons WRITE setAcceptedButtons NOTIFY acceptedButtonsChanged) Q_PROPERTY(Qt::KeyboardModifiers acceptedModifiers READ acceptedModifiers WRITE setAcceptedModifiers NOTIFY acceptedModifiersChanged) public: explicit QQuickPointerDeviceHandler(QObject *parent = nullptr); ~QQuickPointerDeviceHandler(); - QQuickPointerDevice::DeviceTypes acceptedDevices() const { return m_acceptedDevices; } - QQuickPointerDevice::PointerTypes acceptedPointerTypes() const { return m_acceptedPointerTypes; } - Qt::KeyboardModifiers acceptedModifiers() const { return m_acceptedModifiers; } + QQuickPointerDevice::DeviceTypes acceptedDevices() const; + QQuickPointerDevice::PointerTypes acceptedPointerTypes() const; + Qt::MouseButtons acceptedButtons() const; + Qt::KeyboardModifiers acceptedModifiers() const; -public slots: +public Q_SLOTS: void setAcceptedDevices(QQuickPointerDevice::DeviceTypes acceptedDevices); void setAcceptedPointerTypes(QQuickPointerDevice::PointerTypes acceptedPointerTypes); + void setAcceptedButtons(Qt::MouseButtons buttons); void setAcceptedModifiers(Qt::KeyboardModifiers acceptedModifiers); Q_SIGNALS: void acceptedDevicesChanged(); void acceptedPointerTypesChanged(); + void acceptedButtonsChanged(); void acceptedModifiersChanged(); protected: + QQuickPointerDeviceHandler(QQuickPointerDeviceHandlerPrivate &dd, QObject *parent = nullptr); + bool wantsPointerEvent(QQuickPointerEvent *event) override; -protected: - QQuickPointerDevice::DeviceTypes m_acceptedDevices; - QQuickPointerDevice::PointerTypes m_acceptedPointerTypes; - Qt::KeyboardModifiers m_acceptedModifiers; + Q_DECLARE_PRIVATE(QQuickPointerDeviceHandler) }; QT_END_NAMESPACE diff --git a/src/quick/handlers/qquickpointerdevicehandler_p_p.h b/src/quick/handlers/qquickpointerdevicehandler_p_p.h new file mode 100644 index 0000000000..6a950590f3 --- /dev/null +++ b/src/quick/handlers/qquickpointerdevicehandler_p_p.h @@ -0,0 +1,75 @@ +/**************************************************************************** +** +** Copyright (C) 2018 The Qt Company Ltd. +** Contact: https://www.qt.io/licensing/ +** +** This file is part of the QtQuick 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$ +** +****************************************************************************/ + +#ifndef QQUICKPOINTERDEVICEHANDLER_P_H +#define QQUICKPOINTERDEVICEHANDLER_P_H + +// +// W A R N I N G +// ------------- +// +// This file is not part of the Qt API. It exists purely as an +// implementation detail. This header file may change from version to +// version without notice, or even be removed. +// +// We mean it. +// + +#include "qquickpointerdevicehandler_p.h" +#include "qquickpointerhandler_p_p.h" + +QT_BEGIN_NAMESPACE + +class Q_AUTOTEST_EXPORT QQuickPointerDeviceHandlerPrivate : public QQuickPointerHandlerPrivate +{ + Q_DECLARE_PUBLIC(QQuickPointerDeviceHandler) + +public: + static QQuickPointerDeviceHandlerPrivate* get(QQuickPointerDeviceHandler *q) { return q->d_func(); } + static const QQuickPointerDeviceHandlerPrivate* get(const QQuickPointerDeviceHandler *q) { return q->d_func(); } + + QQuickPointerDevice::DeviceTypes acceptedDevices = QQuickPointerDevice::AllDevices; + QQuickPointerDevice::PointerTypes acceptedPointerTypes = QQuickPointerDevice::AllPointerTypes; + Qt::MouseButtons acceptedButtons = Qt::LeftButton; + Qt::KeyboardModifiers acceptedModifiers = Qt::KeyboardModifierMask; +}; + +QT_END_NAMESPACE + +#endif // QQUICKPOINTERDEVICEHANDLER_P_H diff --git a/src/quick/handlers/qquickpointerhandler.cpp b/src/quick/handlers/qquickpointerhandler.cpp index e5b1dc8985..8e10003c6a 100644 --- a/src/quick/handlers/qquickpointerhandler.cpp +++ b/src/quick/handlers/qquickpointerhandler.cpp @@ -38,6 +38,8 @@ ****************************************************************************/ #include "qquickpointerhandler_p.h" +#include "qquickpointerhandler_p_p.h" +#include <QtQuick/private/qquickitem_p.h> QT_BEGIN_NAMESPACE @@ -55,20 +57,17 @@ Q_LOGGING_CATEGORY(lcPointerHandlerActive, "qt.quick.handler.active") \ingroup qtquick-handlers \brief Abstract handler for pointer events. - PointerHandler is the base class handler (not registered as a QML type) for - pointer events without regard to source (touch, mouse or graphics tablet). + 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). */ QQuickPointerHandler::QQuickPointerHandler(QObject *parent) - : QObject(parent) - , m_currentEvent(nullptr) - , m_target(nullptr) - , m_enabled(true) - , m_active(false) - , m_targetExplicitlySet(false) - , m_hadKeepMouseGrab(false) - , m_hadKeepTouchGrab(false) - , m_grabPermissions(CanTakeOverFromItems | CanTakeOverFromHandlersOfDifferentType | ApprovesTakeOverByAnything) + : QObject(*(new QQuickPointerHandlerPrivate), parent) +{ +} + +QQuickPointerHandler::QQuickPointerHandler(QQuickPointerHandlerPrivate &dd, QObject *parent) + : QObject(dd, parent) { } @@ -82,13 +81,46 @@ QQuickPointerHandler::~QQuickPointerHandler() } /*! + \qmlproperty real PointerHandler::margin + + The margin beyond the bounds of the \l {PointerHandler::parent}{parent} + item within which an event point 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 pointDistanceThreshold.png +*/ +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; + emit marginChanged(); +} + +/*! Notification that the grab has changed in some way which is relevant to this handler. - The \a grabber (subject) will be the PointerHandler whose state is changing, + The \a grabber (subject) will be the Input Handler whose state is changing, or null if the state change regards an Item. The \a stateChange (verb) tells what happened. The \a point (object) is the point that was grabbed or ungrabbed. EventPoint has the sole responsibility to call this function. - The PointerHandler must react in whatever way is appropriate, and must + 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) @@ -113,8 +145,9 @@ void QQuickPointerHandler::onGrabChanged(QQuickPointerHandler *grabber, QQuickEv setActive(false); point->setAccepted(false); if (auto par = parentItem()) { - par->setKeepMouseGrab(m_hadKeepMouseGrab); - par->setKeepTouchGrab(m_hadKeepTouchGrab); + Q_D(const QQuickPointerHandler); + par->setKeepMouseGrab(d->hadKeepMouseGrab); + par->setKeepTouchGrab(d->hadKeepTouchGrab); } break; case QQuickEventPoint::OverrideGrabPassive: @@ -124,19 +157,17 @@ void QQuickPointerHandler::onGrabChanged(QQuickPointerHandler *grabber, QQuickEv } if (wasCanceled) emit canceled(point); - else - emit grabChanged(point); + emit grabChanged(stateChange, point); } } /*! - \internal Acquire or give up a passive grab of the given \a point, according to the \a grab state. - Unlike the exclusive grab, multiple PointerHandlers can have passive grabs + 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 a - PointerHandler should acquire a passive grab as soon as a point is pressed, + 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 @@ -181,19 +212,20 @@ bool QQuickPointerHandler::canGrab(QQuickEventPoint *point) */ bool QQuickPointerHandler::approveGrabTransition(QQuickEventPoint *point, QObject *proposedGrabber) { + Q_D(const QQuickPointerHandler); bool allowed = false; if (proposedGrabber == this) { QObject* existingGrabber = point->exclusiveGrabber(); - allowed = (existingGrabber == nullptr) || ((m_grabPermissions & CanTakeOverFromAnything) == CanTakeOverFromAnything); + allowed = (existingGrabber == nullptr) || ((d->grabPermissions & CanTakeOverFromAnything) == CanTakeOverFromAnything); if (existingGrabber) { if (QQuickPointerHandler *existingPhGrabber = point->grabberPointerHandler()) { - if (!allowed && (m_grabPermissions & CanTakeOverFromHandlersOfDifferentType) && + if (!allowed && (d->grabPermissions & CanTakeOverFromHandlersOfDifferentType) && existingPhGrabber->metaObject()->className() != metaObject()->className()) allowed = true; - if (!allowed && (m_grabPermissions & CanTakeOverFromHandlersOfSameType) && + if (!allowed && (d->grabPermissions & CanTakeOverFromHandlersOfSameType) && existingPhGrabber->metaObject()->className() == metaObject()->className()) allowed = true; - } else if ((m_grabPermissions & CanTakeOverFromItems)) { + } else if ((d->grabPermissions & CanTakeOverFromItems)) { QQuickItem * existingItemGrabber = point->grabberItem(); if (existingItemGrabber && !((existingItemGrabber->keepMouseGrab() && point->pointerEvent()->asPointerMouseEvent()) || (existingItemGrabber->keepTouchGrab() && point->pointerEvent()->asPointerTouchEvent()))) @@ -203,18 +235,18 @@ bool QQuickPointerHandler::approveGrabTransition(QQuickEventPoint *point, QObjec } else { // proposedGrabber is different: that means this instance will lose its grab if (proposedGrabber) { - if ((m_grabPermissions & ApprovesTakeOverByAnything) == ApprovesTakeOverByAnything) + if ((d->grabPermissions & ApprovesTakeOverByAnything) == ApprovesTakeOverByAnything) allowed = true; - if (!allowed && (m_grabPermissions & ApprovesTakeOverByHandlersOfDifferentType) && + if (!allowed && (d->grabPermissions & ApprovesTakeOverByHandlersOfDifferentType) && proposedGrabber->metaObject()->className() != metaObject()->className()) allowed = true; - if (!allowed && (m_grabPermissions & ApprovesTakeOverByHandlersOfSameType) && + if (!allowed && (d->grabPermissions & ApprovesTakeOverByHandlersOfSameType) && proposedGrabber->metaObject()->className() == metaObject()->className()) allowed = true; - if (!allowed && (m_grabPermissions & ApprovesTakeOverByItems) && proposedGrabber->inherits("QQuickItem")) + if (!allowed && (d->grabPermissions & ApprovesTakeOverByItems) && proposedGrabber->inherits("QQuickItem")) allowed = true; } else { - if (!allowed && (m_grabPermissions & ApprovesCancellation)) + if (!allowed && (d->grabPermissions & ApprovesCancellation)) allowed = true; } } @@ -236,12 +268,19 @@ bool QQuickPointerHandler::approveGrabTransition(QQuickEventPoint *point, QObjec 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) { - if (m_grabPermissions == grabPermission) + Q_D(QQuickPointerHandler); + if (d->grabPermissions == grabPermission) return; - m_grabPermissions = grabPermission; + d->grabPermissions = grabPermission; emit grabPermissionChanged(); } @@ -253,8 +292,13 @@ void QQuickPointerHandler::componentComplete() { } +QQuickPointerEvent *QQuickPointerHandler::currentEvent() +{ + Q_D(const QQuickPointerHandler); + return d->currentEvent; +} + /*! - \internal 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, @@ -284,7 +328,6 @@ bool QQuickPointerHandler::setExclusiveGrab(QQuickEventPoint *point, bool grab) } /*! - \internal Cancel any existing grab of the given \a point. */ void QQuickPointerHandler::cancelAllGrabs(QQuickEventPoint *point) @@ -300,9 +343,19 @@ QPointF QQuickPointerHandler::eventPos(const QQuickEventPoint *point) const bool QQuickPointerHandler::parentContains(const QQuickEventPoint *point) const { - if (point) { - if (QQuickItem *par = parentItem()) - return par->contains(par->mapFromScene(point->scenePosition())); + if (!point) + return false; + if (QQuickItem *par = parentItem()) { + if (par->window()) { + QPoint screenPosition = par->window()->mapToGlobal(point->scenePosition().toPoint()); + if (!par->window()->geometry().contains(screenPosition)) + return false; + } + QPointF p = par->mapFromScene(point->scenePosition()); + qreal m = margin(); + if (m > 0) + return p.x() >= -m && p.y() >= -m && p.x() <= par->width() + m && p.y() <= par->height() + m; + return par->contains(p); } return false; } @@ -313,15 +366,28 @@ bool QQuickPointerHandler::parentContains(const QQuickEventPoint *point) const If a PointerHandler is disabled, it will reject all events and no signals will be emitted. */ +bool QQuickPointerHandler::enabled() const +{ + Q_D(const QQuickPointerHandler); + return d->enabled; +} + void QQuickPointerHandler::setEnabled(bool enabled) { - if (m_enabled == enabled) + Q_D(QQuickPointerHandler); + if (d->enabled == enabled) return; - m_enabled = enabled; + d->enabled = enabled; emit enabledChanged(); } +bool QQuickPointerHandler::active() const +{ + Q_D(const QQuickPointerHandler); + return d->active; +} + /*! \qmlproperty Item QtQuick::PointerHandler::target @@ -335,21 +401,28 @@ void QQuickPointerHandler::setEnabled(bool enabled) */ void QQuickPointerHandler::setTarget(QQuickItem *target) { - m_targetExplicitlySet = true; - if (m_target == target) + Q_D(QQuickPointerHandler); + d->targetExplicitlySet = true; + if (d->target == target) return; - QQuickItem *oldTarget = m_target; - m_target = target; + QQuickItem *oldTarget = d->target; + d->target = target; onTargetChanged(oldTarget); emit targetChanged(); } +QQuickItem *QQuickPointerHandler::parentItem() const +{ + return static_cast<QQuickItem *>(QObject::parent()); +} + QQuickItem *QQuickPointerHandler::target() const { - if (!m_targetExplicitlySet) + Q_D(const QQuickPointerHandler); + if (!d->targetExplicitlySet) return parentItem(); - return m_target; + return d->target; } void QQuickPointerHandler::handlePointerEvent(QQuickPointerEvent *event) @@ -374,15 +447,24 @@ void QQuickPointerHandler::handlePointerEvent(QQuickPointerEvent *event) bool QQuickPointerHandler::wantsPointerEvent(QQuickPointerEvent *event) { + Q_D(const QQuickPointerHandler); Q_UNUSED(event) - return m_enabled; + return d->enabled; +} + +bool QQuickPointerHandler::wantsEventPoint(QQuickEventPoint *point) +{ + bool ret = parentContains(point); + qCDebug(lcPointerHandlerDispatch) << hex << point->pointId() << "@" << point->scenePosition() + << metaObject()->className() << objectName() << ret; + return ret; } /*! \readonly \qmlproperty bool QtQuick::PointerHandler::active - This holds true whenever this PointerHandler has taken sole responsibility + This holds true whenever this Input Handler has taken sole responsibility for handing one or more 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 Event Points and actively @@ -390,9 +472,10 @@ bool QQuickPointerHandler::wantsPointerEvent(QQuickPointerEvent *event) */ void QQuickPointerHandler::setActive(bool active) { - if (m_active != active) { - qCDebug(lcPointerHandlerActive) << this << m_active << "->" << active; - m_active = active; + Q_D(QQuickPointerHandler); + if (d->active != active) { + qCDebug(lcPointerHandlerActive) << this << d->active << "->" << active; + d->active = active; onActiveChanged(); emit activeChanged(); } @@ -400,7 +483,8 @@ void QQuickPointerHandler::setActive(bool active) void QQuickPointerHandler::handlePointerEventImpl(QQuickPointerEvent *event) { - m_currentEvent = event; + Q_D(QQuickPointerHandler); + d->currentEvent = event; } /*! @@ -417,10 +501,13 @@ void QQuickPointerHandler::handlePointerEventImpl(QQuickPointerEvent *event) */ /*! - \qmlsignal QtQuick::PointerHandler::grabChanged(EventPoint point) + \qmlsignal QtQuick::PointerHandler::grabChanged(GrabState stateChange, EventPoint point) + + This signal is emitted when the grab has changed in some way which is + relevant to this handler. - This signal is emitted when this handler has acquired or relinquished a - passive or exclusive grab of the given \a point. + The \a stateChange (verb) tells what happened. + The \a point (object) is the point that was grabbed or ungrabbed. */ /*! @@ -430,4 +517,20 @@ void QQuickPointerHandler::handlePointerEventImpl(QQuickPointerEvent *event) emitted when the grab is stolen by a different Pointer Handler or Item. */ +QQuickPointerHandlerPrivate::QQuickPointerHandlerPrivate() + : grabPermissions(QQuickPointerHandler::CanTakeOverFromItems | + QQuickPointerHandler::CanTakeOverFromHandlersOfDifferentType | + QQuickPointerHandler::ApprovesTakeOverByAnything) + , enabled(true) + , active(false) + , targetExplicitlySet(false) + , hadKeepMouseGrab(false) + , hadKeepTouchGrab(false) +{ +} + +QQuickPointerHandlerPrivate::~QQuickPointerHandlerPrivate() +{ +} + QT_END_NAMESPACE diff --git a/src/quick/handlers/qquickpointerhandler_p.h b/src/quick/handlers/qquickpointerhandler_p.h index e2bcce8fc9..9644bb959f 100644 --- a/src/quick/handlers/qquickpointerhandler_p.h +++ b/src/quick/handlers/qquickpointerhandler_p.h @@ -51,8 +51,6 @@ // We mean it. // -#include "qevent.h" - #include <QtQuick/private/qquickevents_p_p.h> #include <QtQuick/private/qquickitem_p.h> @@ -60,6 +58,8 @@ QT_BEGIN_NAMESPACE Q_DECLARE_LOGGING_CATEGORY(lcPointerHandlerDispatch) +class QQuickPointerHandlerPrivate; + class Q_QUICK_PRIVATE_EXPORT QQuickPointerHandler : public QObject, public QQmlParserStatus { Q_OBJECT @@ -70,6 +70,7 @@ class Q_QUICK_PRIVATE_EXPORT QQuickPointerHandler : public QObject, public QQmlP Q_PROPERTY(QQuickItem * target READ target WRITE setTarget NOTIFY targetChanged) Q_PROPERTY(QQuickItem * parent READ parentItem CONSTANT) Q_PROPERTY(GrabPermissions grabPermissions READ grabPermissions WRITE setGrabPermissions NOTIFY grabPermissionChanged) + Q_PROPERTY(qreal margin READ margin WRITE setMargin NOTIFY marginChanged) public: explicit QQuickPointerHandler(QObject *parent = nullptr); @@ -91,35 +92,42 @@ public: Q_FLAG(GrabPermissions) public: - bool enabled() const { return m_enabled; } + bool enabled() const; void setEnabled(bool enabled); - bool active() const { return m_active; } + bool active() const; QQuickItem *target() const; void setTarget(QQuickItem *target); - QQuickItem * parentItem() const { return static_cast<QQuickItem *>(QObject::parent()); } + QQuickItem * parentItem() const; void handlePointerEvent(QQuickPointerEvent *event); - GrabPermissions grabPermissions() const { return static_cast<GrabPermissions>(m_grabPermissions); } + GrabPermissions grabPermissions() const; void setGrabPermissions(GrabPermissions grabPermissions); + qreal margin() const; + void setMargin(qreal pointDistanceThreshold); + Q_SIGNALS: void enabledChanged(); void activeChanged(); void targetChanged(); - void grabChanged(QQuickEventPoint *point); + void marginChanged(); + void grabChanged(QQuickEventPoint::GrabState stateChange, QQuickEventPoint *point); void grabPermissionChanged(); void canceled(QQuickEventPoint *point); protected: + QQuickPointerHandler(QQuickPointerHandlerPrivate &dd, QObject *parent); + void classBegin() override; void componentComplete() override; - QQuickPointerEvent *currentEvent() { return m_currentEvent; } + QQuickPointerEvent *currentEvent(); virtual bool wantsPointerEvent(QQuickPointerEvent *event); + virtual bool wantsEventPoint(QQuickEventPoint *point); virtual void handlePointerEventImpl(QQuickPointerEvent *event); void setActive(bool active); virtual void onTargetChanged(QQuickItem *oldTarget) { Q_UNUSED(oldTarget); } @@ -133,19 +141,11 @@ protected: QPointF eventPos(const QQuickEventPoint *point) const; bool parentContains(const QQuickEventPoint *point) const; -private: - QQuickPointerEvent *m_currentEvent; - QQuickItem *m_target; - bool m_enabled : 1; - bool m_active : 1; - bool m_targetExplicitlySet : 1; - bool m_hadKeepMouseGrab : 1; // some handlers override target()->setKeepMouseGrab(); this remembers previous state - bool m_hadKeepTouchGrab : 1; // some handlers override target()->setKeepTouchGrab(); this remembers previous state - uint m_reserved : 19; - uint8_t m_grabPermissions : 8; - friend class QQuickEventPoint; + friend class QQuickItemPrivate; friend class QQuickWindowPrivate; + + Q_DECLARE_PRIVATE(QQuickPointerHandler) }; Q_DECLARE_OPERATORS_FOR_FLAGS(QQuickPointerHandler::GrabPermissions) diff --git a/src/quick/handlers/qquickpointerhandler_p_p.h b/src/quick/handlers/qquickpointerhandler_p_p.h new file mode 100644 index 0000000000..c0b2b84a66 --- /dev/null +++ b/src/quick/handlers/qquickpointerhandler_p_p.h @@ -0,0 +1,85 @@ +/**************************************************************************** +** +** Copyright (C) 2018 The Qt Company Ltd. +** Contact: https://www.qt.io/licensing/ +** +** This file is part of the QtQuick 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$ +** +****************************************************************************/ + +#ifndef QQUICKPOINTERHANDLER_P_H +#define QQUICKPOINTERHANDLER_P_H + +// +// W A R N I N G +// ------------- +// +// This file is not part of the Qt API. It exists purely as an +// implementation detail. This header file may change from version to +// version without notice, or even be removed. +// +// We mean it. +// + +#include "qevent.h" + +#include <QtQuick/private/qquickevents_p_p.h> +#include <QtQuick/private/qquickpointerhandler_p.h> + +QT_BEGIN_NAMESPACE + +class Q_QUICK_PRIVATE_EXPORT QQuickPointerHandlerPrivate : public QObjectPrivate +{ + Q_DECLARE_PUBLIC(QQuickPointerHandler) + +public: + static QQuickPointerHandlerPrivate* get(QQuickPointerHandler *q) { return q->d_func(); } + static const QQuickPointerHandlerPrivate* get(const QQuickPointerHandler *q) { return q->d_func(); } + + QQuickPointerHandlerPrivate(); + virtual ~QQuickPointerHandlerPrivate() override; + + QQuickPointerEvent *currentEvent = nullptr; + QQuickItem *target = nullptr; + qreal m_margin = 0; + uint8_t grabPermissions : 8; + bool enabled : 1; + bool active : 1; + bool targetExplicitlySet : 1; + bool hadKeepMouseGrab : 1; // some handlers override target()->setKeepMouseGrab(); this remembers previous state + bool hadKeepTouchGrab : 1; // some handlers override target()->setKeepTouchGrab(); this remembers previous state +}; + +QT_END_NAMESPACE + +#endif // QQUICKPOINTERHANDLER_P_H diff --git a/src/quick/handlers/qquickpointhandler.cpp b/src/quick/handlers/qquickpointhandler.cpp index 7e2d40452c..7cf37969cc 100644 --- a/src/quick/handlers/qquickpointhandler.cpp +++ b/src/quick/handlers/qquickpointhandler.cpp @@ -97,7 +97,7 @@ QT_BEGIN_NAMESPACE \snippet pointerHandlers/pointHandler.qml 0 - Like all pointer handlers, a PointHandler has a \l target property, which + Like all input handlers, a PointHandler has a \l target property, which may be used as a convenient place to put a point-tracking Item; but PointHandler will not automatically manipulate the \c target item in any way. You need to use bindings to make it react to the \l point. diff --git a/src/quick/handlers/qquicksinglepointhandler.cpp b/src/quick/handlers/qquicksinglepointhandler.cpp index 9df20390e4..71c05891d4 100644 --- a/src/quick/handlers/qquicksinglepointhandler.cpp +++ b/src/quick/handlers/qquicksinglepointhandler.cpp @@ -1,6 +1,6 @@ /**************************************************************************** ** -** Copyright (C) 2017 The Qt Company Ltd. +** Copyright (C) 2018 The Qt Company Ltd. ** Contact: https://www.qt.io/licensing/ ** ** This file is part of the QtQuick module of the Qt Toolkit. @@ -61,7 +61,6 @@ Q_DECLARE_LOGGING_CATEGORY(DBG_TOUCH_TARGET) QQuickSinglePointHandler::QQuickSinglePointHandler(QObject *parent) : QQuickPointerDeviceHandler(parent) - , m_acceptedButtons(Qt::LeftButton) , m_ignoreAdditionalPoints(false) { } @@ -71,7 +70,7 @@ bool QQuickSinglePointHandler::wantsPointerEvent(QQuickPointerEvent *event) if (!QQuickPointerDeviceHandler::wantsPointerEvent(event)) return false; if (event->device()->pointerType() != QQuickPointerDevice::Finger && - (event->buttons() & m_acceptedButtons) == 0 && (event->button() & m_acceptedButtons) == 0) + (event->buttons() & acceptedButtons()) == 0 && (event->button() & acceptedButtons()) == 0) return false; if (m_pointInfo.m_id) { @@ -79,16 +78,23 @@ bool QQuickSinglePointHandler::wantsPointerEvent(QQuickPointerEvent *event) // It's expected to be an update or a release. // If we no longer want it, cancel the grab. int candidatePointCount = 0; + bool missing = true; QQuickEventPoint *point = nullptr; int c = event->pointCount(); for (int i = 0; i < c; ++i) { QQuickEventPoint *p = event->point(i); + const bool found = (p->pointId() == m_pointInfo.m_id); + if (found) + missing = false; if (wantsEventPoint(p)) { ++candidatePointCount; - if (p->pointId() == m_pointInfo.m_id) + if (found) point = p; } } + if (missing) + qCWarning(DBG_TOUCH_TARGET) << this << "pointId" << hex << m_pointInfo.m_id + << "is missing from current event, but was neither canceled nor released"; if (point) { if (candidatePointCount == 1 || (candidatePointCount > 1 && m_ignoreAdditionalPoints)) { point->setAccepted(); @@ -97,8 +103,6 @@ bool QQuickSinglePointHandler::wantsPointerEvent(QQuickPointerEvent *event) point->cancelAllGrabs(this); } } else { - qCWarning(DBG_TOUCH_TARGET) << this << "pointId" << hex << m_pointInfo.m_id - << "is missing from current event, but was neither canceled nor released"; return false; } } else { @@ -115,7 +119,7 @@ bool QQuickSinglePointHandler::wantsPointerEvent(QQuickPointerEvent *event) } } if (chosen && candidatePointCount == 1) { - m_pointInfo.m_id = chosen->pointId(); + setPointId(chosen->pointId()); chosen->setAccepted(); } } @@ -130,48 +134,16 @@ void QQuickSinglePointHandler::handlePointerEventImpl(QQuickPointerEvent *event) if (!m_pointInfo.m_id || !currentPoint->isAccepted()) { reset(); } else { - if (event->asPointerTouchEvent()) { - QQuickEventTouchPoint *tp = static_cast<QQuickEventTouchPoint *>(currentPoint); - m_pointInfo.m_uniqueId = tp->uniqueId(); - m_pointInfo.m_rotation = tp->rotation(); - m_pointInfo.m_pressure = tp->pressure(); - m_pointInfo.m_ellipseDiameters = tp->ellipseDiameters(); - } else if (event->asPointerTabletEvent()) { - // TODO - } else { - m_pointInfo.m_uniqueId = event->device()->uniqueId(); - m_pointInfo.m_rotation = 0; - m_pointInfo.m_pressure = event->buttons() ? 1 : 0; - m_pointInfo.m_ellipseDiameters = QSizeF(); - } - m_pointInfo.m_position = currentPoint->position(); - m_pointInfo.m_scenePosition = currentPoint->scenePosition(); - if (currentPoint->state() == QQuickEventPoint::Updated) - m_pointInfo.m_velocity = currentPoint->velocity(); + m_pointInfo.reset(currentPoint); handleEventPoint(currentPoint); - switch (currentPoint->state()) { - case QQuickEventPoint::Pressed: - m_pointInfo.m_pressPosition = currentPoint->position(); - m_pointInfo.m_scenePressPosition = currentPoint->scenePosition(); - m_pointInfo.m_pressedButtons = event->buttons(); - break; - case QQuickEventPoint::Released: + if (currentPoint->state() == QQuickEventPoint::Released) { setExclusiveGrab(currentPoint, false); reset(); - break; - default: - m_pointInfo.m_pressedButtons = event->buttons(); - break; } emit pointChanged(); } } -bool QQuickSinglePointHandler::wantsEventPoint(QQuickEventPoint *point) -{ - return parentContains(point); -} - void QQuickSinglePointHandler::onGrabChanged(QQuickPointerHandler *grabber, QQuickEventPoint::GrabState stateChange, QQuickEventPoint *point) { if (grabber != this) @@ -212,42 +184,9 @@ void QQuickSinglePointHandler::moveTarget(QPointF pos, QQuickEventPoint *point) m_pointInfo.m_position = target()->mapFromScene(m_pointInfo.m_scenePosition); } -/*! - \qmlproperty int QtQuick::SinglePointHandler::acceptedButtons - - The mouse buttons which can activate this Pointer Handler. - - By default, this property is set to \l {QtQuick::MouseEvent::button} {Qt.LeftButton}. - It can be set to an OR combination of mouse buttons, and will ignore events - from other buttons. - - For example, a control could be made to respond to left and right clicks - in different ways, with two handlers: - - \qml - Item { - TapHandler { - onTapped: console.log("left clicked") - } - TapHandler { - acceptedButtons: Qt.RightButton - onTapped: console.log("right clicked") - } - } - \endqml - - \note Tapping on a touchscreen or tapping the stylus on a graphics tablet - emulates clicking the left mouse button. This behavior can be altered via - \l {PointerDeviceHandler::acceptedDevices}{acceptedDevices} or - \l {PointerDeviceHandler::acceptedPointerTypes}{acceptedPointerTypes}. -*/ -void QQuickSinglePointHandler::setAcceptedButtons(Qt::MouseButtons buttons) +void QQuickSinglePointHandler::setPointId(int id) { - if (m_acceptedButtons == buttons) - return; - - m_acceptedButtons = buttons; - emit acceptedButtonsChanged(); + m_pointInfo.m_id = id; } void QQuickSinglePointHandler::reset() @@ -264,213 +203,4 @@ void QQuickSinglePointHandler::reset() handled, this object is reset to default values (all coordinates are 0). */ -/*! - \qmltype HandlerPoint - \instantiates QQuickHandlerPoint - \inqmlmodule Qt.labs.handlers - \ingroup qtquick-handlers - \brief An event point. - - A QML representation of a QQuickEventPoint. - - It's possible to make bindings to properties of a \l SinglePointHandler's - current point. For example: - - \snippet pointerHandlers/dragHandlerNullTarget.qml 0 - - The point is kept up-to-date when the DragHandler is actively responding to - an EventPoint; but when the point is released, or the current point is - being handled by a different handler, \c position.x and \c position.y are 0. - - \note This is practically identical to QtQuick::EventPoint; however an - EventPoint is a long-lived QObject which is invalidated between gestures - and reused for subsequent event deliveries. Continuous bindings to its - properties are not possible, and an individual handler cannot rely on it - outside the period when that point is part of an active gesture which that - handler is handling. HandlerPoint is a Q_GADGET that the handler owns. - This allows you to make lifetime bindings to its properties. - - \sa SinglePointHandler::point -*/ - -QQuickHandlerPoint::QQuickHandlerPoint() - : m_id(0) - , m_rotation(0) - , m_pressure(0) -{} - -void QQuickHandlerPoint::reset() -{ - m_id = 0; - m_uniqueId = QPointingDeviceUniqueId(); - m_position = QPointF(); - m_scenePosition = QPointF(); - m_pressPosition = QPointF(); - m_scenePressPosition = QPointF(); - m_sceneGrabPosition = QPointF(); - m_velocity = QVector2D(); - m_rotation = 0; - m_pressure = 0; - m_ellipseDiameters = QSizeF(); - m_pressedButtons = Qt::NoButton; -} - -/*! - \readonly - \qmlproperty int QtQuick::HandlerPoint::id - \brief The ID number of the point - - During a touch gesture, from the time that the first finger is pressed - until the last finger is released, each touchpoint will have a unique ID - number. Likewise, if input from multiple devices occurs (for example - simultaneous mouse and touch presses), all the current event points from - all the devices will have unique IDs. - - \note Do not assume that id numbers start at zero or that they are - sequential. Such an assumption is often false due to the way the underlying - drivers work. - - \sa QTouchEvent::TouchPoint::id -*/ - -/*! - \readonly - \qmlproperty PointingDeviceUniqueId QtQuick::HandlerPoint::uniqueId - \brief The unique ID of the point, if any - - This is normally empty, because touchscreens cannot uniquely identify fingers. - - On some types of touchscreens, especially those using TUIO drivers, - it's possible to use recognizable physical tokens (fiducial objects) - in addition to fingers. So if this point is a touch point, and - uniqueId is set, it is the identifier for such an object. - - On a graphics tablet, each type of stylus or other tool often has a unique - ID or serial number, which can be useful to respond in different ways to - different tools. - - Interpreting the contents of this ID requires knowledge of the hardware and - drivers in use. - - \sa QTabletEvent::uniqueId, QtQuick::TouchPoint::uniqueId, QtQuick::EventTouchPoint::uniqueId -*/ - -/*! - \readonly - \qmlproperty QPointF QtQuick::HandlerPoint::position - \brief The position within the \c parent Item - - This is the position of the event point relative to the bounds of - the \l {PointerHandler::parent} {parent}. -*/ - -/*! - \readonly - \qmlproperty QPointF QtQuick::HandlerPoint::scenePosition - \brief The position within the scene - - This is the position of the event point relative to the bounds of the Qt - Quick scene (typically the whole window). -*/ - -/*! - \readonly - \qmlproperty QPointF QtQuick::HandlerPoint::pressPosition - \brief The pressed position within the \c parent Item - - This is the position at which this point was pressed, relative to the - bounds of the \l {PointerHandler::parent} {parent}. -*/ - -/*! - \readonly - \qmlproperty QPointF QtQuick::HandlerPoint::scenePressPosition - \brief The pressed position within the scene - - This is the position at which this point was pressed, in the coordinate - system of the \l {Qt Quick Scene Graph}{scene graph}. -*/ - -/*! - \readonly - \qmlproperty QPointF QtQuick::HandlerPoint::sceneGrabPosition - \brief The grabbed position within the scene - - If this point has been grabbed by a Pointer Handler or an Item, it means - that object has taken sole responsibility for handling the movement and the - release if this point. In that case, this is the position at which the grab - occurred, in the coordinate system of the \l {Qt Quick Scene Graph}{scene graph}. -*/ - -/*! - \readonly - \qmlproperty enum QtQuick::HandlerPoint::pressedButtons - \brief Which mouse or stylus buttons are currently pressed - - \sa MouseArea::pressedButtons -*/ - -/*! - \readonly - \qmlproperty QVector2D QtQuick::HandlerPoint::velocity - \brief A vector representing the average speed and direction of movement - - This is a velocity vector pointing in the direction of movement, in logical - pixels per second. It has x and y components, at least one of which will be - nonzero when this point is in motion. It holds the average recent velocity: - how fast and in which direction the event point has been moving recently. - - \sa QtQuick::EventPoint::velocity, QtQuick::TouchPoint::velocity, QTouchEvent::TouchPoint::velocity -*/ - -/*! - \readonly - \qmlproperty qreal QtQuick::HandlerPoint::rotation - - This property holds the rotation angle of the stylus on a graphics tablet - or the contact patch of a touchpoint on a touchscreen. - - It is valid only with certain tablet stylus devices and touchscreens that - can measure the rotation angle. Otherwise, it will be zero. -*/ - -/*! - \readonly - \qmlproperty qreal QtQuick::HandlerPoint::pressure - - This property tells how hard the user is pressing the stylus on a graphics - tablet or the finger against a touchscreen, in the range from \c 0 (no - measurable pressure) to \c 1.0 (maximum pressure which the device can - measure). - - It is valid only with certain tablets and touchscreens that can measure - pressure. Otherwise, it will be zero. -*/ - -/*! - \readonly - \qmlproperty size QtQuick::HandlerPoint::ellipseDiameters - - This property holds the diameters of the contact patch, if the event - comes from a touchpoint and the device provides this information. - - A touchpoint is modeled as an elliptical area where the finger is pressed - against the touchscreen. (In fact, it could also be modeled as a bitmap; - but in that case we expect an elliptical bounding estimate to be fitted to - the contact patch before the event is sent.) The harder the user presses, - the larger the contact patch; so, these diameters provide an alternate way - of detecting pressure, in case the device does not include a separate - pressure sensor. The ellipse is centered on \l scenePosition (\l position - in the PointerHandler's Item's local coordinates). The \l rotation property - provides the rotation of the ellipse, if known. It is expected that if the - \l rotation is zero, the \l {QSize::height}{height} is the larger dimension - (the major axis), because of the usual hand position, reaching upward or - outward across the surface. - - If the contact patch is unknown, or the device is not a touchscreen, - these values will be zero. - - \sa QtQuick::EventTouchPoint::ellipseDiameters, QtQuick::TouchPoint::ellipseDiameters, QTouchEvent::TouchPoint::ellipseDiameters -*/ - QT_END_NAMESPACE diff --git a/src/quick/handlers/qquicksinglepointhandler_p.h b/src/quick/handlers/qquicksinglepointhandler_p.h index 7606b4f7ba..7c225aab46 100644 --- a/src/quick/handlers/qquicksinglepointhandler_p.h +++ b/src/quick/handlers/qquicksinglepointhandler_p.h @@ -1,6 +1,6 @@ /**************************************************************************** ** -** Copyright (C) 2016 The Qt Company Ltd. +** Copyright (C) 2018 The Qt Company Ltd. ** Contact: https://www.qt.io/licensing/ ** ** This file is part of the QtQuick module of the Qt Toolkit. @@ -51,82 +51,27 @@ // We mean it. // +#include "qquickhandlerpoint_p.h" #include "qquickpointerdevicehandler_p.h" QT_BEGIN_NAMESPACE -class QQuickSinglePointHandler; - -class Q_QUICK_PRIVATE_EXPORT QQuickHandlerPoint { - Q_GADGET - Q_PROPERTY(int id READ id) - Q_PROPERTY(QPointingDeviceUniqueId uniqueId READ uniqueId) - Q_PROPERTY(QPointF position READ position) - Q_PROPERTY(QPointF scenePosition READ scenePosition) - Q_PROPERTY(QPointF pressPosition READ pressPosition) - Q_PROPERTY(QPointF scenePressPosition READ scenePressPosition) - Q_PROPERTY(QPointF sceneGrabPosition READ sceneGrabPosition) - Q_PROPERTY(Qt::MouseButtons pressedButtons READ pressedButtons) - Q_PROPERTY(QVector2D velocity READ velocity) - Q_PROPERTY(qreal rotation READ rotation) - Q_PROPERTY(qreal pressure READ pressure) - Q_PROPERTY(QSizeF ellipseDiameters READ ellipseDiameters) - -public: - QQuickHandlerPoint(); - - int id() const { return m_id; } - Qt::MouseButtons pressedButtons() const { return m_pressedButtons; } - QPointF pressPosition() const { return m_pressPosition; } - QPointF scenePressPosition() const { return m_scenePressPosition; } - QPointF sceneGrabPosition() const { return m_sceneGrabPosition; } - QPointF position() const { return m_position; } - QPointF scenePosition() const { return m_scenePosition; } - QVector2D velocity() const { return m_velocity; } - qreal rotation() const { return m_rotation; } - qreal pressure() const { return m_pressure; } - QSizeF ellipseDiameters() const { return m_ellipseDiameters; } - QPointingDeviceUniqueId uniqueId() const { return m_uniqueId; } - -private: - void reset(); - int m_id; - QPointingDeviceUniqueId m_uniqueId; - Qt::MouseButtons m_pressedButtons; - QPointF m_position; - QPointF m_scenePosition; - QPointF m_pressPosition; - QPointF m_scenePressPosition; - QPointF m_sceneGrabPosition; - QVector2D m_velocity; - qreal m_rotation; - qreal m_pressure; - QSizeF m_ellipseDiameters; - friend class QQuickSinglePointHandler; -}; - class Q_QUICK_PRIVATE_EXPORT QQuickSinglePointHandler : public QQuickPointerDeviceHandler { Q_OBJECT - Q_PROPERTY(Qt::MouseButtons acceptedButtons READ acceptedButtons WRITE setAcceptedButtons NOTIFY acceptedButtonsChanged) Q_PROPERTY(QQuickHandlerPoint point READ point NOTIFY pointChanged) public: explicit QQuickSinglePointHandler(QObject *parent = nullptr); virtual ~QQuickSinglePointHandler() { } - Qt::MouseButtons acceptedButtons() const { return m_acceptedButtons; } - void setAcceptedButtons(Qt::MouseButtons buttons); - QQuickHandlerPoint point() const { return m_pointInfo; } Q_SIGNALS: void pointChanged(); void singlePointGrabChanged(); // QQuickPointerHandler::grabChanged signal can't be a property notifier here - void acceptedButtonsChanged(); protected: bool wantsPointerEvent(QQuickPointerEvent *event) override; - virtual bool wantsEventPoint(QQuickEventPoint *point); void handlePointerEventImpl(QQuickPointerEvent *event) override; virtual void handleEventPoint(QQuickEventPoint *point) = 0; @@ -137,18 +82,18 @@ protected: void moveTarget(QPointF pos, QQuickEventPoint *point); + void setPointId(int id); + private: void reset(); private: QQuickHandlerPoint m_pointInfo; - Qt::MouseButtons m_acceptedButtons; bool m_ignoreAdditionalPoints : 1; }; QT_END_NAMESPACE -QML_DECLARE_TYPE(QQuickHandlerPoint) QML_DECLARE_TYPE(QQuickSinglePointHandler) #endif // QQUICKPOINTERSINGLEHANDLER_H diff --git a/src/quick/handlers/qquicktaphandler.cpp b/src/quick/handlers/qquicktaphandler.cpp index 902ff0df10..255059b9bd 100644 --- a/src/quick/handlers/qquicktaphandler.cpp +++ b/src/quick/handlers/qquicktaphandler.cpp @@ -65,7 +65,7 @@ int QQuickTapHandler::m_touchMultiTapDistanceSquared(-1); value is DragThreshold, which requires the press and release to be close together in both space and time. In this case, DragHandler is able to function using only a passive grab, and therefore does not interfere with - event delivery to any other Items or Pointer Handlers. So the default + event delivery to any other Items or Input Handlers. So the default gesturePolicy is useful when you want to modify behavior of an existing control or Item by adding a TapHandler with bindings and/or JavaScript callbacks. @@ -107,7 +107,7 @@ QQuickTapHandler::~QQuickTapHandler() { } -static bool dragOverThreshold(QQuickEventPoint *point) +static bool dragOverThreshold(const QQuickEventPoint *point) { QPointF delta = point->scenePosition() - point->scenePressPosition(); return (QQuickWindowPrivate::dragOverThreshold(delta.x(), Qt::XAxis, point) || @@ -237,7 +237,7 @@ void QQuickTapHandler::timerEvent(QTimerEvent *event) threshold (QStyleHints::startDragDistance), the tap gesture is canceled, even if the button or finger is still pressed. This policy can be useful whenever TapHandler needs to cooperate with other - pointer handlers (for example \l DragHandler) or event-handling Items + input handlers (for example \l DragHandler) or event-handling Items (for example QtQuick Controls), because in this case TapHandler will not take the exclusive grab, but merely a passive grab. |