38 changed files with 1292 additions and 30 deletions
@ -0,0 +1,818 @@
@@ -0,0 +1,818 @@
|
||||
///////////////////////////////////////////////////////////////////////////////////
|
||||
// Copyright (C) 2026 Jon Beniston, M7RCE <jon@beniston.com> //
|
||||
// Some code by AI //
|
||||
// //
|
||||
// This program is free software; you can redistribute it and/or modify //
|
||||
// it under the terms of the GNU General Public License as published by //
|
||||
// the Free Software Foundation as version 3 of the License, or //
|
||||
// (at your option) any later version. //
|
||||
// //
|
||||
// This program is distributed in the hope that it will be useful, //
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of //
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the //
|
||||
// GNU General Public License V3 for more details. //
|
||||
// //
|
||||
// You should have received a copy of the GNU General Public License //
|
||||
// along with this program. If not, see <http://www.gnu.org/licenses/>. //
|
||||
///////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#include "connectionoverlay.h" |
||||
|
||||
#include <QEvent> |
||||
#include <QHash> |
||||
#include <QPair> |
||||
#include <QLineF> |
||||
#include <QMdiArea> |
||||
#include <QMdiSubWindow> |
||||
#include <QPainter> |
||||
#include <QPainterPath> |
||||
#include <QPainterPathStroker> |
||||
#include <QPaintEvent> |
||||
#include <QRegion> |
||||
#include <QVector> |
||||
#include <QtMath> |
||||
|
||||
ConnectionOverlay::ConnectionOverlay(QMdiArea *mdi) : |
||||
QWidget(mdi), |
||||
m_mdi(mdi) |
||||
{ |
||||
// QMdiArea scrolls its viewport children; keep the overlay fixed above the viewport.
|
||||
setAttribute(Qt::WA_TransparentForMouseEvents); |
||||
setAttribute(Qt::WA_TranslucentBackground); |
||||
setGeometry(mdi->viewport()->geometry()); |
||||
mdi->viewport()->installEventFilter(this); |
||||
m_animationTimer.setInterval(33); |
||||
connect(&m_animationTimer, &QTimer::timeout, this, &ConnectionOverlay::animate); |
||||
m_clock.start(); |
||||
hide(); |
||||
} |
||||
|
||||
bool ConnectionOverlay::sameConnections(const QList<Connection>& a, const QList<Connection>& b) |
||||
{ |
||||
if (a.size() != b.size()) { |
||||
return false; |
||||
} |
||||
for (int i = 0; i < a.size(); ++i) |
||||
{ |
||||
const Connection& x = a[i]; |
||||
const Connection& y = b[i]; |
||||
if (x.source.data() != y.source.data() || x.target.data() != y.target.data() || |
||||
x.sourceLabel != y.sourceLabel || x.targetLabel != y.targetLabel || |
||||
x.flowLabel != y.flowLabel || x.sourceWorkspace != y.sourceWorkspace || |
||||
x.targetWorkspace != y.targetWorkspace || x.kind != y.kind || |
||||
x.direction != y.direction || x.color != y.color) { |
||||
return false; |
||||
} |
||||
} |
||||
return true; |
||||
} |
||||
|
||||
void ConnectionOverlay::setConnections(const QList<Connection>& connections) |
||||
{ |
||||
// Connections are refreshed periodically; only relayout when something changed.
|
||||
if (sameConnections(connections, m_connections)) { |
||||
return; |
||||
} |
||||
m_connections = connections; |
||||
m_indexLabels.clear(); |
||||
// Cache each title ID widget so paths can anchor beside it and avoid painting over it.
|
||||
for (const Connection& connection : m_connections) |
||||
{ |
||||
for (QMdiSubWindow *window : {connection.source.data(), connection.target.data()}) |
||||
{ |
||||
if (window && !m_indexLabels.contains(window)) { |
||||
m_indexLabels.insert(window, window->findChild<QWidget*>("connectionIndexLabel")); |
||||
} |
||||
} |
||||
} |
||||
watchWindows(); |
||||
invalidateLayout(); |
||||
} |
||||
|
||||
void ConnectionOverlay::watchWindows() |
||||
{ |
||||
// Cached routes depend on the connected windows' geometry and their ID labels.
|
||||
for (const QPointer<QObject>& object : m_watched) |
||||
{ |
||||
if (object) { |
||||
object->removeEventFilter(this); |
||||
} |
||||
} |
||||
m_watched.clear(); |
||||
for (auto it = m_indexLabels.constBegin(); it != m_indexLabels.constEnd(); ++it) |
||||
{ |
||||
for (QObject *object : {static_cast<QObject*>(it.key()), static_cast<QObject*>(it.value().data())}) |
||||
{ |
||||
if (object) |
||||
{ |
||||
object->installEventFilter(this); |
||||
m_watched.append(object); |
||||
} |
||||
} |
||||
} |
||||
} |
||||
|
||||
void ConnectionOverlay::setOverlayVisible(bool visible) |
||||
{ |
||||
setVisible(visible); |
||||
if (visible) |
||||
{ |
||||
setGeometry(m_mdi->viewport()->geometry()); |
||||
raise(); |
||||
m_layoutDirty = true; |
||||
relayout(); |
||||
m_animationTimer.start(); |
||||
} |
||||
else |
||||
{ |
||||
m_animationTimer.stop(); |
||||
m_pulseRegion = QRegion(); |
||||
} |
||||
} |
||||
|
||||
bool ConnectionOverlay::eventFilter(QObject *object, QEvent *event) |
||||
{ |
||||
const QEvent::Type type = event->type(); |
||||
if (object == m_mdi->viewport()) |
||||
{ |
||||
if (type == QEvent::Resize || type == QEvent::Move || type == QEvent::Show) |
||||
{ |
||||
setGeometry(m_mdi->viewport()->geometry()); |
||||
if (isVisible()) { |
||||
raise(); |
||||
} |
||||
invalidateLayout(); |
||||
} |
||||
else if (type == QEvent::ChildAdded || type == QEvent::ChildRemoved) |
||||
{ |
||||
invalidateLayout(); // A window joined or left this workspace.
|
||||
} |
||||
} |
||||
else if (type == QEvent::Move || type == QEvent::Resize || type == QEvent::Show || |
||||
type == QEvent::Hide || type == QEvent::WindowStateChange || type == QEvent::ParentChange) |
||||
{ |
||||
invalidateLayout(); // A connected window or its ID label moved, e.g. when scrolling.
|
||||
} |
||||
return QWidget::eventFilter(object, event); |
||||
} |
||||
|
||||
void ConnectionOverlay::changeEvent(QEvent *event) |
||||
{ |
||||
if (event->type() == QEvent::FontChange || event->type() == QEvent::PaletteChange) { |
||||
invalidateLayout(); |
||||
} |
||||
QWidget::changeEvent(event); |
||||
} |
||||
|
||||
void ConnectionOverlay::invalidateLayout() |
||||
{ |
||||
// Remember the cache is stale even while hidden (e.g. in a background dock tab),
|
||||
// so showEvent() can relayout. Coalesce bursts (e.g. scrolling) into one relayout.
|
||||
m_layoutDirty = true; |
||||
if (!isVisible() || m_relayoutPending) { |
||||
return; |
||||
} |
||||
m_relayoutPending = true; |
||||
QMetaObject::invokeMethod(this, [this]() { relayout(); }, Qt::QueuedConnection); |
||||
} |
||||
|
||||
void ConnectionOverlay::relayout() |
||||
{ |
||||
m_relayoutPending = false; |
||||
if (!isVisible() || !m_layoutDirty) { |
||||
return; |
||||
} |
||||
computeLayout(); |
||||
update(); |
||||
} |
||||
|
||||
void ConnectionOverlay::showEvent(QShowEvent *event) |
||||
{ |
||||
QWidget::showEvent(event); |
||||
// Changes while hidden were not laid out. The viewport's own Show event arrives
|
||||
// before this widget is visible, so it cannot trigger the relayout itself.
|
||||
if (m_layoutDirty) |
||||
{ |
||||
computeLayout(); |
||||
update(); |
||||
} |
||||
} |
||||
|
||||
static QPointF viewportEdge(const QRectF& bounds, const QPointF& outside) |
||||
{ |
||||
return QPointF(qBound(bounds.left(), outside.x(), bounds.right()), |
||||
qBound(bounds.top(), outside.y(), bounds.bottom())); |
||||
} |
||||
|
||||
static QString scrollArrow(const QRectF& bounds, const QPointF& outside) |
||||
{ |
||||
if (outside.y() < bounds.top()) { |
||||
return QString::fromUtf8("↑"); |
||||
} |
||||
if (outside.y() > bounds.bottom()) { |
||||
return QString::fromUtf8("↓"); |
||||
} |
||||
if (outside.x() < bounds.left()) { |
||||
return QString::fromUtf8("←"); |
||||
} |
||||
return QString::fromUtf8("→"); |
||||
} |
||||
|
||||
static QPainterPath roundedRoute(const QVector<QPointF>& points) |
||||
{ |
||||
QPainterPath path(points.first()); |
||||
for (int i = 1; i + 1 < points.size(); ++i)
|
||||
{ |
||||
const QPointF incoming = points[i] - points[i - 1]; |
||||
const QPointF outgoing = points[i + 1] - points[i]; |
||||
const qreal incomingLength = QLineF(points[i - 1], points[i]).length(); |
||||
const qreal outgoingLength = QLineF(points[i], points[i + 1]).length(); |
||||
if (incomingLength < 1 || outgoingLength < 1 || |
||||
qAbs(incoming.x() * outgoing.y() - incoming.y() * outgoing.x()) < 0.01)
|
||||
{ |
||||
path.lineTo(points[i]); |
||||
continue; |
||||
} |
||||
const qreal radius = qMin<qreal>(18, qMin(incomingLength, outgoingLength) / 2); |
||||
path.lineTo(points[i] - incoming * (radius / incomingLength)); |
||||
path.quadTo(points[i], points[i] + outgoing * (radius / outgoingLength)); |
||||
} |
||||
path.lineTo(points.last()); |
||||
return path; |
||||
} |
||||
|
||||
static int crossingCost(const QPainterPath& path, const QRectF& sourceBox, const QRectF& targetBox) |
||||
{ |
||||
// Count samples drawn over a window body. An endpoint can be inside a window,
|
||||
// e.g. the source's own title bar, or an ID label covered by an overlapping
|
||||
// window. The route may then leave that window at the start, or arrive in it
|
||||
// at the end, but any other part inside a window is a crossing.
|
||||
constexpr int samples = 80; |
||||
QPointF points[samples + 1]; |
||||
for (int i = 0; i <= samples; ++i) { |
||||
points[i] = path.pointAtPercent(qreal(i) / samples); |
||||
} |
||||
int cost = 0; |
||||
for (const QRectF& box : {sourceBox, targetBox}) |
||||
{ |
||||
if (box.isEmpty()) { |
||||
continue; |
||||
} |
||||
const QRectF body = box.adjusted(-2, -2, 2, 2); |
||||
int first = 0; |
||||
while (first <= samples && body.contains(points[first])) { |
||||
++first; // Leading run inside, leaving the start window
|
||||
} |
||||
int last = samples; |
||||
while (last >= first && body.contains(points[last])) { |
||||
--last; // Trailing run inside, arriving in the end window
|
||||
} |
||||
for (int i = first; i <= last; ++i) |
||||
{ |
||||
if (body.contains(points[i])) { |
||||
++cost; |
||||
} |
||||
} |
||||
} |
||||
return cost; |
||||
} |
||||
|
||||
static QPainterPath connectionPath(const QPointF& from, const QPointF& to, |
||||
int fromSide, int toSide, const QRectF& sourceBox, |
||||
const QRectF& targetBox, const QRectF& bounds) |
||||
{ |
||||
constexpr qreal labelLead = 14; |
||||
const QPointF curveFrom = from + QPointF(fromSide * labelLead, 0); |
||||
const QPointF curveTo = to + QPointF(toSide * labelLead, 0); |
||||
const QPointF delta = curveTo - curveFrom; |
||||
const qreal handle = qBound<qreal>(32, qAbs(delta.x()) * 0.35 + qAbs(delta.y()) * 0.3, 180); |
||||
const QPointF firstControl = fromSide == 0 ? curveFrom + delta * 0.3 : |
||||
curveFrom + QPointF(fromSide * handle, 0); |
||||
const QPointF lastControl = toSide == 0 ? curveTo - delta * 0.3 : |
||||
curveTo + QPointF(toSide * handle, 0); |
||||
QPainterPath direct(from); |
||||
if (fromSide != 0) { |
||||
direct.lineTo(curveFrom); |
||||
} |
||||
direct.cubicTo(firstControl, lastControl, curveTo); |
||||
if (toSide != 0) { |
||||
direct.lineTo(to); |
||||
} |
||||
if (sourceBox.isEmpty() || targetBox.isEmpty()) { |
||||
return direct; |
||||
} |
||||
// Prefer the route that crosses windows least, then the shortest. Crossing can
|
||||
// be unavoidable (e.g. an endpoint covered by the other window), and then the
|
||||
// direct route is usually clearer than a long detour around both windows.
|
||||
QPainterPath bestRoute = direct; |
||||
int bestCost = crossingCost(direct, sourceBox, targetBox); |
||||
qreal bestLength = direct.length(); |
||||
if (bestCost == 0) { |
||||
return direct; |
||||
} |
||||
auto consider = [&](const QPainterPath& candidate) { |
||||
const qreal length = candidate.length(); |
||||
if (bestCost == 0 && length >= bestLength) { |
||||
return; // Cannot beat a shorter clear route
|
||||
} |
||||
const int cost = crossingCost(candidate, sourceBox, targetBox); |
||||
if (cost < bestCost || (cost == bestCost && length < bestLength)) |
||||
{ |
||||
bestRoute = candidate; |
||||
bestCost = cost; |
||||
bestLength = length; |
||||
} |
||||
}; |
||||
|
||||
// Try an outer route around both windows, and nearer horizontal lanes.
|
||||
constexpr qreal clearance = 24; |
||||
const bool separatedBelow = sourceBox.bottom() + 2 * clearance < targetBox.top(); |
||||
const bool separatedAbove = targetBox.bottom() + 2 * clearance < sourceBox.top(); |
||||
const qreal laneY = separatedBelow ? (sourceBox.bottom() + targetBox.top()) / 2 : |
||||
(separatedAbove ? (targetBox.bottom() + sourceBox.top()) / 2 : |
||||
qMax(sourceBox.bottom(), targetBox.bottom()) + clearance); |
||||
const qreal rightX = qMax(sourceBox.right(), |
||||
separatedBelow || separatedAbove ? sourceBox.right() : targetBox.right()) + clearance; |
||||
const qreal leftX = qMin(to.x() - 30, targetBox.left() - clearance); |
||||
QVector<QPointF> route; |
||||
route.append(from); |
||||
const qreal topY = qMin(sourceBox.top(), targetBox.top()) - clearance; |
||||
if (topY >= bounds.top() + 4)
|
||||
{ |
||||
route.append(QPointF(from.x() + clearance, from.y())); |
||||
route.append(QPointF(from.x() + clearance, topY)); |
||||
route.append(QPointF(rightX, topY)); |
||||
}
|
||||
else
|
||||
{ |
||||
route.append(QPointF(rightX, from.y())); |
||||
} |
||||
route.append(QPointF(rightX, laneY)); |
||||
route.append(QPointF(leftX, laneY)); |
||||
route.append(QPointF(leftX, to.y())); |
||||
route.append(to); |
||||
consider(roundedRoute(route)); |
||||
const qreal exitXs[] = { |
||||
from.x() + clearance, |
||||
qMax(from.x() + clearance, targetBox.right() + clearance), |
||||
qMax(from.x() + clearance, sourceBox.right() + clearance) |
||||
}; |
||||
const qreal laneYs[] = { |
||||
topY, sourceBox.top() - clearance, targetBox.top() - clearance, |
||||
laneY, sourceBox.bottom() + clearance, targetBox.bottom() + clearance |
||||
}; |
||||
for (qreal candidateY : laneYs)
|
||||
{ |
||||
if (candidateY < bounds.top() + 4 || candidateY > bounds.bottom() - 4 || |
||||
qAbs(candidateY - from.y()) < 6) { |
||||
continue; |
||||
} |
||||
for (qreal exitX : exitXs)
|
||||
{ |
||||
// A downward exit within the source would run through its controls.
|
||||
const bool insideSourceX = exitX > sourceBox.left() && exitX < sourceBox.right(); |
||||
const bool throughSourceBody = insideSourceX && |
||||
qMax(qMin(from.y(), candidateY), sourceBox.top() + 26) < |
||||
qMin(qMax(from.y(), candidateY), sourceBox.bottom()); |
||||
if (throughSourceBody) { |
||||
continue; |
||||
} |
||||
consider(roundedRoute({ |
||||
from, |
||||
QPointF(exitX, from.y()), |
||||
QPointF(exitX, candidateY), |
||||
QPointF(leftX, candidateY), |
||||
QPointF(leftX, to.y()), |
||||
to |
||||
})); |
||||
} |
||||
} |
||||
// A source directly below its target has no upper lane. Turn just below
|
||||
// the source title and leave on the left, instead of circling both windows.
|
||||
if (targetBox.bottom() <= sourceBox.top() + clearance) { |
||||
const qreal leftExitX = qMin(sourceBox.left(), targetBox.left()) - clearance; |
||||
const qreal turnY = qMax(from.y() + clearance, targetBox.bottom() + clearance); |
||||
if (leftExitX >= bounds.left() + 4 && turnY <= bounds.bottom() - 4) { |
||||
consider(roundedRoute({ |
||||
from, |
||||
QPointF(from.x() + clearance, from.y()), |
||||
QPointF(from.x() + clearance, turnY), |
||||
QPointF(leftExitX, turnY), |
||||
QPointF(leftExitX, to.y()), |
||||
to |
||||
})); |
||||
} |
||||
} |
||||
return bestRoute; |
||||
} |
||||
|
||||
bool ConnectionOverlay::computeLayout() |
||||
{ |
||||
m_layoutDirty = false; |
||||
m_routes.clear(); |
||||
const QList<QMdiSubWindow*> localWindows = m_mdi->subWindowList(); |
||||
const QRectF bounds = rect().adjusted(8, 8, -8, -8); |
||||
const QPoint viewportOffset = m_mdi->viewport()->pos() - pos(); |
||||
const QFontMetrics metrics(font()); |
||||
m_clipRegion = QRegion(rect()); |
||||
QRegion paintedRegion; |
||||
QVector<QRectF> labelObstacles; // Title ID labels, then each label as it is placed
|
||||
// Stubs to other workspaces that leave the same anchor fan out vertically, so
|
||||
// their lines and labels do not sit on top of each other.
|
||||
QHash<QPair<QMdiSubWindow*, int>, int> stubCounts; |
||||
const qreal stubSpacing = metrics.height() + 14; |
||||
auto fanOffset = [&](QMdiSubWindow *window, int side) -> qreal { |
||||
const int n = stubCounts[qMakePair(window, side)]++; |
||||
const int step = (n + 1) / 2; // 0, 1, 1, 2, 2, ...
|
||||
return (n % 2 ? step : -step) * stubSpacing; // 0, +1, -1, +2, -2, ...
|
||||
}; |
||||
QPainterPathStroker maskStroker; |
||||
maskStroker.setWidth(20); |
||||
maskStroker.setCapStyle(Qt::RoundCap); |
||||
maskStroker.setJoinStyle(Qt::RoundJoin); |
||||
for (auto it = m_indexLabels.constBegin(); it != m_indexLabels.constEnd(); ++it) |
||||
{ |
||||
QMdiSubWindow *window = it.key(); |
||||
QWidget *indexLabel = it.value().data(); |
||||
if (!window || !localWindows.contains(window) || !indexLabel || !indexLabel->isVisible()) { |
||||
continue; |
||||
} |
||||
const QPoint labelTopLeft = window->geometry().topLeft() + |
||||
indexLabel->mapTo(window, QPoint(0, 0)) + viewportOffset; |
||||
const QRect indexRect = QRect(labelTopLeft, indexLabel->size()).adjusted(-2, -2, 2, 2); |
||||
m_clipRegion -= indexRect; |
||||
labelObstacles.append(indexRect); |
||||
} |
||||
// The overlay is a sibling of the scrolling viewport, so translate MDI
|
||||
// window coordinates before using their title labels as endpoints.
|
||||
auto anchorFor = [this, &viewportOffset](QMdiSubWindow *window, int side) -> QPointF { |
||||
QWidget *indexLabel = m_indexLabels.value(window).data(); |
||||
const QPoint insideWindow = indexLabel && indexLabel->isVisible() ? |
||||
indexLabel->mapTo(window, QPoint(side < 0 ? -10 : indexLabel->width() + 10, |
||||
indexLabel->height() / 2)) : |
||||
QPoint(side < 0 ? -10 : 48, 12); |
||||
return QPointF(window->geometry().topLeft() + insideWindow + viewportOffset); |
||||
}; |
||||
|
||||
for (const Connection& connection : m_connections) |
||||
{ |
||||
if (!connection.source || !connection.target) { |
||||
continue; |
||||
} |
||||
const bool sourceLocal = localWindows.contains(connection.source.data()); |
||||
const bool targetLocal = localWindows.contains(connection.target.data()); |
||||
if (!sourceLocal && !targetLocal) { |
||||
continue; |
||||
} |
||||
if (sourceLocal && (connection.source->parentWidget() != m_mdi->viewport() || |
||||
!connection.source->isVisible() || connection.source->isMinimized())) { |
||||
continue; |
||||
} |
||||
if (targetLocal && (connection.target->parentWidget() != m_mdi->viewport() || |
||||
!connection.target->isVisible() || connection.target->isMinimized())) { |
||||
continue; |
||||
} |
||||
const int sourceSide = 1; // Device ID, or the producer of a pipe.
|
||||
const int targetSide = -1; // Inputs meet the left side of channel, spectrum, and feature IDs.
|
||||
const QPointF sourceAnchor = sourceLocal ? anchorFor(connection.source.data(), sourceSide) : QPointF(); |
||||
const QPointF targetAnchor = targetLocal ? anchorFor(connection.target.data(), targetSide) : QPointF(); |
||||
const bool sourceVisible = sourceLocal && bounds.contains(sourceAnchor); |
||||
const bool targetVisible = targetLocal && bounds.contains(targetAnchor); |
||||
// This workspace draws a link only when at least one endpoint is on screen.
|
||||
if (!sourceVisible && !targetVisible) { |
||||
continue; |
||||
} |
||||
|
||||
Route route; |
||||
QPointF markerEdge; |
||||
bool crossWorkspace = false; |
||||
int stubDirection = 0; // Which way a cross-workspace stub goes from its window
|
||||
// Scrolled endpoints point to a viewport edge. An endpoint in another
|
||||
// workspace instead gets a short labeled stub beside the local window.
|
||||
if (sourceVisible && targetVisible) |
||||
{ |
||||
route.from = sourceAnchor; |
||||
route.to = targetAnchor; |
||||
} |
||||
else if (sourceVisible && targetLocal) |
||||
{ |
||||
route.from = sourceAnchor; |
||||
route.to = viewportEdge(bounds, targetAnchor); |
||||
markerEdge = route.to; |
||||
route.marker = scrollArrow(bounds, targetAnchor) + " " + connection.targetLabel; |
||||
} |
||||
else if (targetVisible && sourceLocal) |
||||
{ |
||||
route.from = viewportEdge(bounds, sourceAnchor); |
||||
route.to = targetAnchor; |
||||
markerEdge = route.from; |
||||
route.marker = scrollArrow(bounds, sourceAnchor) + " " + connection.sourceLabel; |
||||
} |
||||
else if (sourceVisible) |
||||
{ |
||||
route.from = sourceAnchor; |
||||
route.marker = QString("W%1 · %2").arg(connection.targetWorkspace).arg(connection.targetLabel); |
||||
if (!connection.flowLabel.isEmpty()) { |
||||
route.marker += " · " + connection.flowLabel; // One label per stub, at its tip
|
||||
} |
||||
const qreal markerWidth = metrics.horizontalAdvance(route.marker) + 8; |
||||
const qreal stubLength = 90; |
||||
const qreal stubY = qBound(bounds.top() + 4, route.from.y() + fanOffset(connection.source.data(), sourceSide), |
||||
bounds.bottom() - 4); |
||||
// Stubs leave to the right. Near the right edge there is no room for the
|
||||
// stub and its label, so go left instead, past the window's ID label.
|
||||
stubDirection = route.from.x() + stubLength + markerWidth + 10 <= bounds.right() ? 1 : -1; |
||||
const qreal tipX = stubDirection > 0 ? route.from.x() + stubLength : |
||||
qMax(bounds.left() + markerWidth + 10, route.from.x() - stubLength - 60); |
||||
route.to = QPointF(tipX, stubY); |
||||
route.stubTip = 1; |
||||
crossWorkspace = true; |
||||
} |
||||
else |
||||
{ |
||||
route.to = targetAnchor; |
||||
route.marker = QString("W%1 · %2").arg(connection.sourceWorkspace).arg(connection.sourceLabel); |
||||
if (!connection.flowLabel.isEmpty()) { |
||||
route.marker += " · " + connection.flowLabel; // One label per stub, at its tip
|
||||
} |
||||
const qreal markerWidth = metrics.horizontalAdvance(route.marker) + 8; |
||||
const qreal stubLength = 90; |
||||
// Stubs arrive from the left. Near the left edge there is no room for the
|
||||
// stub and its label, so come from the right instead, past the ID label.
|
||||
stubDirection = route.to.x() - stubLength - markerWidth - 10 >= bounds.left() ? -1 : 1; |
||||
const qreal tipX = stubDirection < 0 ? route.to.x() - stubLength : |
||||
qMin(bounds.right() - markerWidth - 10, route.to.x() + stubLength + 60); |
||||
const qreal stubY = qBound(bounds.top() + 4, route.to.y() + fanOffset(connection.target.data(), targetSide), |
||||
bounds.bottom() - 4); |
||||
route.from = QPointF(tipX, stubY); |
||||
route.stubTip = -1; |
||||
crossWorkspace = true; |
||||
} |
||||
const QPointF& from = route.from; |
||||
const QPointF& to = route.to; |
||||
|
||||
route.color = connection.color.isValid() ? connection.color.lighter(150) : |
||||
(connection.kind == PipeLink ? QColor(238, 183, 77) : QColor(56, 204, 228)); |
||||
route.kind = connection.kind; |
||||
route.direction = connection.direction; |
||||
route.sourceBox = sourceVisible ? |
||||
QRectF(connection.source->geometry().translated(viewportOffset)) : QRectF(); |
||||
route.targetBox = targetVisible ? |
||||
QRectF(connection.target->geometry().translated(viewportOffset)) : QRectF(); |
||||
// A stub flipped to the other side goes straight out, behind its ID label.
|
||||
route.fromSide = sourceVisible && stubDirection >= 0 ? sourceSide : 0; |
||||
route.toSide = targetVisible && stubDirection <= 0 ? targetSide : 0; |
||||
route.path = connectionPath(from, to, route.fromSide, route.toSide, |
||||
route.sourceBox, route.targetBox, bounds); |
||||
route.length = route.path.length(); |
||||
|
||||
if (!connection.flowLabel.isEmpty() && !crossWorkspace) // Stubs include it in their marker
|
||||
{ |
||||
const qreal labelWidth = metrics.horizontalAdvance(connection.flowLabel) + 10; |
||||
const qreal labelHeight = metrics.height() + 4; |
||||
// Beside each route's own midpoint, so labels of fanned stubs separate too.
|
||||
const QPointF midpoint = route.path.pointAtPercent(0.5); |
||||
const qreal labelX = midpoint.x() - labelWidth / 2; |
||||
const qreal labelY = midpoint.y() - labelHeight - 6; |
||||
route.flowLabel = connection.flowLabel; |
||||
route.flowLabelRect = QRectF(qBound(bounds.left() + 4, labelX, |
||||
qMax(bounds.left() + 4, bounds.right() - labelWidth - 4)), |
||||
qBound(bounds.top() + 4, labelY, |
||||
qMax(bounds.top() + 4, bounds.bottom() - labelHeight - 4)), |
||||
labelWidth, labelHeight); |
||||
} |
||||
|
||||
if (!route.marker.isEmpty()) |
||||
{ |
||||
const qreal labelWidth = metrics.horizontalAdvance(route.marker) + 8; |
||||
const qreal labelHeight = metrics.height() + 4; |
||||
const QPointF remoteAnchor = sourceVisible ? to : from; |
||||
// A stub's label continues from its tip, in the direction the stub goes.
|
||||
const qreal labelX = crossWorkspace ? |
||||
(stubDirection > 0 ? remoteAnchor.x() + 6 : remoteAnchor.x() - labelWidth - 6) : |
||||
(markerEdge.x() >= bounds.right() - 1 ? |
||||
markerEdge.x() - labelWidth - 8 : markerEdge.x() + 8); |
||||
const qreal labelY = crossWorkspace ? |
||||
remoteAnchor.y() - labelHeight / 2 : |
||||
(markerEdge.y() >= bounds.bottom() - 1 ? |
||||
markerEdge.y() - labelHeight - 8 : markerEdge.y() + 8); |
||||
route.markerRect = QRectF(qBound(bounds.left() + 4, labelX, |
||||
qMax(bounds.left() + 4, bounds.right() - labelWidth - 4)), |
||||
qBound(bounds.top() + 4, labelY, |
||||
qMax(bounds.top() + 4, bounds.bottom() - labelHeight - 4)), |
||||
labelWidth, labelHeight); |
||||
} |
||||
|
||||
m_routes.append(route); |
||||
} |
||||
|
||||
// Resolve remaining label overlaps. Place workspace and scroll markers first, as
|
||||
// they sit at route ends, then flow labels. Each label moves up or down by whole
|
||||
// label heights to the nearest free position inside the viewport.
|
||||
auto placeLabel = [&](QRectF& label) { |
||||
if (label.isEmpty()) { |
||||
return; |
||||
} |
||||
const qreal step = label.height() + 4; |
||||
for (int attempt = 0; attempt < 16; ++attempt) |
||||
{ |
||||
const int n = (attempt + 1) / 2; |
||||
const QRectF candidate = label.translated(0, (attempt % 2 ? n : -n) * step); |
||||
if (candidate.top() < bounds.top() + 4 || candidate.bottom() > bounds.bottom() - 4) { |
||||
continue; |
||||
} |
||||
bool clear = true; |
||||
for (const QRectF& obstacle : labelObstacles) |
||||
{ |
||||
if (candidate.adjusted(-2, -2, 2, 2).intersects(obstacle)) |
||||
{ |
||||
clear = false; |
||||
break; |
||||
} |
||||
} |
||||
if (clear) |
||||
{ |
||||
label = candidate; |
||||
break; |
||||
} |
||||
} |
||||
labelObstacles.append(label); |
||||
}; |
||||
for (Route& route : m_routes) |
||||
{ |
||||
const qreal before = route.markerRect.center().y(); |
||||
placeLabel(route.markerRect); |
||||
const qreal dy = route.markerRect.center().y() - before; |
||||
if (route.stubTip != 0 && !qFuzzyIsNull(dy)) |
||||
{ |
||||
// Keep a moved stub label on the end of its own line.
|
||||
QPointF& tip = route.stubTip > 0 ? route.to : route.from; |
||||
tip.ry() += dy; |
||||
route.path = connectionPath(route.from, route.to, route.fromSide, route.toSide, |
||||
route.sourceBox, route.targetBox, bounds); |
||||
route.length = route.path.length(); |
||||
} |
||||
} |
||||
for (Route& route : m_routes) { |
||||
placeLabel(route.flowLabelRect); |
||||
} |
||||
// Only now are the routes final, so build the painted region.
|
||||
for (Route& route : m_routes) |
||||
{ |
||||
QRegion routeRegion(maskStroker.createStroke(route.path).toFillPolygon().toPolygon(), Qt::WindingFill); |
||||
routeRegion += QRectF(route.from.x() - 9, route.from.y() - 9, 18, 18).toAlignedRect(); |
||||
routeRegion += QRectF(route.to.x() - 9, route.to.y() - 9, 18, 18).toAlignedRect(); |
||||
for (const QRectF& label : {route.markerRect, route.flowLabelRect}) |
||||
{ |
||||
if (!label.isEmpty()) { |
||||
routeRegion += label.toAlignedRect().adjusted(-2, -2, 2, 2); |
||||
} |
||||
} |
||||
route.bounds = routeRegion.boundingRect(); |
||||
paintedRegion += routeRegion; |
||||
} |
||||
|
||||
paintedRegion &= m_clipRegion; |
||||
// A full-size widget above QOpenGLWidget spectra can occlude their entire
|
||||
// viewport. Give the overlay only the pixels needed by its drawing.
|
||||
if (paintedRegion.isEmpty()) { |
||||
paintedRegion = QRegion(0, 0, 1, 1); |
||||
} |
||||
if (mask() != paintedRegion) |
||||
{ |
||||
// An empty mask means the whole widget was painted.
|
||||
const QRegion oldMask = mask().isEmpty() ? QRegion(rect()) : mask(); |
||||
setMask(paintedRegion); |
||||
// setMask() asks the QMdiArea to repaint what the overlay no longer covers,
|
||||
// but the opaque viewport above it is not repainted, leaving trails of old
|
||||
// routes. Repaint the viewport (and its sub windows) there explicitly.
|
||||
const QRegion exposed = oldMask - paintedRegion; |
||||
if (!exposed.isEmpty()) { |
||||
m_mdi->viewport()->update(exposed.translated(pos() - m_mdi->viewport()->pos())); |
||||
} |
||||
return true; |
||||
} |
||||
return false; |
||||
} |
||||
|
||||
QVector<ConnectionOverlay::Pulse> ConnectionOverlay::pulses() const |
||||
{ |
||||
QVector<Pulse> result; |
||||
for (const Route& route : m_routes) |
||||
{ |
||||
if (route.direction == NoDirection || route.length <= 32) { |
||||
continue; |
||||
} |
||||
const int flowCount = route.direction == BothDirections ? 2 : 1; |
||||
const int pulsesPerFlow = route.length > 360 ? 2 : 1; |
||||
for (int flow = 0; flow < flowCount; ++flow) |
||||
{ |
||||
const bool reverse = route.direction == Reverse || (route.direction == BothDirections && flow == 1); |
||||
for (int pulse = 0; pulse < pulsesPerFlow; ++pulse) |
||||
{ |
||||
qreal progress = m_phase + qreal(pulse) / pulsesPerFlow; |
||||
if (progress >= 1.0) { |
||||
progress -= 1.0; |
||||
} |
||||
if (reverse) { |
||||
progress = 1.0 - progress; |
||||
} |
||||
const qreal tailProgress = qBound<qreal>(0, progress + (reverse ? 0.025 : -0.025), 1); |
||||
result.append({route.path.pointAtPercent(tailProgress), route.path.pointAtPercent(progress), route.color}); |
||||
} |
||||
} |
||||
} |
||||
return result; |
||||
} |
||||
|
||||
QRegion ConnectionOverlay::pulsesRegion(const QVector<Pulse>& pulses) const |
||||
{ |
||||
QRegion region; |
||||
for (const Pulse& pulse : pulses) { |
||||
region += QRectF(pulse.tail, pulse.head).normalized().adjusted(-9, -9, 9, 9).toAlignedRect(); |
||||
} |
||||
return region; |
||||
} |
||||
|
||||
void ConnectionOverlay::animate() |
||||
{ |
||||
if (!isVisible()) { |
||||
return; // Workspace is a background tab, or minimized.
|
||||
} |
||||
// Only the pulses move, so repaint just where they were and where they are now.
|
||||
m_phase = (m_clock.elapsed() % 2400) / 2400.0; |
||||
const QRegion region = pulsesRegion(pulses()); |
||||
const QRegion dirty = m_pulseRegion | region; |
||||
m_pulseRegion = region; |
||||
if (!dirty.isEmpty()) { |
||||
update(dirty); |
||||
} |
||||
} |
||||
|
||||
void ConnectionOverlay::paintEvent(QPaintEvent *event) |
||||
{ |
||||
// Paint current geometry rather than a stale cache. This paint is clipped to the
|
||||
// old mask, so repaint again only if the mask changed.
|
||||
if (m_layoutDirty && computeLayout()) { |
||||
update(); |
||||
} |
||||
QPainter painter(this); |
||||
painter.setRenderHint(QPainter::Antialiasing); |
||||
painter.setClipRegion(m_clipRegion & event->region()); |
||||
const QRegion& dirty = event->region(); |
||||
|
||||
for (const Route& route : m_routes) |
||||
{ |
||||
if (!dirty.intersects(route.bounds)) { |
||||
continue; |
||||
} |
||||
const QColor& color = route.color; |
||||
// drawPath also fills with the current brush. The preceding edge draws
|
||||
// its endpoint dots with a solid brush, so clear it before every path.
|
||||
painter.setBrush(Qt::NoBrush); |
||||
painter.setPen(QPen(QColor(color.red(), color.green(), color.blue(), 35), 6, |
||||
Qt::SolidLine, Qt::RoundCap, Qt::RoundJoin)); |
||||
painter.drawPath(route.path); |
||||
painter.setPen(QPen(QColor(color.red(), color.green(), color.blue(), 180), 2.2, |
||||
route.kind == PipeLink ? Qt::DashLine : Qt::SolidLine, Qt::RoundCap, Qt::RoundJoin)); |
||||
painter.drawPath(route.path); |
||||
painter.setBrush(QColor(color.red(), color.green(), color.blue(), 220)); |
||||
painter.setPen(QPen(palette().window().color(), 1.5)); |
||||
painter.drawEllipse(route.from, 4, 4); |
||||
painter.drawEllipse(route.to, 4, 4); |
||||
} |
||||
|
||||
for (const Pulse& pulse : pulses()) |
||||
{ |
||||
const QColor& color = pulse.color; |
||||
painter.setBrush(Qt::NoBrush); |
||||
painter.setPen(QPen(QColor(color.red(), color.green(), color.blue(), 210), 4, |
||||
Qt::SolidLine, Qt::RoundCap)); |
||||
painter.drawLine(pulse.tail, pulse.head); |
||||
painter.setPen(Qt::NoPen); |
||||
painter.setBrush(QColor(color.red(), color.green(), color.blue(), 130)); |
||||
painter.drawEllipse(pulse.head, 7, 7); |
||||
painter.setBrush(QColor(255, 255, 255, 245)); |
||||
painter.drawEllipse(pulse.head, 3, 3); |
||||
} |
||||
|
||||
for (const Route& route : m_routes) |
||||
{ |
||||
if (!route.flowLabel.isEmpty() && dirty.intersects(route.flowLabelRect.toAlignedRect())) |
||||
{ |
||||
painter.setPen(QPen(route.color, 1)); |
||||
painter.setBrush(QColor(24, 28, 32, 235)); |
||||
painter.drawRoundedRect(route.flowLabelRect, 3, 3); |
||||
painter.setPen(Qt::white); |
||||
painter.drawText(route.flowLabelRect, Qt::AlignCenter, route.flowLabel); |
||||
} |
||||
if (!route.marker.isEmpty() && dirty.intersects(route.markerRect.toAlignedRect())) |
||||
{ |
||||
painter.setPen(Qt::NoPen); |
||||
painter.setBrush(QColor(24, 28, 32, 235)); |
||||
painter.drawRoundedRect(route.markerRect, 3, 3); |
||||
painter.setPen(Qt::white); |
||||
painter.drawText(route.markerRect, Qt::AlignCenter, route.marker); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,118 @@
@@ -0,0 +1,118 @@
|
||||
///////////////////////////////////////////////////////////////////////////////////
|
||||
// Copyright (C) 2026 Jon Beniston, M7RCE <jon@beniston.com> //
|
||||
// Some code by AI //
|
||||
// //
|
||||
// This program is free software; you can redistribute it and/or modify //
|
||||
// it under the terms of the GNU General Public License as published by //
|
||||
// the Free Software Foundation as version 3 of the License, or //
|
||||
// (at your option) any later version. //
|
||||
// //
|
||||
// This program is distributed in the hope that it will be useful, //
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of //
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the //
|
||||
// GNU General Public License V3 for more details. //
|
||||
// //
|
||||
// You should have received a copy of the GNU General Public License //
|
||||
// along with this program. If not, see <http://www.gnu.org/licenses/>. //
|
||||
///////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef SDRGUI_GUI_CONNECTIONOVERLAY_H_ |
||||
#define SDRGUI_GUI_CONNECTIONOVERLAY_H_ |
||||
|
||||
#include <QElapsedTimer> |
||||
#include <QColor> |
||||
#include <QHash> |
||||
#include <QList> |
||||
#include <QPainterPath> |
||||
#include <QRegion> |
||||
#include <QVector> |
||||
#include <QPointer> |
||||
#include <QTimer> |
||||
#include <QWidget> |
||||
|
||||
class QMdiArea; |
||||
class QMdiSubWindow; |
||||
|
||||
// A non-interactive drawing layer above one workspace's MDI windows, showing connections between windows.
|
||||
class ConnectionOverlay : public QWidget |
||||
{ |
||||
Q_OBJECT |
||||
public: |
||||
enum Kind { DeviceLink, PipeLink }; |
||||
enum Direction { NoDirection, Forward, Reverse, BothDirections }; |
||||
|
||||
struct Connection { |
||||
QPointer<QMdiSubWindow> source; |
||||
QPointer<QMdiSubWindow> target; |
||||
QString sourceLabel; |
||||
QString targetLabel; |
||||
QString flowLabel; |
||||
int sourceWorkspace = -1; |
||||
int targetWorkspace = -1; |
||||
Kind kind = DeviceLink; |
||||
Direction direction = Forward; |
||||
QColor color; |
||||
}; |
||||
|
||||
explicit ConnectionOverlay(QMdiArea *mdi); |
||||
void setConnections(const QList<Connection>& connections); |
||||
void setOverlayVisible(bool visible); |
||||
|
||||
protected: |
||||
bool eventFilter(QObject *object, QEvent *event) override; |
||||
void changeEvent(QEvent *event) override; |
||||
void showEvent(QShowEvent *event) override; |
||||
void paintEvent(QPaintEvent *event) override; |
||||
|
||||
private: |
||||
// Geometry for one drawn connection, cached until windows move or connections change.
|
||||
struct Route { |
||||
QPainterPath path; |
||||
qreal length = 0; |
||||
QRect bounds; |
||||
QPointF from; |
||||
QPointF to; |
||||
QColor color; |
||||
Kind kind = DeviceLink; |
||||
Direction direction = Forward; |
||||
QString flowLabel; |
||||
QRectF flowLabelRect; |
||||
QString marker; |
||||
QRectF markerRect; |
||||
// Inputs to connectionPath(), kept so a stub can be rerouted to follow its label.
|
||||
int fromSide = 0; |
||||
int toSide = 0; |
||||
QRectF sourceBox; |
||||
QRectF targetBox; |
||||
int stubTip = 0; // Cross-workspace stub: 1 if to is its tip, -1 if from is
|
||||
}; |
||||
struct Pulse { |
||||
QPointF tail; |
||||
QPointF head; |
||||
QColor color; |
||||
}; |
||||
|
||||
QMdiArea *m_mdi; |
||||
QList<Connection> m_connections; |
||||
QHash<QMdiSubWindow*, QPointer<QWidget>> m_indexLabels; |
||||
QList<QPointer<QObject>> m_watched; |
||||
QVector<Route> m_routes; |
||||
QRegion m_clipRegion; // Everything except the title ID labels
|
||||
QRegion m_pulseRegion; // Area covered by the pulses last painted
|
||||
qreal m_phase = 0; |
||||
bool m_layoutDirty = true; // Cached routes no longer match the windows
|
||||
bool m_relayoutPending = false; // A queued relayout() is outstanding
|
||||
QElapsedTimer m_clock; |
||||
QTimer m_animationTimer; |
||||
|
||||
static bool sameConnections(const QList<Connection>& a, const QList<Connection>& b); |
||||
void watchWindows(); |
||||
void invalidateLayout(); |
||||
void relayout(); |
||||
bool computeLayout(); // Returns true if the mask changed
|
||||
QVector<Pulse> pulses() const; |
||||
QRegion pulsesRegion(const QVector<Pulse>& pulses) const; |
||||
void animate(); |
||||
}; |
||||
|
||||
#endif // SDRGUI_GUI_CONNECTIONOVERLAY_H_
|
||||
|
After Width: | Height: | Size: 539 B |
Loading…
Reference in new issue