diff --git a/include/nodes/internal/FlowView.hpp b/include/nodes/internal/FlowView.hpp index 302e4bf1a..4fc46df78 100644 --- a/include/nodes/internal/FlowView.hpp +++ b/include/nodes/internal/FlowView.hpp @@ -1,9 +1,13 @@ #pragma once #include +#include +#include #include "Export.hpp" +class QTimer; + namespace QtNodes { @@ -36,6 +40,23 @@ class NODE_EDITOR_PUBLIC FlowView void goToNode(NodeGraphicsObject *node); void goToNodeID(QUuid ID); + /// Navigation style for every FlowView (set from the app's preferences). + /// blender: middle-drag / Alt+left-drag pans, Ctrl+(that) zooms, left-drag on empty space box-selects, + /// Home frames all nodes. trackpadScroll: two-finger scroll pans and Ctrl+scroll (pinch) zooms; + /// otherwise the wheel zooms at the cursor. blender=false keeps the original behaviour. + /// trackpadSpeed scales trackpad pan; zoomSpeed scales zoom (wheel, Ctrl+scroll, pinch) and is capped per step. + static void setNavigation(bool blender, bool trackpadScroll, double trackpadSpeed = 4.0, double zoomSpeed = 2.0); + + /// Pan and zoom so every node is visible. + void frameAll(); + + /// Drawing: 0 = auto (software over Remote Desktop, OpenGL otherwise), 1 = OpenGL, 2 = software. + static void setRenderMode(int mode); + /// Overlay the last frame's draw time (ms) in the corner, to measure optimisations. + static void setShowFrameTime(bool show); + /// Below this zoom, embedded widgets are hidden (plain node boxes). + static constexpr double lowDetailZoom = 0.4; + public slots: @@ -57,6 +78,8 @@ public slots: void wheelEvent(QWheelEvent *event) override; + bool event(QEvent *event) override; + void keyPressEvent(QKeyEvent *event) override; void keyReleaseEvent(QKeyEvent *event) override; @@ -65,8 +88,14 @@ public slots: void mouseMoveEvent(QMouseEvent *event) override; + void mouseReleaseEvent(QMouseEvent *event) override; + void drawBackground(QPainter* painter, const QRectF& r) override; + void drawForeground(QPainter* painter, const QRectF& r) override; + + void paintEvent(QPaintEvent *event) override; + void showEvent(QShowEvent *event) override; void addAnchor(int index); @@ -93,6 +122,33 @@ public slots: QPointF _clickPos; + enum class NavDrag { None, Pan, Zoom }; + NavDrag _navDrag = NavDrag::None; + QPoint _navLastPos; + void panByView(QPointF viewDelta); + void zoomBy(double factor); + + void applyRenderMode(); + void updateLevelOfDetail(); + void beginInteraction(); // anti-aliasing off while panning/zooming, back on when idle + QTimer *_interactionTimer = nullptr; + QTimer *_zoomTimer = nullptr; // animates towards the accumulated zoom target + double _pendingZoomLog = 0; // log of the zoom still to apply + bool _zoomCache = false; // nodes on the cheap ItemCoordinateCache while zooming + void zoomSmooth(double factor); + void setZoomCache(bool on); + bool _lowDetail = false; + double _lastFrameMs = 0; + static std::set s_views; + static int s_renderMode; + static bool s_showFrameTime; + + static bool s_blender; + static bool s_trackpadScroll; + static double s_trackpadSpeed; + static double s_zoomSpeed; + QString _lastWheel; // raw last wheel event, shown with the frame-time overlay + FlowScene* _scene; }; } diff --git a/include/nodes/internal/GroupGraphicsObject.hpp b/include/nodes/internal/GroupGraphicsObject.hpp index a28da495c..1a89326e3 100644 --- a/include/nodes/internal/GroupGraphicsObject.hpp +++ b/include/nodes/internal/GroupGraphicsObject.hpp @@ -76,6 +76,8 @@ class GroupGraphicsObject : public QGraphicsObject void setSizeY(int size) {sizeY = size;} void Collapse(); + /// Collapse or expand (as the group's X button), keeping the button state in step. + void ToggleCollapse(); QPointF portScenePosition(int i, PortType type) const; diff --git a/include/nodes/internal/NodeGraphicsObject.hpp b/include/nodes/internal/NodeGraphicsObject.hpp index 77d7ab8a0..56a64460e 100644 --- a/include/nodes/internal/NodeGraphicsObject.hpp +++ b/include/nodes/internal/NodeGraphicsObject.hpp @@ -38,6 +38,9 @@ class NodeGraphicsObject : public QGraphicsObject FlowScene& flowScene(); + /// Zoomed-out drawing: hide the embedded widget (the most expensive thing to draw). + void setLowDetail(bool low); + QRectF boundingRect() const override; diff --git a/src/FlowView.cpp b/src/FlowView.cpp index 35d9f35e9..64fad9239 100644 --- a/src/FlowView.cpp +++ b/src/FlowView.cpp @@ -15,11 +15,17 @@ #include #include #include +#ifdef _WIN32 +// Just the one call, instead of (whose min/max/near/far macros break this file). +extern "C" __declspec(dllimport) int __stdcall GetSystemMetrics(int nIndex); +#endif +#include #include "FlowScene.hpp" #include "DataModelRegistry.hpp" #include "Node.hpp" #include "Group.hpp" +#include "GroupGraphicsObject.hpp" #include "NodeGraphicsObject.hpp" #include "ConnectionGraphicsObject.hpp" #include "StyleCollection.hpp" @@ -32,6 +38,57 @@ using QtNodes::FlowScene; using QtNodes::Connection; using QtNodes::NodeConnectionInteraction; using QtNodes::NodeGraphicsObject; +using QtNodes::GroupGraphicsObject; + +std::set FlowView::s_views; +int FlowView::s_renderMode = 0; +bool FlowView::s_showFrameTime = false; + +static bool remoteDesktopSession() +{ +#ifdef _WIN32 + return GetSystemMetrics(0x1000 /* SM_REMOTESESSION */) != 0; +#else + return false; +#endif +} + +void FlowView::setRenderMode(int mode) +{ + s_renderMode = mode; + for (FlowView *v : s_views) + v->applyRenderMode(); +} + +void FlowView::setShowFrameTime(bool show) +{ + s_showFrameTime = show; + for (FlowView *v : s_views) + v->viewport()->update(); +} + +void FlowView::applyRenderMode() +{ + bool gl = s_renderMode == 1 || (s_renderMode == 0 && !remoteDesktopSession()); + bool isGL = qobject_cast(viewport()) != nullptr; + if (gl != isGL) + setViewport(gl ? static_cast(new QGLWidget(QGLFormat(QGL::SampleBuffers))) : new QWidget()); + // GL redraws everything anyway; the software path only repaints what changed. + setViewportUpdateMode(gl ? QGraphicsView::FullViewportUpdate : QGraphicsView::SmartViewportUpdate); +} + +bool FlowView::s_blender = true; +bool FlowView::s_trackpadScroll = true; +double FlowView::s_trackpadSpeed = 4.0; +double FlowView::s_zoomSpeed = 2.0; + +void FlowView::setNavigation(bool blender, bool trackpadScroll, double trackpadSpeed, double zoomSpeed) +{ + s_blender = blender; + s_trackpadScroll = trackpadScroll; + s_trackpadSpeed = trackpadSpeed; + s_zoomSpeed = zoomSpeed; +} FlowView:: FlowView(QWidget *parent) @@ -40,7 +97,7 @@ FlowView(QWidget *parent) , _deleteSelectionAction(Q_NULLPTR) , _scene(Q_NULLPTR) { - setDragMode(QGraphicsView::ScrollHandDrag); + setDragMode(s_blender ? QGraphicsView::RubberBandDrag : QGraphicsView::ScrollHandDrag); setRenderHint(QPainter::Antialiasing); auto const &flowViewStyle = StyleCollection::flowViewStyle(); @@ -56,9 +113,28 @@ FlowView(QWidget *parent) setCacheMode(QGraphicsView::CacheBackground); - setViewport(new QGLWidget(QGLFormat(QGL::SampleBuffers))); - - setViewportUpdateMode(QGraphicsView::FullViewportUpdate); + s_views.insert(this); + connect(this, &QObject::destroyed, [this]() { s_views.erase(this); }); + applyRenderMode(); + _interactionTimer = new QTimer(this); + _interactionTimer->setSingleShot(true); + _interactionTimer->setInterval(150); + connect(_interactionTimer, &QTimer::timeout, [this]() { + setRenderHint(QPainter::Antialiasing, true); + setZoomCache(false); + viewport()->update(); + }); + + _zoomTimer = new QTimer(this); + _zoomTimer->setInterval(16); + connect(_zoomTimer, &QTimer::timeout, [this]() { + // ease: apply 35% of what's left each frame; finish when it's negligible + double step = std::abs(_pendingZoomLog) < 0.002 ? _pendingZoomLog : 0.35 * _pendingZoomLog; + _pendingZoomLog -= step; + zoomBy(std::exp(step)); + if (_pendingZoomLog == 0.0) + _zoomTimer->stop(); + }); } @@ -409,6 +485,31 @@ void FlowView:: wheelEvent(QWheelEvent *event) { + if (s_blender) + { + // Trackpads send pixelDelta on macOS; over RDP they arrive as fine-grained angleDelta. + QPointF d = !event->pixelDelta().isNull() ? QPointF(event->pixelDelta()) + : QPointF(event->angleDelta()) / 4.0; + _lastWheel = QString("wheel angle %1,%2 pixel %3,%4 %5").arg(event->angleDelta().x()).arg(event->angleDelta().y()) + .arg(event->pixelDelta().x()).arg(event->pixelDelta().y()) + .arg(event->modifiers() & Qt::ControlModifier ? "ctrl" : (event->modifiers() & Qt::ShiftModifier ? "shift" : "")); + if (d.isNull()) + { + event->ignore(); + return; + } + if (!s_trackpadScroll || (event->modifiers() & Qt::ControlModifier)) + { + // zoom: proportional to the step, capped at one wheel notch so coarse RDP steps can't jump + double steps = std::max(-1.0, std::min(1.0, d.y() / 30.0)) * s_zoomSpeed; + zoomSmooth(std::pow(1.2, steps)); // one notch = 1.2x at zoom speed 1, animated + } + else + panByView(d * s_trackpadSpeed); // two-finger swipe pans (Trackpad speed) + event->accept(); + return; + } + QPoint delta = event->angleDelta(); if (delta.y() == 0) @@ -427,6 +528,100 @@ wheelEvent(QWheelEvent *event) } +void +FlowView:: +beginInteraction() +{ + if (renderHints() & QPainter::Antialiasing) + setRenderHint(QPainter::Antialiasing, false); + _interactionTimer->start(); +} + + +void +FlowView:: +updateLevelOfDetail() +{ + if (!_scene) + return; + bool low = transform().m11() < lowDetailZoom; + _lowDetail = low; + for (auto &n : _scene->nodes()) + n.second->nodeGraphicsObject().setLowDetail(low); +} + + +void +FlowView:: +panByView(QPointF viewDelta) +{ + beginInteraction(); + // content follows the fingers / mouse: move the visible scene rect the other way + QPointF d(-viewDelta.x() / transform().m11(), -viewDelta.y() / transform().m22()); + setSceneRect(sceneRect().translated(d.x(), d.y())); +} + + +void +FlowView:: +zoomBy(double factor) +{ + double s = transform().m11() * factor; + if (s > 2.0) factor = 2.0 / transform().m11(); // same maximum as scaleUp() + if (s < 0.05) factor = 0.05 / transform().m11(); + beginInteraction(); + setZoomCache(true); + scale(factor, factor); // AnchorUnderMouse: zooms at the cursor + updateLevelOfDetail(); +} + + +void +FlowView:: +zoomSmooth(double factor) +{ + setZoomCache(true); + _pendingZoomLog += std::log(factor); + // don't queue up more than ~3 notches, so a burst of events can't run away + _pendingZoomLog = std::max(-0.55, std::min(0.55, _pendingZoomLog)); + if (!_zoomTimer->isActive()) + _zoomTimer->start(); +} + + +void +FlowView:: +setZoomCache(bool on) +{ + if (on == _zoomCache || !_scene) + return; + _zoomCache = on; + // Device cache is exact but is re-rendered at every zoom level; item cache just scales the image. + for (auto &n : _scene->nodes()) + n.second->nodeGraphicsObject().setCacheMode(on ? QGraphicsItem::ItemCoordinateCache + : QGraphicsItem::DeviceCoordinateCache); +} + + +void +FlowView:: +frameAll() +{ + if (!_scene || _scene->items().isEmpty()) + return; + QRectF r = _scene->itemsBoundingRect(); + QPointF difference = r.center() - sceneRect().center(); + setSceneRect(sceneRect().translated(difference.x(), difference.y())); + double fit = 0.9 * std::min(viewport()->width() / std::max(r.width(), 1.0), + viewport()->height() / std::max(r.height(), 1.0)); + fit = std::max(0.05, std::min(fit, 2.0)); + setTransformationAnchor(QGraphicsView::AnchorViewCenter); + scale(fit / transform().m11(), fit / transform().m22()); + setTransformationAnchor(QGraphicsView::AnchorUnderMouse); + updateLevelOfDetail(); +} + + void FlowView:: scaleUp() @@ -439,7 +634,9 @@ scaleUp() if (t.m11() > 2.0) return; + beginInteraction(); scale(factor, factor); + updateLevelOfDetail(); } @@ -451,7 +648,9 @@ scaleDown() double const step = 1.2; double const factor = std::pow(step, -1.0); + beginInteraction(); scale(factor, factor); + updateLevelOfDetail(); } @@ -761,14 +960,53 @@ void FlowView::duplicateSelectedNode() } +bool +FlowView:: +event(QEvent *event) +{ + // Tab collapses/expands the group under the mouse. Handled here because Qt would otherwise use + // Tab to move keyboard focus before keyPressEvent sees it. + if (event->type() == QEvent::KeyPress) + { + QKeyEvent *k = static_cast(event); + if (k->key() == Qt::Key_Tab && !(k->modifiers() & (Qt::ControlModifier | Qt::AltModifier))) + { + QPoint vp = viewport()->mapFromGlobal(QCursor::pos()); + for (QGraphicsItem *item : items(vp)) + { + for (QGraphicsItem *it = item; it; it = it->parentItem()) + { + if (auto *g = dynamic_cast(it)) + { + g->ToggleCollapse(); + return true; + } + } + } + return true; // over empty space: swallow Tab rather than jump focus out of the editor + } + } + return QGraphicsView::event(event); +} + + + void FlowView:: keyPressEvent(QKeyEvent *event) { + if (s_blender && event->key() == Qt::Key_Home) + { + frameAll(); + event->accept(); + return; + } + switch (event->key()) { case Qt::Key_Shift: - setDragMode(QGraphicsView::RubberBandDrag); + if (!s_blender) + setDragMode(QGraphicsView::RubberBandDrag); break; default: break; @@ -785,7 +1023,8 @@ keyReleaseEvent(QKeyEvent *event) switch (event->key()) { case Qt::Key_Shift: - setDragMode(QGraphicsView::ScrollHandDrag); + if (!s_blender) + setDragMode(QGraphicsView::ScrollHandDrag); break; default: @@ -799,6 +1038,21 @@ void FlowView:: mousePressEvent(QMouseEvent *event) { + if (s_blender) + { + setDragMode(QGraphicsView::RubberBandDrag); // left-drag on empty space = box select + bool navButton = event->button() == Qt::MiddleButton || + (event->button() == Qt::LeftButton && (event->modifiers() & Qt::AltModifier)); + if (navButton) + { + _navDrag = (event->modifiers() & Qt::ControlModifier) ? NavDrag::Zoom : NavDrag::Pan; + _navLastPos = event->pos(); + event->accept(); + return; + } + } + if (!s_blender && dragMode() == QGraphicsView::RubberBandDrag && !(event->modifiers() & Qt::ShiftModifier)) + setDragMode(QGraphicsView::ScrollHandDrag); QGraphicsView::mousePressEvent(event); if (event->button() == Qt::LeftButton) { @@ -811,8 +1065,19 @@ void FlowView:: mouseMoveEvent(QMouseEvent *event) { + if (_navDrag != NavDrag::None) + { + QPoint d = event->pos() - _navLastPos; + _navLastPos = event->pos(); + if (_navDrag == NavDrag::Pan) + panByView(d); + else + zoomBy(std::pow(1.01, -d.y())); // drag up = zoom in + event->accept(); + return; + } QGraphicsView::mouseMoveEvent(event); - if (scene()->mouseGrabberItem() == nullptr && event->buttons() == Qt::LeftButton) + if (!s_blender && scene()->mouseGrabberItem() == nullptr && event->buttons() == Qt::LeftButton) { // Make sure shift is not being pressed if ((event->modifiers() & Qt::ShiftModifier) == 0) @@ -824,6 +1089,51 @@ mouseMoveEvent(QMouseEvent *event) } +void +FlowView:: +mouseReleaseEvent(QMouseEvent *event) +{ + if (_navDrag != NavDrag::None) + { + _navDrag = NavDrag::None; + event->accept(); + return; + } + QGraphicsView::mouseReleaseEvent(event); +} + + +void +FlowView:: +paintEvent(QPaintEvent *event) +{ + QElapsedTimer t; + t.start(); + QGraphicsView::paintEvent(event); + _lastFrameMs = 0.8 * _lastFrameMs + 0.2 * (t.nsecsElapsed() / 1e6); // smoothed; shown on the next frame +} + + +void +FlowView:: +drawForeground(QPainter* painter, const QRectF& r) +{ + QGraphicsView::drawForeground(painter, r); + if (!s_showFrameTime) + return; + painter->save(); + painter->resetTransform(); + QString mode = qobject_cast(viewport()) ? "OpenGL" : "software"; + QString txt = QString("%1 ms/frame (%2%3, %4 nodes)").arg(_lastFrameMs, 0, 'f', 1).arg(mode) + .arg(_lowDetail ? ", low detail" : "").arg(_scene ? (int)_scene->nodes().size() : 0); + painter->setPen(Qt::yellow); + painter->drawText(QPointF(10, 20), txt); + if (!_lastWheel.isEmpty()) + painter->drawText(QPointF(10, 38), _lastWheel); + painter->restore(); +} + + void FlowView:: drawBackground(QPainter* painter, const QRectF& r) diff --git a/src/GroupGraphicsObject.cpp b/src/GroupGraphicsObject.cpp index facd4d782..b1cadfdaf 100644 --- a/src/GroupGraphicsObject.cpp +++ b/src/GroupGraphicsObject.cpp @@ -2,6 +2,7 @@ #include #include +#include #include #include @@ -76,10 +77,11 @@ GroupGraphicsObject(FlowScene &scene, Group& group) _proxyWidget->setWidget(nameLineEdit); _proxyWidget->setPos(QPointF(sizeX/2 - _proxyWidget->size().width()/2, 0)); - collapseButtonWidget = new QPushButton("X"); + collapseButtonWidget = new QPushButton(QString(QChar(0x2630))); // hamburger icon (U+2630) + collapseButtonWidget->setToolTip("Collapse / expand (Tab, or right-click the group)"); collapseButtonWidget->setCheckable(true); _collapseButton->setWidget(collapseButtonWidget); - _collapseButton->setPos(QPointF(sizeX - _collapseButton->size().width(), 0)); + _collapseButton->setPos(QPointF(0, 0)); // always top-left connect(collapseButtonWidget, &QPushButton::clicked, this, [this](int state){ Collapse(); @@ -184,8 +186,8 @@ Collapse() //Do resize sizeX = 500; sizeY = numInOut * spacing; - _proxyWidget->setPos(QPointF(sizeX/2 - _proxyWidget->size().width()/2, 0)); - _collapseButton->setPos(QPointF(sizeX - _collapseButton->size().width(), 0)); + _proxyWidget->setPos(QPointF(std::max((qreal)(sizeX/2 - _proxyWidget->size().width()/2), (qreal)(_collapseButton->size().width() + 4)), 0)); + _collapseButton->setPos(QPointF(0, 0)); // always top-left //Sets the inside nodes invisible @@ -234,8 +236,8 @@ Collapse() sizeX = savedSizeX; sizeY = savedSizeY; - _proxyWidget->setPos(QPointF(sizeX/2 - _proxyWidget->size().width()/2, 0)); - _collapseButton->setPos(QPointF(sizeX - _collapseButton->size().width(), 0)); + _proxyWidget->setPos(QPointF(std::max((qreal)(sizeX/2 - _proxyWidget->size().width()/2), (qreal)(_collapseButton->size().width() + 4)), 0)); + _collapseButton->setPos(QPointF(0, 0)); // always top-left //Sets the inside nodes invisible for(int i=0; isetPos(QPointF(sizeX/2 - _proxyWidget->size().width()/2, 0)); - _collapseButton->setPos(QPointF(sizeX - _collapseButton->size().width(), 0)); + _proxyWidget->setPos(QPointF(std::max((qreal)(sizeX/2 - _proxyWidget->size().width()/2), (qreal)(_collapseButton->size().width() + 4)), 0)); + _collapseButton->setPos(QPointF(0, 0)); // always top-left event->accept(); } else if(isResizingY) { @@ -555,8 +557,8 @@ mouseMoveEvent(QGraphicsSceneMouseEvent * event) prepareGeometryChange(); sizeY += diff; update(); - _proxyWidget->setPos(QPointF(sizeX/2 - _proxyWidget->size().width()/2, 0)); - _collapseButton->setPos(QPointF(sizeX - _collapseButton->size().width(), 0)); + _proxyWidget->setPos(QPointF(std::max((qreal)(sizeX/2 - _proxyWidget->size().width()/2), (qreal)(_collapseButton->size().width() + 4)), 0)); + _collapseButton->setPos(QPointF(0, 0)); // always top-left event->accept(); } else if(isResizingXY) { auto diff = event->pos() - event->lastPos(); @@ -564,8 +566,8 @@ mouseMoveEvent(QGraphicsSceneMouseEvent * event) sizeX += diff.x(); sizeY += diff.y(); update(); - _proxyWidget->setPos(QPointF(sizeX/2 - _proxyWidget->size().width()/2, 0)); - _collapseButton->setPos(QPointF(sizeX - _collapseButton->size().width(), 0)); + _proxyWidget->setPos(QPointF(std::max((qreal)(sizeX/2 - _proxyWidget->size().width()/2), (qreal)(_collapseButton->size().width() + 4)), 0)); + _collapseButton->setPos(QPointF(0, 0)); // always top-left event->accept(); } else { _scene.groupMoved(_group, pos()); @@ -642,7 +644,34 @@ mouseDoubleClickEvent(QGraphicsSceneMouseEvent* event) void GroupGraphicsObject:: -contextMenuEvent(QGraphicsSceneContextMenuEvent* event) +ToggleCollapse() { + Collapse(); + collapseButtonWidget->setChecked(collapsed); +} + +void +GroupGraphicsObject:: +contextMenuEvent(QGraphicsSceneContextMenuEvent* event) +{ + QMenu menu; + QAction* collapseAction = menu.addAction(collapsed ? "Expand" : "Collapse"); + collapseAction->setShortcut(Qt::Key_Tab); // shown only; Tab is handled by FlowView + QAction* colourAction = menu.addAction("Colour..."); + QAction* chosen = menu.exec(event->screenPos()); + if (chosen == collapseAction) + ToggleCollapse(); + else if (chosen == colourAction) + { + QColor c = QColorDialog::getColor(QColor(r, g, b), nullptr, "Group colour"); + if (c.isValid()) + { + r = c.red(); + g = c.green(); + b = c.blue(); + update(); + } + } + event->accept(); } diff --git a/src/NodeGraphicsObject.cpp b/src/NodeGraphicsObject.cpp index 91703704c..df6385fe6 100644 --- a/src/NodeGraphicsObject.cpp +++ b/src/NodeGraphicsObject.cpp @@ -103,6 +103,15 @@ node() const return _node; } +void +NodeGraphicsObject:: +setLowDetail(bool low) +{ + if (_proxyWidget && _proxyWidget->isVisible() == low) + _proxyWidget->setVisible(!low); +} + + void NodeGraphicsObject:: embedQWidget()