qeventpoint.cpp

Go to the documentation of this file.

// 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
 
#include "qeventpoint.h"
#include "private/qeventpoint_p.h"
#include "private/qpointingdevice_p.h"
 
QT_BEGIN_NAMESPACE
 
Q_LOGGING_CATEGORY(lcPointerVel, "qt.pointer.velocity")
Q_LOGGING_CATEGORY(lcEPDetach, "qt.pointer.eventpoint.detach")
 
QT_DEFINE_QESDP_SPECIALIZATION_DTOR(QEventPointPrivate)
 
QEventPoint::QEventPoint(int id, const QPointingDevice *device)
    : d(new QEventPointPrivate(id, device)) {}
 
QEventPoint::QEventPoint(int pointId, State state, const QPointF &scenePosition, const QPointF &globalPosition)
    : d(new QEventPointPrivate(pointId, state, scenePosition, globalPosition)) {}
 
QEventPoint::QEventPoint(const QEventPoint &other) noexcept = default;
 
QEventPoint &QEventPoint::operator=(const QEventPoint &other) noexcept = default;
 
bool QEventPoint::operator==(const QEventPoint &other) const noexcept
{
    if (d == other.d)
        return true;
    if (!d || !other.d)
        return false;
    return *d == *other.d;
}
 
QEventPoint::~QEventPoint() = default;
 
QPointF QEventPoint::position() const
{ return d ? d->pos : QPointF(); }
 
QPointF QEventPoint::pressPosition() const
{ return d ? d->globalPressPos - d->globalPos + d->pos : QPointF(); }
 
QPointF QEventPoint::grabPosition() const
{ return d ? d->globalGrabPos - d->globalPos + d->pos : QPointF(); }
 
QPointF QEventPoint::lastPosition() const
{ return d ? d->globalLastPos - d->globalPos + d->pos : QPointF(); }
 
QPointF QEventPoint::scenePosition() const
{ return d ? d->scenePos : QPointF(); }
 
QPointF QEventPoint::scenePressPosition() const
{ return d ? d->globalPressPos - d->globalPos + d->scenePos : QPointF(); }
 
QPointF QEventPoint::sceneGrabPosition() const
{ return d ? d->globalGrabPos - d->globalPos + d->scenePos : QPointF(); }
 
QPointF QEventPoint::sceneLastPosition() const
{ return d ? d->globalLastPos - d->globalPos + d->scenePos : QPointF(); }
 
QPointF QEventPoint::globalPosition() const
{ return d ? d->globalPos : QPointF(); }
 
QPointF QEventPoint::globalPressPosition() const
{ return d ? d->globalPressPos : QPointF(); }
 
QPointF QEventPoint::globalGrabPosition() const
{ return d ? d->globalGrabPos : QPointF(); }
 
QPointF QEventPoint::globalLastPosition() const
{ return d ? d->globalLastPos : QPointF(); }
 
QVector2D QEventPoint::velocity() const
{ return d ? d->velocity : QVector2D(); }
 
QEventPoint::State QEventPoint::state() const
{ return d ? d->state : QEventPoint::State::Unknown; }
 
const QPointingDevice *QEventPoint::device() const
{ return d ? d->device : nullptr; }
 
int QEventPoint::id() const
{ return d ? d->pointId : -1; }
 
QPointingDeviceUniqueId QEventPoint::uniqueId() const
{ return d ? d->uniqueId : QPointingDeviceUniqueId(); }
 
ulong QEventPoint::timestamp() const
{ return d ? d->timestamp : 0; }
 
ulong QEventPoint::lastTimestamp() const
{ return d ? d->lastTimestamp : 0; }
 
ulong QEventPoint::pressTimestamp() const
{ return d ? d->pressTimestamp : 0; }
 
qreal QEventPoint::timeHeld() const
{ return d ? (d->timestamp - d->pressTimestamp) / qreal(1000) : 0.0; }
 
qreal QEventPoint::pressure() const
{ return d ? d->pressure : 0.0; }
 
qreal QEventPoint::rotation() const
{ return d ? d->rotation : 0.0; }
 
QSizeF QEventPoint::ellipseDiameters() const
{ return d ? d->ellipseDiameters : QSizeF(); }
 
void QEventPoint::setAccepted(bool accepted)
{
    if (d)
        d->accept = accepted;
}
 
bool QEventPoint::isAccepted() const
{ return d ? d->accept : false; }
 
 
QPointF QEventPoint::normalizedPosition() const
{
    if (!d)
        return {};
 
    auto geom = d->device->availableVirtualGeometry();
    if (geom.isNull())
        return QPointF();
    return (globalPosition() - geom.topLeft()) / geom.width();
}
 
#if QT_DEPRECATED_SINCE(6, 0)
QPointF QEventPoint::startNormalizedPos() const
{
    if (!d)
        return {};
 
    auto geom = d->device->availableVirtualGeometry();
    if (geom.isNull())
        return QPointF();
    return (globalPressPosition() - geom.topLeft()) / geom.width();
}
 
QPointF QEventPoint::lastNormalizedPos() const
{
    if (!d)
        return {};
 
    auto geom = d->device->availableVirtualGeometry();
    if (geom.isNull())
        return QPointF();
    return (globalLastPosition() - geom.topLeft()) / geom.width();
}
#endif // QT_DEPRECATED_SINCE(6, 0)
 
void QMutableEventPoint::detach(QEventPoint &p)
{
    if (p.d)
        p.d.detach();
    else
        p.d.reset(new QEventPointPrivate(-1, nullptr));
}
 
void QMutableEventPoint::update(const QEventPoint &other, QEventPoint &target)
{
    detach(target);
    setPressure(target, other.pressure());
 
    switch (other.state()) {
    case QEventPoint::State::Pressed:
        setGlobalPressPosition(target, other.globalPosition());
        setGlobalLastPosition(target, other.globalPosition());
        if (target.pressure() < 0)
            setPressure(target, 1);
        break;
 
    case QEventPoint::State::Released:
        if (target.globalPosition() != other.globalPosition())
            setGlobalLastPosition(target, target.globalPosition());
        setPressure(target, 0);
        break;
 
    default: // update or stationary
        if (target.globalPosition() != other.globalPosition())
            setGlobalLastPosition(target, target.globalPosition());
        if (target.pressure() < 0)
            setPressure(target, 1);
        break;
    }
 
    setState(target, other.state());
    setPosition(target, other.position());
    setScenePosition(target, other.scenePosition());
    setGlobalPosition(target, other.globalPosition());
    setEllipseDiameters(target, other.ellipseDiameters());
    setRotation(target, other.rotation());
    setVelocity(target, other.velocity());
}
 
void QMutableEventPoint::setTimestamp(QEventPoint &p, ulong t)
{
    // On mouse press, if the mouse has moved from its last-known location,
    // QGuiApplicationPrivate::processMouseEvent() sends first a mouse move and
    // then a press. Both events will get the same timestamp. So we need to set
    // the press timestamp and position even when the timestamp isn't advancing,
    // but skip setting lastTimestamp and velocity because those need a time delta.
    if (p.d) {
        if (p.state() == QEventPoint::State::Pressed) {
            p.d->pressTimestamp = t;
            p.d->globalPressPos = p.d->globalPos;
        }
        if (p.d->timestamp == t)
            return;
    }
    detach(p);
    if (p.device()) {
        // get the persistent instance out of QPointingDevicePrivate::activePoints
        // (which sometimes might be the same as this instance)
        QEventPointPrivate *pd = QPointingDevicePrivate::get(
                    const_cast<QPointingDevice *>(p.d->device))->pointById(p.id())->eventPoint.d.get();
        if (t > pd->timestamp) {
            pd->lastTimestamp = pd->timestamp;
            pd->timestamp = t;
            if (p.state() == QEventPoint::State::Pressed)
                pd->pressTimestamp = t;
            if (pd->lastTimestamp > 0 && !p.device()->capabilities().testFlag(QInputDevice::Capability::Velocity)) {
                // calculate instantaneous velocity according to time and distance moved since the previous point
                QVector2D newVelocity = QVector2D(pd->globalPos - pd->globalLastPos) / (t - pd->lastTimestamp) * 1000;
                // VERY simple kalman filter: does a weighted average
                // where the older velocities get less and less significant
                static const float KalmanGain = 0.7f;
                pd->velocity = newVelocity * KalmanGain + pd->velocity * (1.0f - KalmanGain);
                qCDebug(lcPointerVel) << "velocity" << newVelocity << "filtered" << pd->velocity <<
                                         "based on movement" << pd->globalLastPos << "->" << pd->globalPos <<
                                         "over time" << pd->lastTimestamp << "->" << pd->timestamp;
            }
            if (p.d != pd) {
                p.d->lastTimestamp = pd->lastTimestamp;
                p.d->velocity = pd->velocity;
            }
        }
    }
    p.d->timestamp = t;
}
 
QT_END_NAMESPACE
 
#include "moc_qeventpoint.cpp"