Restore viz modules if deferred operator canceled

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

Author: psavery

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,21 @@ 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
+        // (onInputDisconnected -> clearVisualization). Re-link alone does not
+        // re-show it, and we deliberately do not re-execute, so restore the
+        // module's visibility explicitly here. 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) {
+          if (auto* sink = dynamic_cast<LegacyModuleSink*>(ep.to->node())) {
+            sink->restoreVisualization();
+          }
+        }
       }
     }
 

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(