qt/qtgraphs/src/graphs3d/input/qgraphsinputhandler.cpp

Revision control

++ // Copyright (C) 2024 The Qt Company Ltd.
++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
++ // Qt-Security score:significant reason:default
++
++
++ #include "qgraphsinputhandler_p.h"
++
++ #include <QtQuick/private/qquickdraghandler_p.h>
++ #include <QtQuick/private/qquickpinchhandler_p.h>
++ #include <QtQuick/private/qquicktaphandler_p.h>
++ #include <QtQuick/private/qquickwheelhandler_p.h>
++
++ #include "qquickgraphsitem_p.h"
++ #include "qgraphs3dlogging_p.h"
++
++ QT_BEGIN_NAMESPACE
++
++ QGraphsInputHandler::QGraphsInputHandler(QQuickItem *parent)
++ : QQuickItem(parent)
++ , m_dragMode(QtGraphs3D::DragMode::Rotate)
++ , m_flags{true, true, true, true, true}
++ , m_pendingPoint(QPoint())
++ , m_pinchDiff(.0f)
++ , m_graphsItem(nullptr)
++ {
++ m_pinchHandler = new QQuickPinchHandler(this);
++ m_tapHandler = new QQuickTapHandler(this);
++
++ // This is to support QQuickGraphsItem's mouseMove signal.
++ setAcceptHoverEvents(true);
++ m_dragHandler = new QQuickDragHandler(this);
++ m_panHandler = new QQuickDragHandler(this);
++ m_wheelHandler = new QQuickWheelHandler(this);
++ m_dragHandler->setAcceptedButtons(Qt::MouseButton::RightButton);
++ m_panHandler->setAcceptedButtons(Qt::MouseButton::MiddleButton);
++ m_wheelHandler->setAcceptedDevices(QInputDevice::DeviceType::Mouse
++ | QInputDevice::DeviceType::TouchPad);
++ QObject::connect(m_tapHandler, &QQuickTapHandler::tapped, this, &QGraphsInputHandler::onTapped);
++ QObject::connect(m_dragHandler,
++ &QQuickDragHandler::translationChanged,
++ this,
++ &QGraphsInputHandler::onTranslationChanged);
++ QObject::connect(m_panHandler,
++ &QQuickDragHandler::translationChanged,
++ this,
++ &QGraphsInputHandler::onTranslationChanged);
++ QObject::connect(m_dragHandler,
++ &QQuickDragHandler::grabChanged,
++ this,
++ &QGraphsInputHandler::onGrabChanged);
++ QObject::connect(m_wheelHandler,
++ &QQuickWheelHandler::wheel,
++ this,
++ &QGraphsInputHandler::onWheel);
++ QObject::connect(m_pinchHandler,
++ &QQuickPinchHandler::scaleChanged,
++ this,
++ &QGraphsInputHandler::onPinchScaleChanged);
++ QObject::connect(m_pinchHandler,
++ &QQuickPinchHandler::grabChanged,
++ this,
++ &QGraphsInputHandler::onGrabChanged);
++ }
++
++ QGraphsInputHandler::~QGraphsInputHandler() {}
++
++ void QGraphsInputHandler::setZoomEnabled(bool enable)
++ {
++ if (m_flags.zoomEnabled == enable) {
++ qCDebug(lcProperties3D) << __FUNCTION__
++ << "value is already set to:" << enable;
++ return;
++ }
++ m_flags.zoomEnabled = enable;
++ if (m_graphsItem)
++ emit m_graphsItem->zoomEnabledChanged(enable);
++ }
++
++ bool QGraphsInputHandler::isZoomEnabled()
++ {
++ return m_flags.zoomEnabled;
++ }
++
++ void QGraphsInputHandler::setZoomAtTargetEnabled(bool enable)
++ {
++ if (m_flags.zoomAtTarget == enable) {
++ qCDebug(lcProperties3D) << __FUNCTION__
++ << "value is already set to:" << enable;
++ return;
++ }
++ m_flags.zoomAtTarget = enable;
++ if (m_graphsItem)
++ emit m_graphsItem->zoomAtTargetEnabledChanged(enable);
++ }
++
++ bool QGraphsInputHandler::isZoomAtTargetEnabled()
++ {
++ return m_flags.zoomAtTarget;
++ }
++
++ void QGraphsInputHandler::setRotationEnabled(bool enable)
++ {
++ if (m_flags.rotationEnabled == enable) {
++ qCDebug(lcProperties3D) << __FUNCTION__
++ << "value is already set to:" << enable;
++ }
++ m_flags.rotationEnabled = enable;
++ if (m_graphsItem)
++ emit m_graphsItem->rotationEnabledChanged(enable);
++ }
++
++ bool QGraphsInputHandler::isRotationEnabled()
++ {
++ return m_flags.rotationEnabled;
++ }
++
++ void QGraphsInputHandler::setPanEnabled(bool enable)
++ {
++ if (m_flags.panEnabled == enable) {
++ qCDebug(lcProperties3D) << __FUNCTION__
++ << "value is already set to:" << enable;
++ }
++ m_flags.panEnabled = enable;
++ if (m_graphsItem)
++ emit m_graphsItem->panEnabledChanged(enable);
++ }
++
++ bool QGraphsInputHandler::isPanEnabled()
++ {
++ return m_flags.panEnabled;
++ }
++
++ void QGraphsInputHandler::setDragMode(QtGraphs3D::DragMode mode)
++ {
++ if (m_dragMode == mode) {
++ qCDebug(lcProperties3D) << __FUNCTION__
++ << "value is already set to:" << mode;
++ }
++ m_dragMode = mode;
++ if (m_graphsItem)
++ emit m_graphsItem->dragModeChanged(mode);
++ }
++
++ QtGraphs3D::DragMode QGraphsInputHandler::dragMode()
++ {
++ return m_dragMode;
++ }
++
++ void QGraphsInputHandler::setSelectionEnabled(bool enable)
++ {
++ if (m_flags.selectionEnabled == enable) {
++ qCDebug(lcProperties3D) << __FUNCTION__
++ << "value is already set to:" << enable;
++ return;
++ }
++ m_flags.selectionEnabled = enable;
++ if (m_graphsItem)
++ emit m_graphsItem->selectionEnabledChanged(enable);
++ }
++
++ bool QGraphsInputHandler::isSelectionEnabled()
++ {
++ return m_flags.selectionEnabled;
++ }
++
++ void QGraphsInputHandler::setDefaultInputHandler()
++ {
++ setVisible(true);
++ }
++
++ void QGraphsInputHandler::unsetDefaultInputHandler()
++ {
++ setVisible(false);
++ }
++
++ void QGraphsInputHandler::unsetDefaultTapHandler()
++ {
++ QObject::disconnect(m_tapHandler,
++ &QQuickTapHandler::tapped,
++ this,
++ &QGraphsInputHandler::onTapped);
++ }
++
++ void QGraphsInputHandler::unsetDefaultDragHandler()
++ {
++ QObject::disconnect(m_dragHandler,
++ &QQuickDragHandler::translationChanged,
++ this,
++ &QGraphsInputHandler::onTranslationChanged);
++ }
++
++ void QGraphsInputHandler::unsetDefaultWheelHandler()
++ {
++ QObject::disconnect(m_wheelHandler,
++ &QQuickWheelHandler::wheel,
++ this,
++ &QGraphsInputHandler::onWheel);
++ }
++
++ void QGraphsInputHandler::unsetDefaultPinchHandler()
++ {
++ QObject::disconnect(m_pinchHandler,
++ &QQuickPinchHandler::scaleChanged,
++ this,
++ &QGraphsInputHandler::onPinchScaleChanged);
++ }
++
++ void QGraphsInputHandler::setDragButton(Qt::MouseButtons button)
++ {
++ m_dragHandler->setAcceptedButtons(button);
++ }
++
++ void QGraphsInputHandler::setPanButton(Qt::MouseButtons button)
++ {
++ m_panHandler->setAcceptedButtons(button);
++ }
++
++ void QGraphsInputHandler::setGraphsItem(QQuickGraphsItem *item)
++ {
++ m_graphsItem = item;
++ QObject::connect(m_tapHandler, &QQuickTapHandler::tapped, item, &QQuickGraphsItem::tapped);
++ QObject::connect(m_tapHandler,
++ &QQuickTapHandler::doubleTapped,
++ item,
++ &QQuickGraphsItem::doubleTapped);
++ QObject::connect(m_tapHandler,
++ &QQuickTapHandler::longPressed,
++ item,
++ &QQuickGraphsItem::longPressed);
++ QObject::connect(m_dragHandler,
++ &QQuickDragHandler::translationChanged,
++ item,
++ &QQuickGraphsItem::dragged);
++ QObject::connect(m_wheelHandler, &QQuickWheelHandler::wheel, item, &QQuickGraphsItem::wheel);
++ QObject::connect(m_pinchHandler,
++ &QQuickPinchHandler::scaleChanged,
++ item,
++ &QQuickGraphsItem::pinch);
++ QObject::connect(this, &QGraphsInputHandler::mouseMove, item, &QQuickGraphsItem::mouseMove);
++ }
++
++ void QGraphsInputHandler::onTapped()
++ {
++ if (!m_flags.selectionEnabled)
++ return;
++
++ if (m_graphsItem->isSlicingActive()) {
++ m_graphsItem->setSliceActivatedChanged(true);
++ m_graphsItem->update();
++ return;
++ }
++ m_graphsItem->doPicking(m_tapHandler->point().position());
++ }
++
++ void QGraphsInputHandler::onTranslationChanged(QVector2D delta)
++ {
++
++ bool dragButtons = m_dragHandler->centroid().pressedButtons().testAnyFlags(
++ m_dragHandler->acceptedButtons());
++
++ bool panButtons = m_panHandler->centroid().pressedButtons().testAnyFlags(
++ m_panHandler->acceptedButtons());
++
++ QQuickGraphsItem *item = m_graphsItem;
++ float xRotation = item->cameraXRotation();
++ float yRotation = item->cameraYRotation();
++
++ if (panButtons || (dragButtons && m_dragMode == QtGraphs3D::DragMode::Pan)) {
++ if (!m_flags.panEnabled)
++ return;
++
++ QVector3D camPos = item->cameraTargetPosition();
++ QVector3D diff = item->cameraTarget()->mapDirectionToScene({delta.x(), -delta.y(), 0});
++ float zoom = 1 / (item->cameraZoomLevel() / 100.0f);
++ item->setCameraTargetPosition(camPos - diff * zoom);
++
++ } else if (dragButtons && m_dragMode == QtGraphs3D::DragMode::Rotate) {
++ if (!m_flags.rotationEnabled)
++ return;
++
++ float rotationSpeed = 1.0f;
++ #if !defined(Q_OS_IOS)
++ rotationSpeed = 10.0f;
++ #endif
++ // Calculate mouse movement since last frame
++ // Apply to rotations
++ xRotation += (delta.x() / rotationSpeed);
++ yRotation += (delta.y() / rotationSpeed);
++ item->setCameraXRotation(xRotation);
++ item->setCameraYRotation(yRotation);
++ }
++ }
++
++ void QGraphsInputHandler::onGrabChanged(QPointingDevice::GrabTransition transition,
++ QEventPoint point)
++ {
++ static QPointF pickPoint;
++
++ if (transition == QPointingDevice::GrabPassive) {
++ pickPoint = point.position().toPoint();
++ } else if (transition == QPointingDevice::GrabExclusive) {
++ if (m_dragHandler->centroid().pressedButtons().testFlag(Qt::LeftButton))
++ m_graphsItem->doPicking(pickPoint);
++ } else if (transition == QPointingDevice::UngrabExclusive
++ || transition == QPointingDevice::UngrabPassive) {
++ setPosition(QPointF(.0f, .0f));
++ setScale(1.f);
++ setRotation(.0f);
++ emit m_graphsItem->selectedElementChanged(QtGraphs3D::ElementType::None);
++ pickPoint = QPointF();
++ }
++ }
++
++ void QGraphsInputHandler::onWheel(QQuickWheelEvent *event)
++ {
++ if (!m_flags.zoomEnabled) {
++ qCWarning(lcEvents3D, "%s zooming needs to be enabled",
++ qUtf8Printable(QLatin1String(__FUNCTION__)));
++ return;
++ }
++
++ int halfSizeZoomLevel = 50;
++ int oneToOneZoomLevel = 100;
++
++ int driftTowardCenterLevel = 175;
++ float wheelZoomDrift = 0.1f;
++
++ int nearZoomRangeDivider = 12;
++ int midZoomRangeDivider = 60;
++ int farZoomRangeDivider = 120;
++
++ if (m_graphsItem->isSlicingActive())
++ return;
++
++ // Adjust zoom level based on what zoom range we're in.
++ QQuickGraphsItem *item = m_graphsItem;
++ int zoomLevel = int(item->cameraZoomLevel());
++ const int minZoomLevel = int(item->minCameraZoomLevel());
++ const int maxZoomLevel = int(item->maxCameraZoomLevel());
++ if (zoomLevel > oneToOneZoomLevel)
++ zoomLevel += event->angleDelta().y() / nearZoomRangeDivider;
++ else if (zoomLevel > halfSizeZoomLevel)
++ zoomLevel += event->angleDelta().y() / midZoomRangeDivider;
++ else
++ zoomLevel += event->angleDelta().y() / farZoomRangeDivider;
++ zoomLevel = qBound(minZoomLevel, zoomLevel, maxZoomLevel);
++
++ if (m_flags.zoomAtTarget) {
++ QVector3D targetPosition = item->graphPositionAt(QPoint(event->x(), event->y()));
++ float previousZoom = item->cameraZoomLevel();
++ item->setCameraZoomLevel(zoomLevel);
++
++ float diffAdj = 0.0f;
++
++ // If zooming in/out outside the graph, or zooming out after certain point,
++ // move towards the center.
++ if ((qAbs(targetPosition.x()) > 2.0f || qAbs(targetPosition.y()) > 2.0f
++ || qAbs(targetPosition.z()) > 2.0f)
++ || (previousZoom > zoomLevel && zoomLevel <= driftTowardCenterLevel)) {
++ targetPosition = QVector3D();
++ // Add some extra correction so that we actually reach the center
++ // eventually
++ diffAdj = wheelZoomDrift;
++ if (previousZoom > zoomLevel)
++ diffAdj *= 2.0f; // Correct towards center little more when zooming out
++ }
++
++ float zoomFraction = 1.0f - (previousZoom / zoomLevel);
++
++ // Adjust camera towards the zoom point, attempting to keep the cursor at
++ // same graph point
++ QVector3D oldTarget = item->cameraTargetPosition();
++ QVector3D origDiff = targetPosition - oldTarget;
++ QVector3D diff = origDiff * zoomFraction + (origDiff.normalized() * diffAdj);
++ if (diff.length() > origDiff.length())
++ diff = origDiff;
++ item->setCameraTargetPosition(oldTarget + diff);
++ } else {
++ item->setCameraZoomLevel(zoomLevel);
++ }
++
++ item->update();
++ }
++
++ void QGraphsInputHandler::onPinchScaleChanged(qreal delta)
++ {
++ if (!m_flags.zoomEnabled) {
++ qCWarning(lcEvents3D, "%s zooming needs to be enabled",
++ qUtf8Printable(QLatin1String(__FUNCTION__)));
++ return;
++ }
++
++ m_pinchDiff += (delta - 1.0f);
++ int driftTowardCenterLevel = 175;
++ float wheelZoomDrift = 0.1f;
++
++ QQuickGraphsItem *item = m_graphsItem;
++ int zoomLevel = int(item->cameraZoomLevel());
++ const int minZoomLevel = int(item->minCameraZoomLevel());
++ const int maxZoomLevel = int(item->maxCameraZoomLevel());
++ float zoomRate = qSqrt(qSqrt(zoomLevel));
++ if (m_pinchDiff > .0f)
++ zoomLevel += zoomRate;
++ else
++ zoomLevel -= zoomRate;
++ zoomLevel = qBound(minZoomLevel, zoomLevel, maxZoomLevel);
++ if (m_flags.zoomAtTarget) {
++ QVector3D targetPosition = item->graphPositionAt(
++ m_pinchHandler->centroid().position().toPoint());
++ item->setCameraZoomLevel(zoomLevel);
++
++ float diffAdj = 0.0f;
++
++ // If zooming in/out outside the graph, or zooming out after certain point,
++ // move towards the center.
++ if ((qAbs(targetPosition.x()) > 2.0f || qAbs(targetPosition.y()) > 2.0f
++ || qAbs(targetPosition.z()) > 2.0f)
++ || (m_pinchDiff > .0f && zoomLevel <= driftTowardCenterLevel)) {
++ targetPosition = QVector3D();
++ // Add some extra correction so that we actually reach the center
++ // eventually
++ diffAdj = wheelZoomDrift;
++ if (m_pinchDiff > .0f)
++ diffAdj *= 2.0f; // Correct towards center little more when zooming out
++ }
++
++ // Adjust camera towards the zoom point, attempting to keep the cursor at
++ // same graph point
++ QVector3D oldTarget = item->cameraTargetPosition();
++ QVector3D origDiff = targetPosition - oldTarget;
++ QVector3D diff = origDiff * m_pinchDiff + (origDiff.normalized() * diffAdj);
++ if (diff.length() > origDiff.length())
++ diff = origDiff;
++ item->setCameraTargetPosition(oldTarget + diff);
++ } else {
++ item->setCameraZoomLevel(zoomLevel);
++ }
++ m_pinchDiff = .0f;
++ }
++
++ void QGraphsInputHandler::hoverMoveEvent(QHoverEvent *event)
++ {
++ Q_EMIT mouseMove(event->oldPos());
++ }
++
++ QT_END_NAMESPACE
++
++ #include "moc_qgraphsinputhandler_p.cpp"