// Copyright (C) 2020 The Qt Company Ltd.

// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only

// Qt-Security score:significant reason:default

#include "qpointingdevice.h"

#include "qpointingdevice_p.h"

#include "qwindowsysteminterface_p.h"

#include "qeventpoint_p.h"

#include <QList>

#include <QLoggingCategory>

#include <QMutex>

#include <QCoreApplication>

#include <private/qdebug_p.h>

QT_BEGIN_NAMESPACE

using namespace Qt::StringLiterals;

Q_LOGGING_CATEGORY(lcPointerGrab, "qt.pointer.grab");

/*!

    \class QPointingDevice

    \brief The QPointingDevice class describes a device from which mouse, touch or tablet events originate.

    \since 6.0

    \ingroup events

    \inmodule QtGui

    Each QPointerEvent contains a QPointingDevice pointer to allow accessing

    device-specific properties like type and capabilities. It is the

    responsibility of the platform or generic plug-ins to register the

    available pointing devices via QWindowSystemInterface before generating any

    pointer events. Applications do not need to instantiate this class, they

    should just access the global instances pointed to by QPointerEvent::device().

*/

/*! \enum QInputDevice::DeviceType

    This enum represents the type of device that generated a QPointerEvent.

    \value Unknown

        The device cannot be identified.

    \value Mouse

        A mouse.

    \value TouchScreen

        In this type of device, the touch surface and display are integrated.

        This means the surface and display typically have the same size, such

        that there is a direct relationship between the touch points' physical

        positions and the coordinate reported by QEventPoint. As a

        result, Qt allows the user to interact directly with multiple QWidgets,

        QGraphicsItems, or Qt Quick Items at the same time.

    \value TouchPad

        In this type of device, the touch surface is separate from the display.

        There is not a direct relationship between the physical touch location

        and the on-screen coordinates. Instead, they are calculated relative to

        the current mouse position, and the user must use the touch-pad to move

        this reference point. Unlike touch-screens, Qt allows users to only

        interact with a single QWidget or QGraphicsItem at a time.

    \value Stylus

        A pen-like device used on a graphics tablet such as a Wacom tablet,

        or on a touchscreen that provides a separate stylus sensing capability.

    \value Airbrush

        A stylus with a thumbwheel to adjust

        \l {QTabletEvent::tangentialPressure}{tangentialPressure}.

    \value Puck

        A device that is similar to a flat mouse with a transparent circle with

        cross-hairs.

    \value Keyboard

        A keyboard.

    \value AllDevices

        Any of the above (used as a default filter value).

*/

/*! \enum QPointingDevice::PointerType

    This enum represents what is interacting with the pointing device.

    There is some redundancy between this property and \l {QInputDevice::DeviceType}.

    For example, if a touchscreen is used, then the \c DeviceType is

    \c TouchScreen and \c PointerType is \c Finger (always). But on a graphics

    tablet, it's often possible for both ends of the stylus to be used, and

    programs need to distinguish them. Therefore the concept is extended so

    that every QPointerEvent has a PointerType, and it can simplify some event

    handling code to ignore the DeviceType and react differently depending on

    the PointerType alone.

    Valid values are:

    \value Unknown

        The pointer type is unknown.

    \value Generic

        A mouse or something acting like a mouse (the core pointer on X11).

    \value Finger

        The user's finger.

    \value Pen

        The drawing end of a stylus.

    \value Eraser

        The other end of the stylus (if it has a virtual eraser on the other end).

    \value Cursor

        A transparent circle with cross-hairs as found on a

        \l {QInputDevice::DeviceType}{Puck} device.

    \value AllPointerTypes

        Any of the above (used as a default filter value).

*/

/*! \enum QPointingDevice::GrabTransition

    This enum represents a transition of exclusive or passive grab

    from one object (possibly \c nullptr) to another (possibly \c nullptr).

    It is emitted as an argument of the QPointingDevice::grabChanged() signal.

    Valid values are:

    \value GrabExclusive

        Emitted after QPointerEvent::setExclusiveGrabber().

    \value UngrabExclusive

        Emitted after QPointerEvent::setExclusiveGrabber() when the grabber is

        set to \c nullptr, to notify that the grab has terminated normally.

    \value CancelGrabExclusive

        Emitted after QPointerEvent::setExclusiveGrabber() when the grabber is set

        to a different object, to notify that the old grabber's grab is "stolen".

    \value GrabPassive

        Emitted after QPointerEvent::addPassiveGrabber().

    \value UngrabPassive

        Emitted when a passive grab is terminated normally,

        for example after QPointerEvent::removePassiveGrabber().

    \value CancelGrabPassive

        Emitted when a passive grab is terminated abnormally (a gesture is canceled).

    \value OverrideGrabPassive

        This value is not currently used.

*/

/*! \fn void QPointingDevice::grabChanged(QObject *grabber, QPointingDevice::GrabTransition transition, const QPointerEvent *event, const QEventPoint &point) const

    This signal is emitted when the \a grabber object gains or loses an

    exclusive or passive grab of \a point during delivery of \a event.

    The \a transition tells what happened, from the perspective of the

    \c grabber object.

    \note A grab transition from one object to another results in two signals,

    to notify that one object has lost its grab, and to notify that there is

    another grabber. In other cases, when transitioning to or from a non-grabbing

    state, only one signal is emitted: the \a grabber argument is never \c nullptr.

    \sa QPointerEvent::setExclusiveGrabber(), QPointerEvent::addPassiveGrabber(), QPointerEvent::removePassiveGrabber()

*/

/*!

    Creates a new invalid pointing device instance as a child of \a parent.

*/

QPointingDevice::QPointingDevice(QObject *parent)

    : QInputDevice(*(new QPointingDevicePrivate("unknown"_L1, -1,

                                              DeviceType::Unknown, PointerType::Unknown,

                                              Capability::None, 0, 0)), parent)

{

}

QPointingDevice::~QPointingDevice()

{

}

/*!

    Creates a new pointing device instance with the given

    \a name, \a deviceType, \a pointerType, \a capabilities, \a maxPoints,

    \a buttonCount, \a seatName, \a uniqueId and \a parent.

*/

QPointingDevice::QPointingDevice(const QString &name, qint64 id, QInputDevice::DeviceType deviceType,

                                 QPointingDevice::PointerType pointerType, Capabilities capabilities, int maxPoints, int buttonCount,

                                 const QString &seatName, QPointingDeviceUniqueId uniqueId, QObject *parent)

    : QInputDevice(*(new QPointingDevicePrivate(name, id, deviceType, pointerType, capabilities, maxPoints, buttonCount, seatName, uniqueId)), parent)

{

}

/*!

    \internal

*/

QPointingDevice::QPointingDevice(QPointingDevicePrivate &d, QObject *parent)

    : QInputDevice(d, parent)

{

}

#if QT_DEPRECATED_SINCE(6, 0)

/*!

    \internal

    \deprecated [6.0] Please use the constructor rather than setters.

    Sets the device type \a devType and infers the pointer type.

*/

void QPointingDevice::setType(DeviceType devType)

{

    Q_D(QPointingDevice);

    d->deviceType = devType;

    if (d->pointerType == PointerType::Unknown)

        switch (devType) {

        case DeviceType::Mouse:

            d->pointerType = PointerType::Generic;

            break;

        case DeviceType::TouchScreen:

        case DeviceType::TouchPad:

            d->pointerType = PointerType::Finger;

            break;

        case DeviceType::Puck:

            d->pointerType = PointerType::Cursor;

            break;

        case DeviceType::Stylus:

        case DeviceType::Airbrush:

            d->pointerType = PointerType::Pen;

            break;

        default:

            break;

        }

}

/*!

    \internal

    \deprecated [6.0] Please use the constructor rather than setters.

*/

void QPointingDevice::setCapabilities(QInputDevice::Capabilities caps)

{

    Q_D(QPointingDevice);

    d->setCapabilities(caps);

}

/*!

    \internal

    \deprecated [6.0] Please use the constructor rather than setters.

*/

void QPointingDevice::setMaximumTouchPoints(int c)

{

    Q_D(QPointingDevice);

    d->maximumTouchPoints = c;

}

#endif // QT_DEPRECATED_SINCE(6, 0)

/*!

    \property QPointingDevice::pointerType

    \brief the pointer type

*/

/*!

    Returns the pointer type.

*/

QPointingDevice::PointerType QPointingDevice::pointerType() const

{

    Q_D(const QPointingDevice);

    return d->pointerType;

}

/*!

    \property QPointingDevice::maximumPoints

    \brief the maximum number of simultaneous touch points (fingers) that

    can be detected

*/

/*!

    Returns the maximum number of simultaneous touch points (fingers) that

    can be detected.

*/

int QPointingDevice::maximumPoints() const

{

    Q_D(const QPointingDevice);

    return d->maximumTouchPoints;

}

/*!

    \property QPointingDevice::buttonCount

    \brief the maximum number of on-device buttons that can be detected

*/

/*!

    Returns the maximum number of on-device buttons that can be detected.

*/

int QPointingDevice::buttonCount() const

{

    Q_D(const QPointingDevice);

    return d->buttonCount;

}

/*!

    \property QPointingDevice::uniqueId

    \brief a unique ID (of dubious utility) for the device

    You probably should rather be concerned with QPointerEventPoint::uniqueId().

*/

/*!

    Returns a unique ID (of dubious utility) for the device.

    You probably should rather be concerned with QPointerEventPoint::uniqueId().

*/

QPointingDeviceUniqueId QPointingDevice::uniqueId() const

{

    Q_D(const QPointingDevice);

    return d->uniqueId;

}

/*!

    Returns the primary pointing device (the core pointer, traditionally

    assumed to be a mouse) on the given seat \a seatName.

    If multiple pointing devices are registered, this function prefers a mouse

    or touchpad that matches the given \a seatName and that does not have

    another device as its parent. Usually only one master or core device does

    not have a parent device. But if such a device is not found, this function

    creates a new virtual "core pointer" mouse. Thus Qt continues to work on

    platforms that are not yet doing input device discovery and registration.

*/

const QPointingDevice *QPointingDevice::primaryPointingDevice(const QString& seatName)

{

    const auto v = devices();

    const QPointingDevice *mouse = nullptr;

    const QPointingDevice *touchpad = nullptr;

    for (const QInputDevice *dev : v) {

        if (!seatName.isNull() && dev->seatName() != seatName)

            continue;

        if (dev->type() == QInputDevice::DeviceType::Mouse) {

            if (!mouse)

                mouse = static_cast<const QPointingDevice *>(dev);

            // the core pointer is likely a mouse, and its parent is not another input device

            if (!mouse->parent() || !qobject_cast<const QInputDevice *>(mouse->parent()))

                return mouse;

        } else if (dev->type() == QInputDevice::DeviceType::TouchPad) {

            if (!touchpad || !dev->parent() || dev->parent()->metaObject() != dev->metaObject())

                touchpad = static_cast<const QPointingDevice *>(dev);

        }

    }

    if (!mouse && !touchpad) {

        qCDebug(lcQpaInputDevices) << "no mouse-like devices registered for seat" << seatName

                                   << "The platform plugin should have provided one via "

                                      "QWindowSystemInterface::registerInputDevice(). Creating a default mouse for now.";

        mouse = new QPointingDevice("core pointer"_L1, 1, DeviceType::Mouse,

                                    PointerType::Generic, Capability::Position, 1, 3, seatName,

                                    QPointingDeviceUniqueId(), QCoreApplication::instance());

        QInputDevicePrivate::registerDevice(mouse);

        return mouse;

    }

    if (v.size() > 1)

        qCDebug(lcQpaInputDevices) << "core pointer ambiguous for seat" << seatName;

    if (mouse)

        return mouse;

    return touchpad;

}

QPointingDevicePrivate::~QPointingDevicePrivate()

    = default;

/*!

    \internal

    Finds the device instance belonging to the drawing or eraser end of a particular stylus,

    identified by its \a deviceType, \a pointerType, \a uniqueId and \a systemId.

    Returns the device found, or \c nullptr if none was found.

    If \a systemId is \c 0, it's not significant for the search.

    If an instance matching the given \a deviceType and \a pointerType but with

    only a default-constructed \c uniqueId is found, it will be assumed to be

    the one we're looking for, its \c uniqueId will be updated to match the

    given \a uniqueId, and its \c capabilities will be updated to match the

    given \a capabilities. This is for the benefit of any platform plugin that can

    discover the tablet itself at startup, along with the supported stylus types,

    but then discovers specific styli later on as they come into proximity.

*/

const QPointingDevice *QPointingDevicePrivate::queryTabletDevice(QInputDevice::DeviceType deviceType,

                                                                 QPointingDevice::PointerType pointerType,

                                                                 QPointingDeviceUniqueId uniqueId,

                                                                 QPointingDevice::Capabilities capabilities,

                                                                 qint64 systemId)

{

    const auto &devices = QInputDevice::devices();

    for (const QInputDevice *dev : devices) {

        if (dev->type() < QPointingDevice::DeviceType::Puck || dev->type() > QPointingDevice::DeviceType::Airbrush)

            continue;

        const QPointingDevice *pdev = static_cast<const QPointingDevice *>(dev);

        const auto devPriv = QPointingDevicePrivate::get(pdev);

        bool uniqueIdDiscovered = (devPriv->uniqueId.numericId() == 0 && uniqueId.numericId() != 0);

        if (devPriv->deviceType == deviceType && devPriv->pointerType == pointerType &&

                (!systemId || devPriv->systemId == systemId) &&

                (devPriv->uniqueId == uniqueId || uniqueIdDiscovered)) {

            if (uniqueIdDiscovered) {

                const_cast<QPointingDevicePrivate *>(devPriv)->uniqueId = uniqueId;

                if (capabilities)

                    const_cast<QPointingDevicePrivate *>(devPriv)->capabilities = capabilities;

                qCDebug(lcQpaInputDevices) << "discovered unique ID and capabilities of tablet tool" << pdev;

            }

            return pdev;

        }

    }

    return nullptr;

}

/*!

    \internal

    Finds the device instance identified by its \a systemId.

    Returns the device found, or \c nullptr if none was found.

*/

const QPointingDevice *QPointingDevicePrivate::pointingDeviceById(qint64 systemId)

{

    const auto &devices = QInputDevice::devices();

    for (const QInputDevice *dev : devices) {

        if (dev->type() >= QPointingDevice::DeviceType::Keyboard)

            continue;

        const QPointingDevice *pdev = static_cast<const QPointingDevice *>(dev);

        const auto devPriv = QPointingDevicePrivate::get(pdev);

        if (devPriv->systemId == systemId)

            return pdev;

    }

    return nullptr;

}

/*!

    \internal

    First, ensure that the \a cancelEvent's QTouchEvent::points() list contains

    all points that have exclusive grabs. Then send the event to each object

    that has an exclusive grab of any of the points.

*/

void QPointingDevicePrivate::sendTouchCancelEvent(QTouchEvent *cancelEvent)

{

    // An incoming TouchCancel event will typically not contain any points, but

    // QQuickPointerHandler::onGrabChanged needs to be called for each point

    // that has an exclusive grabber. Adding those points to the event makes it

    // an easy iteration there.

    if (cancelEvent->points().isEmpty()) {

        for (auto &epd : activePoints.values()) {

            if (epd.exclusiveGrabber)

                QMutableTouchEvent::addPoint(cancelEvent, epd.eventPoint);

        }

    }

    for (auto &epd : activePoints.values()) {

        if (epd.exclusiveGrabber)

            QCoreApplication::sendEvent(epd.exclusiveGrabber, cancelEvent);

        // The next touch event can only be a TouchBegin, so clean up.

        cancelEvent->setExclusiveGrabber(epd.eventPoint, nullptr);

        cancelEvent->clearPassiveGrabbers(epd.eventPoint);

    }

}

/*! \internal

    Returns the active EventPointData instance with the given \a id, if available,

    or \c nullptr if not.

*/

QPointingDevicePrivate::EventPointData *QPointingDevicePrivate::queryPointById(int id) const

{

    auto it = activePoints.find(id);

    if (it == activePoints.end())

        return nullptr;

    return &it.value();

}

/*! \internal

    Returns the active EventPointData instance with the given \a id, if available;

    if not, appends a new instance and returns it.

*/

QPointingDevicePrivate::EventPointData *QPointingDevicePrivate::pointById(int id) const

{

    const auto [it, inserted] = activePoints.try_emplace(id);

    if (inserted) {

        Q_Q(const QPointingDevice);

        auto &epd = it.value();

        QMutableEventPoint::setId(epd.eventPoint, id);

        QMutableEventPoint::setDevice(epd.eventPoint, q);

    }

    return &it.value();

}

/*! \internal

    Remove the active EventPointData instance with the given \a id.

*/

void QPointingDevicePrivate::removePointById(int id)

{

    activePoints.remove(id);

}

/*!

    \internal

    Find the first non-null target (widget) via QMutableEventPoint::target()

    in the active points. This is the widget that will receive any event that

    comes from a touchpad, even if some of the touchpoints fall spatially on

    other windows.

*/

QObject *QPointingDevicePrivate::firstActiveTarget() const

{

    for (auto &pt : activePoints.values()) {

        if (auto target = QMutableEventPoint::target(pt.eventPoint))

            return target;

    }

    return nullptr;

}

/*! \internal

    Find the first non-null QWindow instance via QMutableEventPoint::window()

    in the active points. This is the window that will receive any event that

    comes from a touchpad, even if some of the touchpoints fall spatially on

    other windows.

*/

QWindow *QPointingDevicePrivate::firstActiveWindow() const

{

    for (auto &pt : activePoints.values()) {

        if (auto window = QMutableEventPoint::window(pt.eventPoint))

            return window;

    }

    return nullptr;

}

/*! \internal

    Return the exclusive grabber of the first point in activePoints.

    This is mainly for autotests that try to verify the "current" grabber

    outside the context of event delivery, which is something that the rest

    of the codebase should not be doing.

*/

QObject *QPointingDevicePrivate::firstPointExclusiveGrabber() const

{

    if (activePoints.isEmpty())

        return nullptr;

    return activePoints.values().first().exclusiveGrabber;

}

void QPointingDevicePrivate::setExclusiveGrabber(const QPointerEvent *event, const QEventPoint &point, QObject *exclusiveGrabber)

{

    Q_Q(QPointingDevice);

    auto persistentPoint = queryPointById(point.id());

    if (!persistentPoint) {

        qWarning() << "point is not in activePoints" << point;

        return;

    }

    Q_ASSERT(persistentPoint->eventPoint.id() == point.id());

    if (persistentPoint->exclusiveGrabber == exclusiveGrabber)

        return;

    auto oldGrabber = persistentPoint->exclusiveGrabber;

    persistentPoint->exclusiveGrabber = exclusiveGrabber;

    if (oldGrabber)

        emit q->grabChanged(oldGrabber, exclusiveGrabber ? QPointingDevice::CancelGrabExclusive : QPointingDevice::UngrabExclusive,

                            event, persistentPoint->eventPoint);

    if (Q_UNLIKELY(lcPointerGrab().isDebugEnabled())) {

        qCDebug(lcPointerGrab) << name << "point" << point.id() << point.state()

                               << "@" << point.scenePosition()

                               << ": grab" << oldGrabber << "->" << exclusiveGrabber;

    }

    QMutableEventPoint::setGlobalGrabPosition(persistentPoint->eventPoint, point.globalPosition());

    if (exclusiveGrabber)

        emit q->grabChanged(exclusiveGrabber, QPointingDevice::GrabExclusive, event, point);

    else

        persistentPoint->exclusiveGrabberContext.clear();

}

/*!

    \internal

    Call QEventPoint::setExclusiveGrabber(nullptr) on each active point that has a grabber.

*/

bool QPointingDevicePrivate::removeExclusiveGrabber(const QPointerEvent *event, const QObject *grabber)

{

    bool ret = false;

    for (auto &pt : activePoints.values()) {

        if (pt.exclusiveGrabber == grabber) {

            setExclusiveGrabber(event, pt.eventPoint, nullptr);

            ret = true;

        }

    }

    return ret;

}

bool QPointingDevicePrivate::addPassiveGrabber(const QPointerEvent *event, const QEventPoint &point, QObject *grabber)

{

    Q_Q(QPointingDevice);

    auto persistentPoint = queryPointById(point.id());

    if (!persistentPoint) {

        qWarning() << "point is not in activePoints" << point;

        return false;

    }

    if (persistentPoint->passiveGrabbers.contains(grabber))

        return false;

    if (Q_UNLIKELY(lcPointerGrab().isDebugEnabled())) {

        qCDebug(lcPointerGrab) << name << "point" << point.id() << point.state()

                               << ": grab (passive)" << grabber;

    }

    persistentPoint->passiveGrabbers << grabber;

    emit q->grabChanged(grabber, QPointingDevice::GrabPassive, event, point);

    return true;

}

bool QPointingDevicePrivate::setPassiveGrabberContext(QPointingDevicePrivate::EventPointData *epd, QObject *grabber, QObject *context)

{

    qsizetype i = epd->passiveGrabbers.indexOf(grabber);

    if (i < 0)

        return false;

    if (epd->passiveGrabbersContext.size() <= i)

        epd->passiveGrabbersContext.resize(i + 1);

    epd->passiveGrabbersContext[i] = context;

    return true;

}

bool QPointingDevicePrivate::removePassiveGrabber(const QPointerEvent *event, const QEventPoint &point, QObject *grabber)

{

    Q_Q(QPointingDevice);

    auto persistentPoint = queryPointById(point.id());

    if (!persistentPoint) {

        qWarning() << "point is not in activePoints" << point;

        return false;

    }

    qsizetype i = persistentPoint->passiveGrabbers.indexOf(grabber);

    if (i >= 0) {

        if (Q_UNLIKELY(lcPointerGrab().isDebugEnabled())) {

            qCDebug(lcPointerGrab) << name << "point" << point.id() << point.state()

                                   << ": removing passive grabber" << grabber;

        }

        emit q->grabChanged(grabber, QPointingDevice::UngrabPassive, event, point);

        persistentPoint->passiveGrabbers.removeAt(i);

        if (persistentPoint->passiveGrabbersContext.size()) {

            Q_ASSERT(persistentPoint->passiveGrabbersContext.size() > i);

            persistentPoint->passiveGrabbersContext.removeAt(i);

        }

        return true;

    }

    return false;

}

void QPointingDevicePrivate::clearPassiveGrabbers(const QPointerEvent *event, const QEventPoint &point)

{

    Q_Q(QPointingDevice);

    auto persistentPoint = queryPointById(point.id());

    if (!persistentPoint) {

        qWarning() << "point is not in activePoints" << point;

        return;

    }

    if (persistentPoint->passiveGrabbers.isEmpty())

        return;

    if (Q_UNLIKELY(lcPointerGrab().isDebugEnabled())) {

        qCDebug(lcPointerGrab) << name << "point" << point.id() << point.state()

                               << ": clearing" << persistentPoint->passiveGrabbers;

    }

    for (auto g : persistentPoint->passiveGrabbers)

        emit q->grabChanged(g, QPointingDevice::UngrabPassive, event, point);

    persistentPoint->passiveGrabbers.clear();

    persistentPoint->passiveGrabbersContext.clear();

}

/*!

    \internal

    Removes the given \a grabber as both passive and exclusive grabber from all

    points in activePoints where it's currently found. If \a cancel is \c true,

    the transition emitted from the grabChanged() signal will be

    \c CancelGrabExclusive or \c CancelGrabPassive. Otherwise it will be

    \c UngrabExclusive or \c UngrabPassive.

    \note This function provides a way to work around the limitation that we

    normally change grabbers only during event delivery; but it's also more expensive.

*/

void QPointingDevicePrivate::removeGrabber(QObject *grabber, bool cancel)

{

    Q_Q(QPointingDevice);

    for (auto ap : activePoints) {

        auto &epd = ap.second;

        if (epd.exclusiveGrabber.data() == grabber) {

            qCDebug(lcPointerGrab) << name << "point" << epd.eventPoint.id() << epd.eventPoint.state()

                                   << "@" << epd.eventPoint.scenePosition()

                                   << ": grab" << grabber << "-> nullptr";

            epd.exclusiveGrabber.clear();

            epd.exclusiveGrabberContext.clear();

            emit q->grabChanged(grabber,

                                cancel ? QPointingDevice::CancelGrabExclusive : QPointingDevice::UngrabExclusive,

                                nullptr, epd.eventPoint);

        }

        qsizetype pi = epd.passiveGrabbers.indexOf(grabber);

        if (pi >= 0) {

            qCDebug(lcPointerGrab) << name << "point" << epd.eventPoint.id() << epd.eventPoint.state()

                                   << ": removing passive grabber" << grabber;

            epd.passiveGrabbers.removeAt(pi);

            if (epd.passiveGrabbersContext.size()) {

                Q_ASSERT(epd.passiveGrabbersContext.size() > pi);

                epd.passiveGrabbersContext.removeAt(pi);

            }

            emit q->grabChanged(grabber,

                                cancel ? QPointingDevice::CancelGrabPassive : QPointingDevice::UngrabPassive,

                                nullptr, epd.eventPoint);

        }

    }

}

/*!

    \internal

    Finds the device instance belonging to the drawing or eraser end of a particular stylus,

    identified by its \a deviceType, \a pointerType and \a uniqueId. If an existing device

    is not found, a new one is created and registered, with a warning.

    This function is called from QWindowSystemInterface. Platform plugins should use

    \l queryTabletDeviceInstance() to check whether a tablet stylus coming into proximity

    is previously known; if not known, the plugin should create and register the stylus.

*/

const QPointingDevice *QPointingDevicePrivate::tabletDevice(QInputDevice::DeviceType deviceType,

                                                            QPointingDevice::PointerType pointerType,

                                                            QPointingDeviceUniqueId uniqueId)

{

    const QPointingDevice *dev = queryTabletDevice(deviceType, pointerType, uniqueId);

    if (!dev) {

        qCDebug(lcQpaInputDevices) << "failed to find registered tablet device"

                                   << deviceType << pointerType << Qt::hex << uniqueId.numericId()

                                   << "The platform plugin should have provided one via "

                                      "QWindowSystemInterface::registerInputDevice(). Creating a default one for now.";

        dev = new QPointingDevice("fake tablet"_L1, 2, deviceType, pointerType,

                                  QInputDevice::Capability::Position | QInputDevice::Capability::Pressure,

                                  1, 1, QString(), uniqueId, QCoreApplication::instance());

        QInputDevicePrivate::registerDevice(dev);

    }

    return dev;

}

bool QPointingDevice::operator==(const QPointingDevice &other) const

{

    // Wacom tablets generate separate instances for each end of each stylus;

    // QInputDevice::operator==() says they are all the same, but we use

    // the stylus unique serial number and pointerType to distinguish them

    return QInputDevice::operator==(other) &&

            pointerType() == other.pointerType() &&

            uniqueId() == other.uniqueId();

}

#ifndef QT_NO_DEBUG_STREAM

QDebug operator<<(QDebug debug, const QPointingDevice *device)

{

    QDebugStateSaver saver(debug);

    debug.nospace();

    debug.noquote();

    debug << "QPointingDevice(";

    if (device) {

        debug << '"' << device->name() << "\" ";

        QtDebugUtils::formatQEnum(debug, device->type());

        debug << " id=" << device->systemId();

        if (!device->seatName().isEmpty())

            debug << " seat=" << device->seatName();

        if (device->pointerType() != QPointingDevice::PointerType::Generic) {

            debug << " ptrType=";

            QtDebugUtils::formatQEnum(debug, device->pointerType());

        }

        if (int(device->capabilities()) != int(QInputDevice::Capability::Position)) {

            debug << " caps=";

            QtDebugUtils::formatQFlags(debug, device->capabilities());

        }

        if (device->buttonCount() > 0)

            debug << " buttonCount=" << device->buttonCount();

        if (device->maximumPoints() > 1)

            debug << " maxPts=" << device->maximumPoints();

        if (device->uniqueId().isValid())

            debug << " uniqueId=" << Qt::hex << device->uniqueId().numericId() << Qt::dec;

    } else {

        debug << "0x0";

    }

    debug << ')';

    return debug;

}

#endif // !QT_NO_DEBUG_STREAM

/*!

    \class QPointingDeviceUniqueId

    \since 5.8

    \ingroup events

    \inmodule QtGui

    \brief QPointingDeviceUniqueId identifies a unique object, such as a tagged token

    or stylus, which is used with a pointing device.

    QPointingDeviceUniqueIds can be compared for equality, and can be used as keys in a QHash.

    You get access to the numerical ID via numericId(), if the device supports such IDs.

    For future extensions, though, you should not use that function, but compare objects

    of this type using the equality operator.

    This class is a thin wrapper around an integer ID. You pass it into and out of

    functions by value.

    \sa QEventPoint

*/

/*!

    \fn QPointingDeviceUniqueId::QPointingDeviceUniqueId()

    Constructs an invalid unique pointer ID.

*/

/*!

    Constructs a unique pointer ID from numeric ID \a id.

*/

QPointingDeviceUniqueId QPointingDeviceUniqueId::fromNumericId(qint64 id)

{

    QPointingDeviceUniqueId result;

    result.m_numericId = id;

    return result;

}

/*!

    \fn bool QPointingDeviceUniqueId::isValid() const

    Returns whether this unique pointer ID is valid, that is, it represents an actual

    pointer.

*/

/*!

    \property QPointingDeviceUniqueId::numericId

    \brief the numeric unique ID of the token represented by a touchpoint

    If the device provides a numeric ID, isValid() returns true, and this

    property provides the numeric ID;

    otherwise it is -1.

    You should not use the value of this property in portable code, but

    instead rely on equality to identify pointers.

    \sa isValid()

*/

qint64 QPointingDeviceUniqueId::numericId() const noexcept

{

    return m_numericId;

}

/*!

    \fn bool QPointingDeviceUniqueId::operator==(QPointingDeviceUniqueId lhs, QPointingDeviceUniqueId rhs)

    \since 5.8

    Returns whether the two unique pointer IDs \a lhs and \a rhs identify the same pointer

    (\c true) or not (\c false).

*/

/*!

    \fn bool QPointingDeviceUniqueId::operator!=(QPointingDeviceUniqueId lhs, QPointingDeviceUniqueId rhs)

    \since 5.8

    Returns whether the two unique pointer IDs \a lhs and \a rhs identify different pointers

    (\c true) or not (\c false).

*/

/*!

    \qhashold{QPointingDeviceUniqueId}

    \since 5.8

*/

size_t qHash(QPointingDeviceUniqueId key, size_t seed) noexcept

{

    return qHash(key.numericId(), seed);

}

QT_END_NAMESPACE

#include "moc_qpointingdevice.cpp"