Restore visualization on operator cancel

Previously, the visualization would just be gone.

Signed-off-by: Patrick Avery <patrick.avery@kitware.com>

Author: psavery

tomviz/pipeline/Node.h

@@ -152,6 +152,13 @@ class Node : public QObject
   /// widget. Otherwise return nullptr and a default QProgressBar will be used.
   virtual QWidget* getCustomProgressWidget(QWidget*) const { return nullptr; }
 
+  /// Re-show any visualization this node owns (or, for group nodes, that its
+  /// children own) after an input link is recreated, without re-running the
+  /// pipeline. The counterpart of the implicit hide that happens when a link
+  /// is broken. Called when a deferred insertion is cancelled and the original
+  /// links are restored. Default no-op.
+  virtual void restorePresentation() {}
+
   /// Whether the node supports canceling mid-execution via cancelExecution().
   bool supportsCancelingMidExecution() const;
 

tomviz/pipeline/NodeEditDialog.cxx

@@ -9,6 +9,7 @@
 #include "Node.h"
 #include "OutputPort.h"
 #include "Pipeline.h"
+#include "sinks/LegacyModuleSink.h"
 
 #include "Utilities.h"
 
@@ -150,7 +151,20 @@ void NodeEditDialog::reject()
     // Recreate the original links that were broken to insert the node.
     for (const auto& ep : m_deferred.linksToRestore) {
       if (ep.from && ep.to) {
-        m_pipeline->createLink(ep.from, ep.to);
+        auto* link = m_pipeline->createLink(ep.from, ep.to);
+        // Breaking the link to insert the node hid any downstream module: a
+        // direct module sink via onInputDisconnected, or modules behind a
+        // SinkGroupNode via the group's resetVisualization() fan-out. Re-link
+        // alone does not re-show them and we deliberately do not re-execute, so
+        // ask the downstream node to restore its presentation explicitly. The
+        // VTK objects still hold the last data, so this is presentation-only --
+        // no pipeline run and no dependence on upstream PortData (which a
+        // transient source releases on disconnect). Done only on this cancel
+        // path so the insertion preview keeps its current behavior (the moved
+        // module stays hidden until the not-yet-run transform produces data).
+        if (link && ep.to->node()) {
+          ep.to->node()->restorePresentation();
+        }
       }
     }
 

tomviz/pipeline/SinkGroupNode.cxx

@@ -47,6 +47,18 @@ void SinkGroupNode::addPassthrough(const QString& name, PortType type)
           });
 }
 
+void SinkGroupNode::restorePresentation()
+{
+  // Symmetric with the resetVisualization() fan-out performed when this
+  // group's input is disconnected (see addPassthrough). Child sinks' own
+  // input links never changed, so they need an explicit re-show.
+  for (auto* sink : sinks()) {
+    if (auto* legacy = qobject_cast<LegacyModuleSink*>(sink)) {
+      legacy->restoreVisualization();
+    }
+  }
+}
+
 bool SinkGroupNode::execute()
 {
   for (auto* port : inputPorts()) {

tomviz/pipeline/SinkGroupNode.h

@@ -36,6 +36,12 @@ class SinkGroupNode : public Node
 
   bool execute() override;
 
+  /// Re-show the visualizations of all child sinks. Counterpart of the
+  /// resetVisualization() fan-out done when this group's input is
+  /// disconnected; used to restore modules when a cancelled deferred
+  /// insertion recreates the group's original input link.
+  void restorePresentation() override;
+
   /// All sink nodes currently connected to this group's output ports.
   QList<SinkNode*> sinks() const;
 

tomviz/pipeline/sinks/LegacyModuleSink.cxx

@@ -293,6 +293,18 @@ void LegacyModuleSink::resetVisualization()
   emit renderNeeded();
 }
 
+void LegacyModuleSink::restoreVisualization()
+{
+  // Re-apply the current visibility flag. Each subclass's setVisibility()
+  // override pushes visibility onto its props/widgets unconditionally before
+  // the base call, so this re-shows props that clearVisualization() hid even
+  // though m_visible never changed (the base call's guard then suppresses a
+  // redundant visibilityChanged signal). The VTK objects still hold the last
+  // consumed data, so nothing needs to be re-read or re-executed.
+  setVisibility(m_visible);
+  emit renderNeeded();
+}
+
 void LegacyModuleSink::onInputDisconnected(InputPort*)
 {
   resetVisualization();

tomviz/pipeline/sinks/LegacyModuleSink.h

@@ -106,6 +106,15 @@ class LegacyModuleSink : public SinkNode
   /// direct input disconnect.
   void resetVisualization();
 
+  /// Re-show the props this sink owns according to its current visibility
+  /// flag, then request a repaint. The counterpart of resetVisualization():
+  /// the underlying VTK objects still hold the last-consumed data after a
+  /// clearVisualization(), so reconnecting an input only needs to re-apply
+  /// visibility -- no upstream data and no pipeline run required. Used to
+  /// restore a module when a broken link is recreated (e.g. cancelling a
+  /// deferred operator insertion).
+  void restoreVisualization();
+
   /// Return sibling LegacyModuleSinks connected to the same upstream
   /// OutputPort as this sink's given input port (excluding this node).
   QList<LegacyModuleSink*> siblingSinks(
@@ -158,6 +167,7 @@ class LegacyModuleSink : public SinkNode
   void postConsume(bool success) override;
 
   void onInputDisconnected(InputPort* port) override;
+  void restorePresentation() override { restoreVisualization(); }
 
 private:
   /// Reset camera on first consume if no other sink has rendered to this view.