fixed node removals

app/widget/nodeview/nodeview.cpp

@@ -139,7 +139,7 @@ void NodeView::DeleteSelected()
 
     if (!selected_nodes.isEmpty()) {
       foreach (Node* node, selected_nodes) {
-        Node::RemoveNodeAndDisconnect(node, command);
+        new NodeRemoveAndDisconnectCommand(node, command);
       }
     }
   }

app/widget/nodeview/nodeviewundo.cpp

@@ -21,6 +21,7 @@
 #include "nodeviewundo.h"
 
 #include "project/item/sequence/sequence.h"
+#include "widget/timelinewidget/timelineundo.h"
 
 namespace olive {
 
@@ -94,28 +95,6 @@ Project *NodeAddCommand::GetRelevantProject() const
   return graph_->project();
 }
 
-NodeRemoveCommand::NodeRemoveCommand(Node *node, QUndoCommand *parent) :
-  UndoCommand(parent),
-  graph_(node->parent()),
-  node_(node)
-{
-}
-
-void NodeRemoveCommand::redo_internal()
-{
-  node_->setParent(&memory_manager_);
-}
-
-void NodeRemoveCommand::undo_internal()
-{
-  node_->setParent(graph_);
-}
-
-Project *NodeRemoveCommand::GetRelevantProject() const
-{
-  return static_cast<Sequence*>(graph_)->project();
-}
-
 NodeCopyInputsCommand::NodeCopyInputsCommand(Node *src, Node *dest, bool include_connections, QUndoCommand *parent) :
   QUndoCommand(parent),
   src_(src),
@@ -129,4 +108,26 @@ void NodeCopyInputsCommand::redo()
   Node::CopyInputs(src_, dest_, include_connections_);
 }
 
+void NodeRemoveAndDisconnectCommand::prep()
+{
+  command_ = new QUndoCommand();
+
+  // If this is a block, remove all links
+  Block* block = dynamic_cast<Block*>(node_);
+  if (block) {
+    new BlockUnlinkAllCommand(block, command_);
+  }
+
+  // Disconnect everything
+  foreach (const Node::InputConnection& conn, node_->edges()) {
+    new NodeEdgeRemoveCommand(node_, conn.input, conn.element, command_);
+  }
+
+  foreach (NodeInput* input, node_->inputs()) {
+    for (auto it=input->edges().cbegin(); it!=input->edges().cend(); it++) {
+      new NodeEdgeRemoveCommand(it->second, input, it->first, command_);
+    }
+  }
+}
+
 }

app/widget/nodeview/nodeviewundo.h

@@ -90,22 +90,124 @@ private:
   Node* node_;
 };
 
-class NodeRemoveCommand : public UndoCommand {
+class NodeRemoveAndDisconnectCommand : public UndoCommand {
 public:
-  NodeRemoveCommand(Node* node,
-                    QUndoCommand* parent = nullptr);
+  NodeRemoveAndDisconnectCommand(Node* node, QUndoCommand* parent = nullptr) :
+    UndoCommand(parent),
+    node_(node),
+    graph_(nullptr),
+    command_(nullptr),
+    prepped_(false)
+  {
+  }
 
-  virtual Project* GetRelevantProject() const override;
+  virtual ~NodeRemoveAndDisconnectCommand() override
+  {
+    delete command_;
+  }
+
+  virtual Project* GetRelevantProject() const override
+  {
+    if (graph_) {
+      return graph_->project();
+    } else {
+      return node_->parent()->project();
+    }
+  }
 
 protected:
-  virtual void redo_internal() override;
-  virtual void undo_internal() override;
+  virtual void redo_internal() override
+  {
+    if (!prepped_) {
+      prep();
+      prepped_ = true;
+    }
+
+    command_->redo();
+
+    graph_ = node_->parent();
+    node_->setParent(&memory_manager_);
+  }
+
+  virtual void undo_internal() override
+  {
+    node_->setParent(graph_);
+    graph_ = nullptr;
+
+    command_->undo();
+  }
 
 private:
+  void prep();
+
   QObject memory_manager_;
 
-  NodeGraph* graph_;
   Node* node_;
+  NodeGraph* graph_;
+
+  QUndoCommand* command_;
+
+  bool prepped_;
+
+};
+
+class NodeRemoveWithExclusiveDependenciesAndDisconnect : public UndoCommand {
+public:
+  NodeRemoveWithExclusiveDependenciesAndDisconnect(Node* node, QUndoCommand* parent = nullptr) :
+    UndoCommand(parent),
+    node_(node),
+    command_(nullptr),
+    prepped_(false)
+  {
+  }
+
+  virtual ~NodeRemoveWithExclusiveDependenciesAndDisconnect() override
+  {
+    delete command_;
+  }
+
+  virtual Project* GetRelevantProject() const override
+  {
+    if (command_) {
+      return static_cast<const NodeRemoveAndDisconnectCommand*>(command_->child(0))->GetRelevantProject();
+    } else {
+      return node_->parent()->project();
+    }
+  }
+
+protected:
+  virtual void redo_internal() override
+  {
+    if (!prepped_) {
+      prep();
+      prepped_ = true;
+    }
+
+    command_->redo();
+  }
+
+  virtual void undo_internal() override
+  {
+    command_->undo();
+  }
+
+private:
+  void prep()
+  {
+    command_ = new QUndoCommand();
+
+    new NodeRemoveAndDisconnectCommand(node_, command_);
+
+    // Remove exclusive dependencies
+    QVector<Node*> deps = node_->GetExclusiveDependencies();
+    foreach (Node* d, deps) {
+      new NodeRemoveAndDisconnectCommand(d, command_);
+    }
+  }
+
+  Node* node_;
+  QUndoCommand* command_;
+  bool prepped_;
 
 };