fix: processing status icons and related bugs

ConnectionIdUtils:
- Fixed "intNodeId" typo to "inNodeId" in toJson()
- Added backward compatibility in fromJson()

Processing status icons:
- Initialize icons in NodeStyle constructor after Q_INIT_RESOURCE
  (fixes icons not loading due to static initialization order)
- Fixed resource path format from "://" to ":/"
- Skip drawing when status is NoStatus
- Use const reference for ProcessingIconStyle to avoid copy
- Auto-move icon to BottomLeft when node is resizable to avoid
  overlap with resize handle

RandomNumberModel example:
- Fixed memory leak by reusing timer instead of creating new ones

Author: paceholder

examples/calculator/LongProcessingRandomNumber.hpp

@@ -15,22 +15,19 @@
 class RandomNumberModel : public MathOperationDataModel
 {
 public:
-    RandomNumberModel() {
+    RandomNumberModel()
+        : _timer(new QTimer(this))
+    {
         this->setNodeProcessingStatus(QtNodes::NodeProcessingStatus::Empty);
 
-
         QObject::connect(this, &NodeDelegateModel::computingStarted, this, [this]() {
             if (_number1.lock() && _number2.lock()) {
-                this->setNodeProcessingStatus(
-                    QtNodes::NodeProcessingStatus::Processing);
+                this->setNodeProcessingStatus(QtNodes::NodeProcessingStatus::Processing);
             }
-
             emit requestNodeUpdate();
         });
         QObject::connect(this, &NodeDelegateModel::computingFinished, this, [this]() {
-            this->setNodeProcessingStatus(
-                QtNodes::NodeProcessingStatus::Updated);
-
+            this->setNodeProcessingStatus(QtNodes::NodeProcessingStatus::Updated);
             emit requestNodeUpdate();
         });
     }
@@ -44,31 +41,34 @@ class RandomNumberModel : public MathOperationDataModel
 private:
     void compute() override
     {
+        // Stop any previous computation
+        _timer->stop();
+        _timer->disconnect();
+
         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();
+        _secondsRemaining = 3;
+        _timer->start(1000);
+        connect(_timer, &QTimer::timeout, this, [this, n1, n2, outPortIndex]() {
+            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;
+                    double randomValue = QRandomGenerator::global()->generateDouble() * (upper - a)
+                                         + a;
 
                     _result = std::make_shared<DecimalData>(randomValue);
                     Q_EMIT computingFinished();
@@ -80,4 +80,8 @@ class RandomNumberModel : public MathOperationDataModel
             }
         });
     }
+
+private:
+    QTimer *_timer;
+    int _secondsRemaining = 0;
 };

include/QtNodes/internal/ConnectionIdUtils.hpp

@@ -132,17 +132,25 @@ inline QJsonObject toJson(ConnectionId const &connId)
 
     connJson["outNodeId"] = static_cast<qint64>(connId.outNodeId);
     connJson["outPortIndex"] = static_cast<qint64>(connId.outPortIndex);
-    connJson["intNodeId"] = static_cast<qint64>(connId.inNodeId);
+    connJson["inNodeId"] = static_cast<qint64>(connId.inNodeId);
     connJson["inPortIndex"] = static_cast<qint64>(connId.inPortIndex);
 
     return connJson;
 }
 
 inline ConnectionId fromJson(QJsonObject const &connJson)
 {
+    // Support both "inNodeId" (correct) and "intNodeId" (legacy typo) for backward compatibility
+    NodeId inNodeId = InvalidNodeId;
+    if (connJson.contains("inNodeId")) {
+        inNodeId = static_cast<NodeId>(connJson["inNodeId"].toInt(InvalidNodeId));
+    } else if (connJson.contains("intNodeId")) {
+        inNodeId = static_cast<NodeId>(connJson["intNodeId"].toInt(InvalidNodeId));
+    }
+
     ConnectionId connId{static_cast<NodeId>(connJson["outNodeId"].toInt(InvalidNodeId)),
                         static_cast<PortIndex>(connJson["outPortIndex"].toInt(InvalidPortIndex)),
-                        static_cast<NodeId>(connJson["intNodeId"].toInt(InvalidNodeId)),
+                        inNodeId,
                         static_cast<PortIndex>(connJson["inPortIndex"].toInt(InvalidPortIndex))};
 
     return connId;

include/QtNodes/internal/DefaultNodePainter.hpp

@@ -37,6 +37,6 @@ class NODE_EDITOR_PUBLIC DefaultNodePainter : public AbstractNodePainter
     void drawValidationIcon(QPainter *painter, NodeGraphicsObject &ngo) const;
 
 private:
-    QIcon _toolTipIcon{"://info-tooltip.svg"};
+    QIcon _toolTipIcon{":/info-tooltip.svg"};
 };
 } // namespace QtNodes

include/QtNodes/internal/NodeStyle.hpp

@@ -78,12 +78,13 @@ class NODE_EDITOR_PUBLIC NodeStyle : public Style
 
     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")};
+    // Status icons - initialized in constructor after Q_INIT_RESOURCE
+    QIcon statusUpdated;
+    QIcon statusProcessing;
+    QIcon statusPending;
+    QIcon statusInvalid;
+    QIcon statusEmpty;
+    QIcon statusPartial;
 
     ProcessingIconStyle processingIconStyle{};
 };

src/DefaultNodePainter.cpp

@@ -306,21 +306,32 @@ void DefaultNodePainter::drawProcessingIndicator(QPainter *painter, NodeGraphics
     if (!delegate)
         return;
 
+    // Skip if status is NoStatus
+    if (delegate->processingStatus() == NodeProcessingStatus::NoStatus)
+        return;
+
     AbstractNodeGeometry &geometry = ngo.nodeScene()->nodeGeometry();
 
     QSize size = geometry.size(nodeId);
 
     QPixmap pixmap = delegate->processingStatusIcon();
-    NodeStyle nodeStyle = delegate->nodeStyle();
+    if (pixmap.isNull())
+        return;
 
-    ProcessingIconStyle iconStyle = nodeStyle.processingIconStyle;
+    ProcessingIconStyle const &iconStyle = delegate->nodeStyle().processingIconStyle;
 
     qreal iconSize = iconStyle._size;
     qreal margin = iconStyle._margin;
 
-    qreal x = margin;
+    // Determine position, avoiding conflict with resize handle
+    ProcessingIconPos pos = iconStyle._pos;
+    bool isResizable = model.nodeFlags(nodeId) & NodeFlag::Resizable;
+    if (isResizable && pos == ProcessingIconPos::BottomRight) {
+        pos = ProcessingIconPos::BottomLeft;
+    }
 
-    if (iconStyle._pos == ProcessingIconPos::BottomRight) {
+    qreal x = margin;
+    if (pos == ProcessingIconPos::BottomRight) {
         x = size.width() - iconSize - margin;
     }
 

src/NodeStyle.cpp

@@ -21,6 +21,14 @@ NodeStyle::NodeStyle()
     // order fiasco: https://isocpp.org/wiki/faq/ctors#static-init-order
     initResources();
 
+    // Initialize status icons after resources are loaded
+    statusUpdated = QIcon(":/status_icons/updated.svg");
+    statusProcessing = QIcon(":/status_icons/processing.svg");
+    statusPending = QIcon(":/status_icons/pending.svg");
+    statusInvalid = QIcon(":/status_icons/failed.svg");
+    statusEmpty = QIcon(":/status_icons/empty.svg");
+    statusPartial = QIcon(":/status_icons/partial.svg");
+
     // This configuration is stored inside the compiled unit and is loaded statically
     loadJsonFile(":DefaultStyle.json");
 }