QuickGraphLib 0.1.0a18__tar.gz → 0.1.0a19__tar.gz

{quickgraphlib-0.1.0a18 → quickgraphlib-0.1.0a19}/.gitignore

@@ -2,6 +2,7 @@
 .mypy_cache
 __pycache__
 venv
+build/
 dist
 *.egg-info
 aqtinstall.log

{quickgraphlib-0.1.0a18 → quickgraphlib-0.1.0a19}/.pre-commit-config.yaml

@@ -18,6 +18,11 @@ repos:
         entry: venv/Scripts/ruff.exe format
         language: system
         types: [python]
+      - id: clang_format
+        name: "Format C/C++ files"
+        entry: venv/Scripts/clang-format.exe -i
+        types_or: [c, c++]
+        language: system
       - id: gersemi
         name: gersemi
         entry: venv/Scripts/gersemi.exe -i

{quickgraphlib-0.1.0a18 → quickgraphlib-0.1.0a19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: QuickGraphLib
-Version: 0.1.0a18
+Version: 0.1.0a19
 Summary: A scientific graphing library for QtQuick
 Author-Email: Matthew Joyce <matthew.joyce@refeyn.com>
 License: MIT License

{quickgraphlib-0.1.0a18 → quickgraphlib-0.1.0a19}/QuickGraphLib/DataTypes.hpp

@@ -12,11 +12,11 @@ class QGL_EXPORT QGLPolygonF : public QPolygonF {
    public:
     using QPolygonF::QPolygonF;
     QGLPolygonF() = default;
-    QGLPolygonF(const QList<QPointF> &v) : QPolygonF(v) {}
-    QGLPolygonF(const QPolygonF &v) : QPolygonF(v) {}
-    QGLPolygonF(QList<QPointF> &&v) noexcept : QPolygonF(std::move(v)) {}
-    QGLPolygonF(QPolygonF &&v) noexcept : QPolygonF(std::move(v)) {}
-    inline void swap(QGLPolygonF &other) { QPolygonF::swap(other); }
+    QGLPolygonF(const QList<QPointF>& v) : QPolygonF(v) {}
+    QGLPolygonF(const QPolygonF& v) : QPolygonF(v) {}
+    QGLPolygonF(QList<QPointF>&& v) noexcept : QPolygonF(std::move(v)) {}
+    QGLPolygonF(QPolygonF&& v) noexcept : QPolygonF(std::move(v)) {}
+    inline void swap(QGLPolygonF& other) { QPolygonF::swap(other); }
     operator QVariant() const;
 };
 Q_DECLARE_SHARED(QGLPolygonF)
@@ -25,9 +25,9 @@ class QGL_EXPORT QGLDoubleList : public QList<qreal> {
    public:
     using QList<qreal>::QList;
     QGLDoubleList() = default;
-    QGLDoubleList(const QList<qreal> &v) : QList<qreal>(v) {}
-    QGLDoubleList(QList<qreal> &&v) noexcept : QList<qreal>(std::move(v)) {}
-    inline void swap(QGLDoubleList &other) { QList<qreal>::swap(other); }
+    QGLDoubleList(const QList<qreal>& v) : QList<qreal>(v) {}
+    QGLDoubleList(QList<qreal>&& v) noexcept : QList<qreal>(std::move(v)) {}
+    inline void swap(QGLDoubleList& other) { QList<qreal>::swap(other); }
     operator QVariant() const;
 };
 Q_DECLARE_SHARED(QGLDoubleList)

quickgraphlib-0.1.0a19/QuickGraphLib/GraphItems/BaseHandles.qml

@@ -0,0 +1,76 @@
+// SPDX-FileCopyrightText: Copyright (c) 2024 Refeyn Ltd and other QuickGraphLib contributors
+// SPDX-License-Identifier: MIT
+
+import QtQuick
+
+/*!
+    \qmltype BaseHandles
+    \inqmlmodule QuickGraphLib.GraphItems
+    \inherits QtQuick::Item
+    \internal
+    \brief Shared base contract for graph handle overlays.
+
+    BaseHandles centralizes the common styling, click and movement signal contract used by
+    concrete handle overlay items. Applications should instantiate the concrete handle types rather
+    than BaseHandles directly.
+*/
+
+Item {
+    id: root
+
+    property bool _bodyHovered: false
+
+    /*!
+        Must be assigned the data transform of the graph area this handle item is paired to.
+
+        \sa GraphArea::dataTransform
+    */
+    required property matrix4x4 dataTransform
+    /*!
+        The normal handle fill color.
+    */
+    property color handleFillColor: "white"
+    /*!
+        The handle fill color used while hovered.
+    */
+    property color handleHoverFillColor: "#fff6bf"
+    /*!
+        The handle fill color used while selected or dragged.
+    */
+    property color handleSelectedFillColor: "#ffd24d"
+    /*!
+        The handle outline color.
+    */
+    property color handleStrokeColor: "#333333"
+    /*!
+        The handle outline width.
+    */
+    property real handleStrokeWidth: 1
+    /*!
+        Whether handles should be visible.
+    */
+    property bool handlesVisible: selected
+    /*!
+        Whether the pointer is currently over the shape body.
+    */
+    readonly property bool hovered: enabled && _bodyHovered
+    /*!
+        Whether the handle item should be drawn in the selected state.
+    */
+    property bool selected: false
+
+    /*!
+        Emitted when the body of the handle item is clicked.
+    */
+    signal bodyClicked
+
+    /*!
+        Emitted when \a handle is clicked.
+    */
+    signal handleClicked(GraphHandle handle)
+
+    /*!
+        Emitted when \a handle has moved to \a position in data coordinates.
+    */
+    signal handleMoved(GraphHandle handle, point position)
+}

{quickgraphlib-0.1.0a18 → quickgraphlib-0.1.0a19}/QuickGraphLib/GraphItems/CMakeLists.txt

@@ -6,7 +6,9 @@ set(QGL_GI_QML_FILES
     AxVLine.qml
     BarHorizontal.qml
     BarVertical.qml
+    BaseHandles.qml
     BasicLegend.qml
+    GraphHandle.qml
     BoxPlotHorizontal.qml
     BoxPlotVertical.qml
     GraphItemDragHandler.qml
@@ -16,8 +18,18 @@ set(QGL_GI_QML_FILES
     AxVSpan.qml
     BasicLegendItem.qml
     Contour.qml
+    Ellipse.qml
+    EllipseHandles.qml
     Grid.qml
     Line.qml
+    LineSegmentHandles.qml
+    LineSegment.qml
+    Polygon.qml
+    PolygonHandles.qml
+    Polyline.qml
+    PolylineHandles.qml
+    Rectangle.qml
+    RectangleHandles.qml
     ColorMesh.qml
 )
 qt_add_qml_module(QuickGraphLibGraphItems

quickgraphlib-0.1.0a19/QuickGraphLib/GraphItems/Ellipse.qml

@@ -0,0 +1,59 @@
+// SPDX-FileCopyrightText: Copyright (c) 2024 Refeyn Ltd and other QuickGraphLib contributors
+// SPDX-License-Identifier: MIT
+
+import QtQuick
+import QtQuick.Shapes as QQS
+import QuickGraphLib as QuickGraphLib
+
+/*!
+    \qmltype Ellipse
+    \inqmlmodule QuickGraphLib.GraphItems
+    \inherits QtQuick::Shapes::ShapePath
+    \brief Displays an ellipse in data coordinates.
+
+    Draws an ellipse from a bounding Qt rect in data coordinates. The style can be adjusted using the
+    \l {ShapePath::fillColor} {fillColor}, \l {ShapePath::strokeColor} {strokeColor} and
+    \l {ShapePath::strokeWidth} {strokeWidth} properties.
+*/
+
+QQS.ShapePath {
+    id: root
+
+    readonly property real _dataBottom: _normalizedDataRect.bottom
+    readonly property point _dataCenter: Qt.point((_normalizedDataRect.left + _normalizedDataRect.right) / 2, (_normalizedDataRect.top + _normalizedDataRect.bottom) / 2)
+    readonly property real _dataLeft: _normalizedDataRect.left
+    readonly property real _dataRight: _normalizedDataRect.right
+    readonly property point _dataRightCenter: Qt.point(_dataRight, _dataCenter.y)
+    readonly property real _dataTop: _normalizedDataRect.top
+    readonly property point _dataTopCenter: Qt.point(_dataCenter.x, _dataTop)
+    readonly property point _mappedCenter: dataTransform.map(_dataCenter)
+    readonly property rect _mappedRect: dataTransform.mapRect(_normalizedDataRect)
+    readonly property point _mappedRightCenter: dataTransform.map(_dataRightCenter)
+    readonly property point _mappedTopCenter: dataTransform.map(_dataTopCenter)
+    readonly property rect _normalizedDataRect: QuickGraphLib.Helpers.normalizedRect(dataRect)
+    readonly property real _radiusX: _mappedRect.width / 2
+    readonly property real _radiusY: _mappedRect.height / 2
+    /*!
+        The ellipse bounding rectangle in data coordinates.
+    */
+    required property rect dataRect
+
+    /*!
+        Must be assigned the data transform of the graph area this ellipse is paired to.
+
+        \sa GraphArea::dataTransform
+    */
+    required property matrix4x4 dataTransform
+
+    fillColor: "transparent"
+    pathHints: QQS.ShapePath.PathConvex | QQS.ShapePath.PathSolid
+
+    PathAngleArc {
+        centerX: root._mappedCenter.x
+        centerY: root._mappedCenter.y
+        radiusX: root._radiusX
+        radiusY: root._radiusY
+        startAngle: 0
+        sweepAngle: 360
+    }
+}

quickgraphlib-0.1.0a19/QuickGraphLib/GraphItems/EllipseHandles.qml

@@ -0,0 +1,340 @@
+// SPDX-FileCopyrightText: Copyright (c) 2024 Refeyn Ltd and other QuickGraphLib contributors
+// SPDX-License-Identifier: MIT
+
+import QtQuick
+import QuickGraphLib as QuickGraphLib
+
+/*!
+    \qmltype EllipseHandles
+    \inqmlmodule QuickGraphLib.GraphItems
+    \inherits QtQuick::Item
+    \brief Interaction overlay for an elliptical region of interest.
+
+    EllipseHandles provides selection, body dragging and optional cardinal resize handles for an
+    ellipse. It does not own the ellipse data; instead it emits movement and resize signals so
+    applications can update their own model.
+*/
+
+BaseHandles {
+    id: root
+
+    enum HandleMode {
+        NoHandles,
+        Cardinal,
+        CardinalAndCenter
+    }
+
+    property bool _bodyDragging: false
+    readonly property point _bottomHandlePoint: Qt.point(_centerPoint.x, _dataBottom)
+    readonly property point _centerPoint: Qt.point((_dataLeft + _dataRight) / 2, (_dataTop + _dataBottom) / 2)
+    readonly property real _dataBottom: Math.max(dataRect.y, dataRect.y + dataRect.height)
+    readonly property real _dataLeft: Math.min(dataRect.x, dataRect.x + dataRect.width)
+    readonly property real _dataRight: Math.max(dataRect.x, dataRect.x + dataRect.width)
+    readonly property real _dataTop: Math.min(dataRect.y, dataRect.y + dataRect.height)
+    property point _lastDragPoint: Qt.point(0, 0)
+    readonly property point _leftHandlePoint: Qt.point(_dataLeft, _centerPoint.y)
+    readonly property point _mappedBottomHandle: dataTransform.map(_bottomHandlePoint)
+    readonly property point _mappedCenter: dataTransform.map(_centerPoint)
+    readonly property point _mappedLeftHandle: dataTransform.map(_leftHandlePoint)
+    readonly property point _mappedRightHandle: dataTransform.map(_rightHandlePoint)
+    readonly property point _mappedTopHandle: dataTransform.map(_topHandlePoint)
+    readonly property point _rightHandlePoint: Qt.point(_dataRight, _centerPoint.y)
+    readonly property point _topHandlePoint: Qt.point(_centerPoint.x, _dataTop)
+    /*!
+        A direct reference to the bottom resize handle.
+    */
+    readonly property alias bottomHandle: bottomGraphHandle
+    /*!
+        Optional visual delegate used for cardinal resize handles.
+
+        The delegate can read the handle state through \c parent.handle.
+    */
+    property Component cardinalHandleDelegate: null
+    /*!
+        The default shape used for cardinal resize handles.
+    */
+    property int cardinalHandleShape: GraphHandle.Square
+    /*!
+        Whether cardinal resize handles can resize the ellipse.
+    */
+    property bool cardinalHandlesMovable: true
+    /*!
+        A direct reference to the optional center move handle.
+    */
+    readonly property alias centerHandle: centerGraphHandle
+    /*!
+        Optional visual delegate used for the center move handle.
+
+        The delegate can read the handle state through \c parent.handle.
+    */
+    property Component centerHandleDelegate: null
+    /*!
+        The default shape used for the center move handle.
+    */
+    property int centerHandleShape: GraphHandle.Circle
+    /*!
+        The visual size and hit target size of the center handle.
+    */
+    property real centerHandleSize: handleSize
+    /*!
+        The ellipse bounding rectangle in data coordinates.
+    */
+    required property rect dataRect
+
+    /*!
+        Which built-in handles should be shown.
+    */
+    property int handleMode: EllipseHandles.Cardinal
+    /*!
+        The visual size and hit target size of cardinal resize handles.
+    */
+    property real handleSize: 8
+    /*!
+        GraphHandle objects rendered by this item.
+    */
+    readonly property var handles: [leftGraphHandle, rightGraphHandle, topGraphHandle, bottomGraphHandle, centerGraphHandle]
+
+    /*!
+        A direct reference to the left resize handle.
+    */
+    readonly property alias leftHandle: leftGraphHandle
+    /*!
+        The minimum height emitted when resize handles are dragged toward the opposite edge.
+    */
+    property real minimumDataHeight: 0
+    /*!
+        The minimum width emitted when resize handles are dragged toward the opposite edge.
+    */
+    property real minimumDataWidth: 0
+    /*!
+        Whether dragging the ellipse body should emit movement signals.
+    */
+    property bool movable: true
+    /*!
+        A direct reference to the right resize handle.
+    */
+    readonly property alias rightHandle: rightGraphHandle
+    /*!
+        A direct reference to the top resize handle.
+    */
+    readonly property alias topHandle: topGraphHandle
+
+    /*!
+        Emitted when the ellipse body has moved by \a delta in data coordinates.
+    */
+    signal moved(point delta)
+    /*!
+        Emitted when a handle has resized the ellipse to \a dataRect.
+    */
+    signal resized(rect dataRect)
+
+    function _bodyScenePoint(localPoint) {
+        return root.mapFromItem(bodyMouseArea, localPoint);
+    }
+    function _containsBodyPoint(localPoint) {
+        return _containsBodyScenePoint(_bodyScenePoint(localPoint));
+    }
+    function _containsBodyScenePoint(scenePoint) {
+        let radiusX = Math.abs(root._mappedRightHandle.x - root._mappedCenter.x);
+        let radiusY = Math.abs(root._mappedTopHandle.y - root._mappedCenter.y);
+        return QuickGraphLib.Helpers.isInsideEllipse(scenePoint, root._mappedCenter, radiusX, radiusY);
+    }
+    function _resizedFromHandle(handle, position) {
+        let minimumWidth = Math.max(0, root.minimumDataWidth);
+        let minimumHeight = Math.max(0, root.minimumDataHeight);
+        if (handle.objectName === "left") {
+            return QuickGraphLib.Helpers.clampedResizeRect(Qt.point(position.x, root._dataTop), Qt.point(root._dataRight, root._dataBottom), minimumWidth, 0, -1, -1);
+        }
+        if (handle.objectName === "right") {
+            return QuickGraphLib.Helpers.clampedResizeRect(Qt.point(position.x, root._dataBottom), Qt.point(root._dataLeft, root._dataTop), minimumWidth, 0, 1, 1);
+        }
+        if (handle.objectName === "top") {
+            return QuickGraphLib.Helpers.clampedResizeRect(Qt.point(root._dataLeft, position.y), Qt.point(root._dataRight, root._dataBottom), 0, minimumHeight, -1, -1);
+        }
+        if (handle.objectName === "bottom") {
+            return QuickGraphLib.Helpers.clampedResizeRect(Qt.point(root._dataRight, position.y), Qt.point(root._dataLeft, root._dataTop), 0, minimumHeight, 1, 1);
+        }
+        return root.dataRect;
+    }
+
+    height: parent ? parent.height : 0
+    width: parent ? parent.width : 0
+    x: 0
+    y: 0
+
+    MouseArea {
+        id: bodyMouseArea
+
+        property real _bodyBottom: Math.max(root._mappedTopHandle.y, root._mappedBottomHandle.y)
+        property real _bodyLeft: Math.min(root._mappedLeftHandle.x, root._mappedRightHandle.x)
+        property real _bodyRight: Math.max(root._mappedLeftHandle.x, root._mappedRightHandle.x)
+        property real _bodyTop: Math.min(root._mappedTopHandle.y, root._mappedBottomHandle.y)
+
+        cursorShape: root.movable && (root._bodyHovered || root._bodyDragging) ? Qt.SizeAllCursor : Qt.ArrowCursor
+        enabled: root.enabled
+        height: _bodyBottom - _bodyTop
+        hoverEnabled: true
+        width: _bodyRight - _bodyLeft
+        x: _bodyLeft
+        y: _bodyTop
+
+        onCanceled: {
+            root._bodyDragging = false;
+        }
+        onExited: {
+            root._bodyHovered = false;
+        }
+        onPositionChanged: event => {
+            root._bodyHovered = root._containsBodyPoint(Qt.point(event.x, event.y));
+            if (!root._bodyDragging || !root.movable)
+                return;
+            let currentPoint = root.dataTransform.inverted().map(root.mapFromItem(bodyMouseArea, Qt.point(event.x, event.y)));
+            let delta = Qt.point(currentPoint.x - root._lastDragPoint.x, currentPoint.y - root._lastDragPoint.y);
+            root._lastDragPoint = currentPoint;
+            root.moved(delta);
+        }
+        onPressed: event => {
+            if (!root._containsBodyPoint(Qt.point(event.x, event.y))) {
+                root._bodyDragging = false;
+                event.accepted = false;
+                return;
+            }
+            root._bodyDragging = true;
+            root.bodyClicked();
+            root._lastDragPoint = root.dataTransform.inverted().map(root.mapFromItem(bodyMouseArea, Qt.point(event.x, event.y)));
+        }
+        onReleased: {
+            root._bodyDragging = false;
+        }
+    }
+    GraphHandle {
+        id: leftGraphHandle
+
+        cursorShape: Qt.SizeHorCursor
+        dataTransform: root.dataTransform
+        delegate: root.cardinalHandleDelegate
+        fillColor: root.handleFillColor
+        hoverFillColor: root.handleHoverFillColor
+        movable: root.cardinalHandlesMovable
+        objectName: "left"
+        position: root._leftHandlePoint
+        role: GraphHandle.Resize
+        selected: root.selected
+        selectedFillColor: root.handleSelectedFillColor
+        shape: root.cardinalHandleShape
+        size: root.handleSize
+        strokeColor: root.handleStrokeColor
+        strokeWidth: root.handleStrokeWidth
+        visible: root.handlesVisible && root.handleMode !== EllipseHandles.NoHandles
+
+        onClicked: root.handleClicked(leftGraphHandle)
+        onMoved: position => {
+            root.handleMoved(leftGraphHandle, position);
+            root.resized(root._resizedFromHandle(leftGraphHandle, position));
+        }
+    }
+    GraphHandle {
+        id: rightGraphHandle
+
+        cursorShape: Qt.SizeHorCursor
+        dataTransform: root.dataTransform
+        delegate: root.cardinalHandleDelegate
+        fillColor: root.handleFillColor
+        hoverFillColor: root.handleHoverFillColor
+        movable: root.cardinalHandlesMovable
+        objectName: "right"
+        position: root._rightHandlePoint
+        role: GraphHandle.Resize
+        selected: root.selected
+        selectedFillColor: root.handleSelectedFillColor
+        shape: root.cardinalHandleShape
+        size: root.handleSize
+        strokeColor: root.handleStrokeColor
+        strokeWidth: root.handleStrokeWidth
+        visible: root.handlesVisible && root.handleMode !== EllipseHandles.NoHandles
+
+        onClicked: root.handleClicked(rightGraphHandle)
+        onMoved: position => {
+            root.handleMoved(rightGraphHandle, position);
+            root.resized(root._resizedFromHandle(rightGraphHandle, position));
+        }
+    }
+    GraphHandle {
+        id: topGraphHandle
+
+        cursorShape: Qt.SizeVerCursor
+        dataTransform: root.dataTransform
+        delegate: root.cardinalHandleDelegate
+        fillColor: root.handleFillColor
+        hoverFillColor: root.handleHoverFillColor
+        movable: root.cardinalHandlesMovable
+        objectName: "top"
+        position: root._topHandlePoint
+        role: GraphHandle.Resize
+        selected: root.selected
+        selectedFillColor: root.handleSelectedFillColor
+        shape: root.cardinalHandleShape
+        size: root.handleSize
+        strokeColor: root.handleStrokeColor
+        strokeWidth: root.handleStrokeWidth
+        visible: root.handlesVisible && root.handleMode !== EllipseHandles.NoHandles
+
+        onClicked: root.handleClicked(topGraphHandle)
+        onMoved: position => {
+            root.handleMoved(topGraphHandle, position);
+            root.resized(root._resizedFromHandle(topGraphHandle, position));
+        }
+    }
+    GraphHandle {
+        id: bottomGraphHandle
+
+        cursorShape: Qt.SizeVerCursor
+        dataTransform: root.dataTransform
+        delegate: root.cardinalHandleDelegate
+        fillColor: root.handleFillColor
+        hoverFillColor: root.handleHoverFillColor
+        movable: root.cardinalHandlesMovable
+        objectName: "bottom"
+        position: root._bottomHandlePoint
+        role: GraphHandle.Resize
+        selected: root.selected
+        selectedFillColor: root.handleSelectedFillColor
+        shape: root.cardinalHandleShape
+        size: root.handleSize
+        strokeColor: root.handleStrokeColor
+        strokeWidth: root.handleStrokeWidth
+        visible: root.handlesVisible && root.handleMode !== EllipseHandles.NoHandles
+
+        onClicked: root.handleClicked(bottomGraphHandle)
+        onMoved: position => {
+            root.handleMoved(bottomGraphHandle, position);
+            root.resized(root._resizedFromHandle(bottomGraphHandle, position));
+        }
+    }
+    GraphHandle {
+        id: centerGraphHandle
+
+        cursorShape: Qt.SizeAllCursor
+        dataTransform: root.dataTransform
+        delegate: root.centerHandleDelegate
+        fillColor: root.handleFillColor
+        hoverFillColor: root.handleHoverFillColor
+        movable: root.movable
+        objectName: "center"
+        position: root._centerPoint
+        role: GraphHandle.Move
+        selected: root.selected
+        selectedFillColor: root.handleSelectedFillColor
+        shape: root.centerHandleShape
+        size: root.centerHandleSize
+        strokeColor: root.handleStrokeColor
+        strokeWidth: root.handleStrokeWidth
+        visible: root.handlesVisible && root.handleMode === EllipseHandles.CardinalAndCenter
+
+        onClicked: root.handleClicked(centerGraphHandle)
+        onMoved: position => {
+            root.handleMoved(centerGraphHandle, position);
+            root.moved(Qt.point(position.x - centerGraphHandle.position.x, position.y - centerGraphHandle.position.y));
+        }
+    }
+}