nodes: allow stalling graph signals until an operation is over

app/node/graph.cpp

@@ -22,6 +22,11 @@
 
 OLIVE_NAMESPACE_ENTER
 
+NodeGraph::NodeGraph() :
+  operation_stack_(0)
+{
+}
+
 void NodeGraph::Clear()
 {
   foreach (Node* node, node_children_) {
@@ -38,14 +43,94 @@ void NodeGraph::AddNode(Node *node)
 
   node->setParent(this);
 
-  connect(node, &Node::EdgeAdded, this, &NodeGraph::EdgeAdded);
-  connect(node, &Node::EdgeRemoved, this, &NodeGraph::EdgeRemoved);
+  connect(node, &Node::EdgeAdded, this, &NodeGraph::SignalEdgeAdded);
+  connect(node, &Node::EdgeRemoved, this, &NodeGraph::SignalEdgeRemoved);
 
   node_children_.append(node);
 
   emit NodeAdded(node);
 }
 
+void NodeGraph::BeginOperation()
+{
+  operation_stack_++;
+}
+
+void NodeGraph::EndOperation()
+{
+  operation_stack_--;
+
+  if (!operation_stack_) {
+    // Signal everything that we cached during the operation
+
+    // First, signal the removed edges
+    foreach (NodeEdgePtr e, cached_removed_edges_) {
+      emit EdgeRemoved(e);
+    }
+    cached_removed_edges_.clear();
+
+    // Next, signal the removed nodes
+    foreach (Node* n, cached_removed_nodes_) {
+      emit NodeRemoved(n);
+    }
+    cached_removed_nodes_.clear();
+
+    // Next, signal the added nodes
+    foreach (Node* n, cached_added_nodes_) {
+      emit NodeAdded(n);
+    }
+    cached_added_nodes_.clear();
+
+    // Finally, signal the added edges
+    foreach (NodeEdgePtr e, cached_added_edges_) {
+      emit EdgeAdded(e);
+    }
+    cached_added_edges_.clear();
+  }
+}
+
+void NodeGraph::SignalNodeAdded(Node* node)
+{
+  if (!operation_stack_) {
+    emit NodeAdded(node);
+  } else if (!cached_removed_nodes_.removeOne(node)) {
+    // If we already removed this node during the operation (appending a signal to
+    // cached_removed_nodes_), we just remove that instead of appending a new signal. However if we
+    // didn't (removeOne returning false), only then do we append an add signal
+    cached_added_nodes_.append(node);
+  }
+}
+
+void NodeGraph::SignalNodeRemoved(Node *node)
+{
+  if (!operation_stack_) {
+    emit NodeRemoved(node);
+  } else if (!cached_added_nodes_.removeOne(node)) {
+    // See SignalNodeAdded() for explanation of this
+    cached_removed_nodes_.append(node);
+  }
+}
+
+void NodeGraph::SignalEdgeAdded(NodeEdgePtr edge)
+{
+  if (!operation_stack_) {
+    emit EdgeAdded(edge);
+  } else if (!cached_removed_edges_.removeOne(edge)) {
+    // See SignalNodeAdded() for explanation of this
+    cached_added_edges_.append(edge);
+  }
+}
+
+void NodeGraph::SignalEdgeRemoved(NodeEdgePtr edge)
+{
+  if (!operation_stack_) {
+    emit EdgeRemoved(edge);
+  } else if (!cached_added_edges_.removeOne(edge)) {
+    // See SignalNodeAdded() for explanation of this
+    cached_removed_edges_.append(edge);
+  }
+}
+
 void NodeGraph::TakeNode(Node *node, QObject* new_parent)
 {
   if (!ContainsNode(node)) {

app/node/graph.h

@@ -37,7 +37,7 @@ public:
   /**
    * @brief NodeGraph Constructor
    */
-  NodeGraph() = default;
+  NodeGraph();
 
   /**
    * @brief Destructively destroys all nodes in the graph
@@ -67,6 +67,10 @@ public:
    */
   bool ContainsNode(Node* n) const;
 
+  void BeginOperation();
+
+  void EndOperation();
+
 signals:
   /**
    * @brief Signal emitted when a Node is added to the graph
@@ -90,6 +94,20 @@ signals:
 
 private:
   QList<Node*> node_children_;
+
+  int operation_stack_;
+
+  QList<Node*> cached_added_nodes_;
+  QList<Node*> cached_removed_nodes_;
+  QList<NodeEdgePtr> cached_added_edges_;
+  QList<NodeEdgePtr> cached_removed_edges_;
+
+private slots:
+  void SignalNodeAdded(Node *node);
+  void SignalNodeRemoved(Node* node);
+  void SignalEdgeAdded(NodeEdgePtr edge);
+  void SignalEdgeRemoved(NodeEdgePtr edge);
+
 };
 
 OLIVE_NAMESPACE_EXIT

app/node/node.h

@@ -528,6 +528,8 @@ T* Node::FindOutputNode()
   return static_cast<T*>(FindOutputNodeInternal<T>(this));
 }
 
+using NodePtr = std::shared_ptr<Node>;
+
 OLIVE_NAMESPACE_EXIT
 
 #endif // NODE_H

app/node/output/viewer/viewer.cpp

@@ -52,7 +52,7 @@ ViewerOutput::ViewerOutput() :
     connect(list, &TrackList::TrackListChanged, this, &ViewerOutput::UpdateTrackCache);
     connect(list, &TrackList::LengthChanged, this, &ViewerOutput::VerifyLength);
     connect(list, &TrackList::BlockAdded, this, &ViewerOutput::TrackListAddedBlock);
-    connect(list, &TrackList::BlockRemoved, this, &ViewerOutput::BlockRemoved);
+    connect(list, &TrackList::BlockRemoved, this, &ViewerOutput::SignalBlockRemoved);
     connect(list, &TrackList::TrackAdded, this, &ViewerOutput::TrackListAddedTrack);
     connect(list, &TrackList::TrackRemoved, this, &ViewerOutput::TrackRemoved);
     connect(list, &TrackList::TrackHeightChanged, this, &ViewerOutput::TrackHeightChangedSlot);
@@ -274,6 +274,27 @@ void ViewerOutput::set_media_name(const QString &name)
   emit MediaNameChanged(media_name_);
 }
 
+void ViewerOutput::SignalBlockAdded(Block *block, const TrackReference& track)
+{
+  if (!operation_stack_) {
+    emit BlockAdded(block, track);
+  } else {
+    cached_block_removed_.removeOne(block);
+    cached_block_added_.insert(block, track);
+  }
+}
+
+void ViewerOutput::SignalBlockRemoved(Block *block)
+{
+  if (!operation_stack_) {
+    emit BlockRemoved({block});
+  } else {
+    // We keep track of all blocks that are removed, even if we don't end up signalling them
+    cached_block_added_.remove(block);
+    cached_block_removed_.append(block);
+  }
+}
+
 void ViewerOutput::BeginOperation()
 {
   operation_stack_++;
@@ -285,13 +306,23 @@ void ViewerOutput::EndOperation()
 {
   operation_stack_--;
 
+  if (!operation_stack_) {
+    for (auto it=cached_block_added_.cbegin(); it!=cached_block_added_.cend(); it++) {
+      emit BlockAdded(it.key(), it.value());
+    }
+    cached_block_added_.clear();
+
+    emit BlockRemoved(cached_block_removed_);
+    cached_block_removed_.clear();
+  }
+
   Node::EndOperation();
 }
 
 void ViewerOutput::TrackListAddedBlock(Block *block, int index)
 {
   Timeline::TrackType type = static_cast<TrackList*>(sender())->type();
-  emit BlockAdded(block, TrackReference(type, index));
+  SignalBlockAdded(block, TrackReference(type, index));
 }
 
 void ViewerOutput::TrackListAddedTrack(TrackOutput *track)

app/node/output/viewer/viewer.h

@@ -139,7 +139,7 @@ signals:
   void AudioParamsChanged();
 
   void BlockAdded(Block* block, TrackReference track);
-  void BlockRemoved(Block* block);
+  void BlockRemoved(const QList<Block*>& blocks);
 
   void TrackAdded(TrackOutput* track, Timeline::TrackType type);
   void TrackRemoved(TrackOutput* track);
@@ -149,6 +149,9 @@ signals:
   void MediaNameChanged(const QString& name);
 
 private:
+  QMap<Block*, TrackReference> cached_block_added_;
+  QList<Block*> cached_block_removed_;
+
   QUuid uuid_;
 
   NodeInput* texture_input_;
@@ -186,6 +189,9 @@ private slots:
 
   void TrackHeightChangedSlot(int index, int height);
 
+  void SignalBlockAdded(Block *block, const TrackReference &track);
+  void SignalBlockRemoved(Block *block);
+
 };
 
 OLIVE_NAMESPACE_EXIT