Add Node Processing Status feature (#494)

* wip: adds NodeValidationState info to NodeDelegateModel

* makes the nodeObject red in case of invalid state and adds a tooltip for error msg

* adds warning state and adapts calculator example

* adds validation icon and adapts calculation example

* core improvements to develop node processing status

* first commit on the creation of a processing status example

* fixes nodeprocessingstatus cast

* creation of random gen example, and fix of icon color

* Connect delegate UI update signal

* fix random number node dynamic

* clean up test code in multiplication node

* revert unnecessary changes in multiplication model

* revert unnecessary changes

* solve icon size and refactor NodeProcessingStatus code

* remove duplicate code

* add space to better organize processing status in node display

* remove processing value default value

* fix bugs in node processing status

* add Q_DECLARE_METATYPE to solve linux build problems

* declaring metatype in the correct place

* uniformizes icon files attributes

* removes commented code

* improves processing status icon resolution

* solves situations where icons should not appear

* adds docstring to each nodeprocessingstatus

* adds possibility to change the node processing status icon style

* moves all status logic to NodeStyle

* removes unnecessary code

* adds declaration of QPixmap

---------

Co-authored-by: Taiguara Tupinambás <[email protected]>

Author: g-abilio

examples/calculator/DivisionModel.hpp

@@ -59,23 +59,23 @@ class DivisionModel : public MathOperationDataModel
         if (n2 && (n2->number() == 0.0)) {
             state._state = QtNodes::NodeValidationState::State::Error;
             state._stateMessage = QStringLiteral("Division by zero error");
-            setValidatonState(state);
+            setValidationState(state);
             _result.reset();
         } else if ( n2 && (n2->number() < 1e-5)) {
             state._state = QtNodes::NodeValidationState::State::Warning;
             state._stateMessage = QStringLiteral("Very small divident. Result might overflow");
-            setValidatonState(state);
+            setValidationState(state);
             if (n1) {
                 _result = std::make_shared<DecimalData>(n1->number() / n2->number());
             } else {
                 _result.reset();
             }
         } else if (n1 && n2) {
-            setValidatonState(state);
+            setValidationState(state);
             _result = std::make_shared<DecimalData>(n1->number() / n2->number());
         } else {
             QtNodes::NodeValidationState state;
-            setValidatonState(state);
+            setValidationState(state);
             _result.reset();
         }
 

examples/calculator/LongProcessingRandomNumber.hpp

@@ -0,0 +1,83 @@
+#pragma once
+
+#include <QtNodes/NodeDelegateModel>
+#include <QTimer>
+#include <QtCore/QObject>
+#include <QtWidgets/QLabel>
+#include <QtCore/QRandomGenerator64>
+
+#include "MathOperationDataModel.hpp"
+#include "DecimalData.hpp"
+
+/// The model generates a random value in a long processing schema,
+/// as it should demonstrate the usage of the NodeProcessingStatus.
+/// The random number is generate in the [n1, n2] interval.
+class RandomNumberModel : public MathOperationDataModel
+{
+public:
+    RandomNumberModel() {
+        this->setNodeProcessingStatus(QtNodes::NodeProcessingStatus::Empty);
+
+
+        QObject::connect(this, &NodeDelegateModel::computingStarted, this, [this]() {
+            if (_number1.lock() && _number2.lock()) {
+                this->setNodeProcessingStatus(
+                    QtNodes::NodeProcessingStatus::Processing);
+            }
+
+            emit requestNodeUpdate();
+        });
+        QObject::connect(this, &NodeDelegateModel::computingFinished, this, [this]() {
+            this->setNodeProcessingStatus(
+                QtNodes::NodeProcessingStatus::Updated);
+
+            emit requestNodeUpdate();
+        });
+    }
+    virtual ~RandomNumberModel() {}
+
+public:
+    QString caption() const override { return QStringLiteral("Random Number"); }
+
+    QString name() const override { return QStringLiteral("Random Number"); }
+
+private:
+    void compute() override
+    {
+        Q_EMIT computingStarted();
+        PortIndex const outPortIndex = 0;
+
+        auto n1 = _number1.lock();
+        auto n2 = _number2.lock();
+
+        QTimer *timer = new QTimer(this);
+        timer->start(1000);
+        int secondsRemaining = 3;
+        connect(timer, &QTimer::timeout, this, [=]() mutable {
+            if (--secondsRemaining <= 0) {
+                timer->stop();
+                if (n1 && n2) {
+                    double a = n1->number();
+                    double b = n2->number();
+
+                    if (a > b) {
+                        setNodeProcessingStatus(QtNodes::NodeProcessingStatus::Failed);
+
+                        emit requestNodeUpdate();
+                        return;
+                    }
+
+                    double upper = std::nextafter(b, std::numeric_limits<double>::max());
+                    double randomValue = QRandomGenerator::global()->generateDouble() * (upper - a) + a;
+
+                    _result = std::make_shared<DecimalData>(randomValue);
+                    Q_EMIT computingFinished();
+                } else {
+                    _result.reset();
+                }
+
+                Q_EMIT dataUpdated(outPortIndex);
+            }
+        });
+    }
+};

examples/calculator/headless_main.cpp

@@ -1,5 +1,6 @@
 #include "AdditionModel.hpp"
 #include "DivisionModel.hpp"
+#include "LongProcessingRandomNumber.hpp"
 #include "MultiplicationModel.hpp"
 #include "NumberDisplayDataModel.hpp"
 #include "NumberSourceDataModel.hpp"
@@ -27,6 +28,8 @@ static std::shared_ptr<NodeDelegateModelRegistry> registerDataModels()
 
     ret->registerModel<DivisionModel>("Operators");
 
+    ret->registerModel<RandomNumberModel>("Operators");
+
     return ret;
 }
 

examples/calculator/main.cpp

@@ -14,6 +14,7 @@
 
 #include "AdditionModel.hpp"
 #include "DivisionModel.hpp"
+#include "LongProcessingRandomNumber.hpp"
 #include "MultiplicationModel.hpp"
 #include "NumberDisplayDataModel.hpp"
 #include "NumberSourceDataModel.hpp"
@@ -40,6 +41,8 @@ static std::shared_ptr<NodeDelegateModelRegistry> registerDataModels()
 
     ret->registerModel<DivisionModel>("Operators");
 
+    ret->registerModel<RandomNumberModel>("Operators");
+
     return ret;
 }
 

include/QtNodes/internal/DefaultNodePainter.hpp

@@ -32,6 +32,8 @@ class NODE_EDITOR_PUBLIC DefaultNodePainter : public AbstractNodePainter
 
     void drawResizeRect(QPainter *painter, NodeGraphicsObject &ngo) const;
 
+    void drawProcessingIndicator(QPainter *painter, NodeGraphicsObject &ngo) const;
+
     void drawValidationIcon(QPainter *painter, NodeGraphicsObject &ngo) const;
 
 private:

include/QtNodes/internal/Definitions.hpp

@@ -33,6 +33,7 @@ enum class NodeRole {
     OutPortCount = 9,     ///< `unsigned int`
     Widget = 10,          ///< Optional `QWidget*` or `nullptr`
     ValidationState = 11, ///< Enum NodeValidationState of the node
+    ProcessingStatus = 12 ///< Enum NodeProcessingStatus of the node
 };
 Q_ENUM_NS(NodeRole)
 

include/QtNodes/internal/NodeDelegateModel.hpp

@@ -3,6 +3,7 @@
 #include <memory>
 
 #include <QMetaType>
+#include <QPixmap>
 #include <QtWidgets/QWidget>
 
 #include "Definitions.hpp"
@@ -19,9 +20,9 @@ namespace QtNodes {
 struct NodeValidationState
 {
     enum class State : int {
-        Valid = 0,      ///< All required inputs are present and correct.
-        Warning = 1,    ///< Some inputs are missing or questionable, processing may be unreliable.
-        Error = 2,      ///< Inputs or settings are invalid, preventing successful computation.
+        Valid = 0,   ///< All required inputs are present and correct.
+        Warning = 1, ///< Some inputs are missing or questionable, processing may be unreliable.
+        Error = 2,   ///< Inputs or settings are invalid, preventing successful computation.
     };
     bool isValid() { return _state == State::Valid; };
     QString const message() { return _stateMessage; }
@@ -31,6 +32,19 @@ struct NodeValidationState
     QString _stateMessage{""};
 };
 
+/**
+* Describes the node status, depending on its current situation
+*/
+enum class NodeProcessingStatus : int {
+    NoStatus = 0,   ///< No processing status is shown in the Node UI.
+    Updated = 1,    ///< Node is up to date; its outputs reflect the current inputs and parameters.
+    Processing = 2, ///< Node is currently running a computation.
+    Pending = 3,    ///< Node is out of date and waiting to be recomputed (e.g. manual/queued run).
+    Empty = 4,      ///< Node has no valid input data; nothing to compute.
+    Failed = 5,     ///< The last computation ended with an error.
+    Partial = 6,    ///< Computation finished incompletely; only partial results are available.
+};
+
 class StyleCollection;
 
 /**
@@ -39,7 +53,9 @@ class StyleCollection;
  * AbstractGraphModel.
  * This class is the same what has been called NodeDataModel before v3.
  */
-class NODE_EDITOR_PUBLIC NodeDelegateModel : public QObject, public Serializable
+class NODE_EDITOR_PUBLIC NodeDelegateModel
+    : public QObject
+    , public Serializable
 {
     Q_OBJECT
 
@@ -48,15 +64,15 @@ class NODE_EDITOR_PUBLIC NodeDelegateModel : public QObject, public Serializable
 
     virtual ~NodeDelegateModel() = default;
 
+    /// It is possible to hide caption in GUI
+    virtual bool captionVisible() const { return true; }
+
     /// Name makes this model unique
     virtual QString name() const = 0;
 
     /// Caption is used in GUI
     virtual QString caption() const = 0;
 
-    /// It is possible to hide caption in GUI
-    virtual bool captionVisible() const { return true; }
-
     /// Port caption is used in GUI to label individual ports
     virtual QString portCaption(PortType, PortIndex) const { return QString(); }
 
@@ -66,12 +82,16 @@ class NODE_EDITOR_PUBLIC NodeDelegateModel : public QObject, public Serializable
     /// Validation State will default to Valid, but you can manipulate it by overriding in an inherited class
     virtual NodeValidationState validationState() const { return _nodeValidationState; }
 
-public:
+    /// Returns the curent processing status
+    virtual NodeProcessingStatus processingStatus() const { return _processingStatus; }
+
     QJsonObject save() const override;
 
     void load(QJsonObject const &) override;
 
-    void setValidatonState(const NodeValidationState &validationState);
+    void setValidationState(const NodeValidationState &validationState);
+
+    void setNodeProcessingStatus(NodeProcessingStatus status);
 
     virtual unsigned int nPorts(PortType portType) const = 0;
 
@@ -80,8 +100,16 @@ class NODE_EDITOR_PUBLIC NodeDelegateModel : public QObject, public Serializable
     virtual ConnectionPolicy portConnectionPolicy(PortType, PortIndex) const;
 
     NodeStyle const &nodeStyle() const;
+
     void setNodeStyle(NodeStyle const &style);
 
+    QPixmap processingStatusIcon() const;
+
+    void setStatusIcon(NodeProcessingStatus status, const QPixmap &pixmap);
+
+    void setStatusIconStyle(ProcessingIconStyle const &style);
+
+public:
     virtual void setInData(std::shared_ptr<NodeData> nodeData, PortIndex const portIndex) = 0;
 
     virtual std::shared_ptr<NodeData> outData(PortIndex const port) = 0;
@@ -114,10 +142,20 @@ public Q_SLOTS:
     void dataInvalidated(PortIndex const index);
 
     void computingStarted();
+
     void computingFinished();
 
     void embeddedWidgetSizeUpdated();
 
+    /// Request an update of the node's UI.
+    /**
+     * Emit this signal whenever some internal state change requires
+     * the node to be repainted. The containing graph model will
+     * propagate the update to the scene.
+     */
+    void requestNodeUpdate();
+
+    /// Call this function before deleting the data associated with ports.
     /**
      * @brief Call this function before deleting the data associated with ports.
      * The function notifies the Graph Model and makes it remove and recompute the
@@ -144,8 +182,11 @@ public Q_SLOTS:
     NodeStyle _nodeStyle;
 
     NodeValidationState _nodeValidationState;
+
+    NodeProcessingStatus _processingStatus{NodeProcessingStatus::NoStatus};
 };
 
 } // namespace QtNodes
 
 Q_DECLARE_METATYPE(QtNodes::NodeValidationState)
+Q_DECLARE_METATYPE(QtNodes::NodeProcessingStatus)

include/QtNodes/internal/NodeGraphicsObject.hpp

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <QIcon>
 #include <QtCore/QUuid>
 #include <QtWidgets/QGraphicsObject>
 

include/QtNodes/internal/NodeStyle.hpp

@@ -1,12 +1,32 @@
 #pragma once
 
+#include <QIcon>
 #include <QtGui/QColor>
 
 #include "Export.hpp"
 #include "Style.hpp"
 
 namespace QtNodes {
 
+/**
+    * Describes the position of the processing icon on the node ui
+     */
+enum class ProcessingIconPos {
+    BottomLeft = 0,  /// icon on the bottom left position
+    BottomRight = 1, /// icon on the bottom right position
+};
+
+/**
+ * Defines the processing icon style;
+ */
+struct ProcessingIconStyle
+{
+    ProcessingIconPos _pos{ProcessingIconPos::BottomRight};
+    double _size{20.0};
+    double _margin{8.0};
+    int _resolution{64};
+};
+
 class NODE_EDITOR_PUBLIC NodeStyle : public Style
 {
 public:
@@ -51,5 +71,14 @@ class NODE_EDITOR_PUBLIC NodeStyle : public Style
     float ConnectionPointDiameter;
 
     float Opacity;
+
+    QIcon statusUpdated{QStringLiteral("://status_icons/updated.svg")};
+    QIcon statusProcessing{QStringLiteral("://status_icons/processing.svg")};
+    QIcon statusPending{QStringLiteral("://status_icons/pending.svg")};
+    QIcon statusInvalid{QStringLiteral("://status_icons/failed.svg")};
+    QIcon statusEmpty{QStringLiteral("://status_icons/empty.svg")};
+    QIcon statusPartial{QStringLiteral("://status_icons/partial.svg")};
+
+    ProcessingIconStyle processingIconStyle{};
 };
 } // namespace QtNodes

resources/resources.qrc

@@ -2,5 +2,11 @@
     <qresource prefix="/">
         <file>DefaultStyle.json</file>
         <file>info-tooltip.svg</file>
+        <file>status_icons/empty.svg</file>
+        <file>status_icons/failed.svg</file>
+        <file>status_icons/partial.svg</file>
+        <file>status_icons/pending.svg</file>
+        <file>status_icons/processing.svg</file>
+        <file>status_icons/updated.svg</file> 
     </qresource>
 </RCC>