nodecombobox: implemented node combobox widget

app/node/factory.cpp

@@ -62,7 +62,7 @@ void NodeFactory::Destroy()
   library_.clear();
 }
 
-Menu *NodeFactory::CreateMenu(QWidget* parent)
+Menu *NodeFactory::CreateMenu(QWidget* parent, bool create_none_item)
 {
   Menu* menu = new Menu(parent);
   menu->setToolTipsVisible(true);
@@ -100,18 +100,57 @@ Menu *NodeFactory::CreateMenu(QWidget* parent)
     a->setToolTip(n->Description());
   }
 
+  if (create_none_item) {
+
+    QAction* none_item = new QAction(QCoreApplication::translate("NodeFactory", "None"),
+                                     menu);
+
+    none_item->setData(-1);
+
+    if (menu->actions().isEmpty()) {
+      menu->addAction(none_item);
+    } else {
+      QAction* separator = menu->insertSeparator(menu->actions().first());
+      menu->insertAction(separator, none_item);
+    }
+  }
+
   return menu;
 }
 
 Node* NodeFactory::CreateFromMenuAction(QAction *action)
 {
-  int library_index = action->data().toInt();
+  int index = action->data().toInt();
 
-  if (library_index >= 0 && library_index < library_.size()) {
-    return library_.at(library_index)->copy();
+  if (index == -1) {
+    return nullptr;
   }
 
-  return nullptr;
+  return library_.at(index)->copy();
+}
+
+QString NodeFactory::GetIDFromMenuAction(QAction *action)
+{
+  int index = action->data().toInt();
+
+  if (index == -1) {
+    return QString();
+  }
+
+  return library_.at(action->data().toInt())->id();
+}
+
+QString NodeFactory::GetNameFromID(const QString &id)
+{
+  if (!id.isEmpty()) {
+    foreach (Node* n, library_) {
+      if (n->id() == id) {
+        return n->Name();
+      }
+    }
+  }
+
+  return QString();
 }
 
 Node *NodeFactory::CreateFromID(const QString &id)

app/node/factory.h

@@ -60,10 +60,14 @@ public:
 
   static void Destroy();
 
-  static Menu* CreateMenu(QWidget *parent);
+  static Menu* CreateMenu(QWidget *parent, bool create_none_item = false);
 
   static Node* CreateFromMenuAction(QAction* action);
 
+  static QString GetIDFromMenuAction(QAction* action);
+
+  static QString GetNameFromID(const QString& id);
+
   static Node* CreateFromID(const QString& id);
 
 private:

app/node/node.cpp

@@ -371,7 +371,7 @@ void Node::Hash(QCryptographicHash &hash, const rational& time) const
         // Footage timestamp
         if (stream->type() == Stream::kVideo) {
           hash.addData(QStringLiteral("%1/%2").arg(QString::number(input_time.numerator()),
-                                                    QString::number(input_time.denominator())).toUtf8());
+                                                   QString::number(input_time.denominator())).toUtf8());
 
           hash.addData(QString::number(static_cast<VideoStream*>(stream.get())->start_time()).toUtf8());
 
@@ -532,16 +532,75 @@ NodeOutput *Node::GetOutputWithID(const QString &id) const
   return nullptr;
 }
 
-bool Node::OutputsTo(Node *n) const
+bool Node::OutputsTo(Node *n, bool recursively) const
 {
-  foreach (NodeParam* param, params_) {
-    if (param->type() == NodeParam::kOutput) {
-      QVector<NodeEdgePtr> edges = param->edges();
+  QList<NodeOutput*> outputs = GetOutputs();
 
-      foreach (NodeEdgePtr edge, edges) {
-        if (edge->input()->parent() == n) {
-          return true;
-        }
+  foreach (NodeOutput* output, outputs) {
+    foreach (NodeEdgePtr edge, output->edges()) {
+      Node* connected = edge->input()->parentNode();
+
+      if (connected == n) {
+        return true;
+      } else if (recursively && connected->OutputsTo(n, recursively)) {
+        return true;
+      }
+    }
+  }
+
+  return false;
+}
+
+bool Node::OutputsTo(const QString &id, bool recursively) const
+{
+  QList<NodeOutput*> outputs = GetOutputs();
+
+  foreach (NodeOutput* output, outputs) {
+    foreach (NodeEdgePtr edge, output->edges()) {
+      Node* connected = edge->input()->parentNode();
+
+      if (connected->id() == id) {
+        return true;
+      } else if (recursively && connected->OutputsTo(id, recursively)) {
+        return true;
+      }
+    }
+  }
+
+  return false;
+}
+
+bool Node::InputsFrom(Node *n, bool recursively) const
+{
+  QList<NodeInput*> inputs = GetInputsIncludingArrays();
+
+  foreach (NodeInput* input, inputs) {
+    foreach (NodeEdgePtr edge, input->edges()) {
+      Node* connected = edge->output()->parentNode();
+
+      if (connected == n) {
+        return true;
+      } else if (recursively && connected->InputsFrom(n, recursively)) {
+        return true;
+      }
+    }
+  }
+
+  return false;
+}
+
+bool Node::InputsFrom(const QString &id, bool recursively) const
+{
+  QList<NodeInput*> inputs = GetInputsIncludingArrays();
+
+  foreach (NodeInput* input, inputs) {
+    foreach (NodeEdgePtr edge, input->edges()) {
+      Node* connected = edge->output()->parentNode();
+
+      if (connected->id() == id) {
+        return true;
+      } else if (recursively && connected->InputsFrom(id, recursively)) {
+        return true;
       }
     }
   }

app/node/node.h

@@ -229,9 +229,33 @@ public:
   NodeOutput* GetOutputWithID(const QString& id) const;
 
   /**
-   * @brief Returns whether this Node outputs directly to `n`
+   * @brief Returns whether this Node outputs to `n`
+   *
+   * @param n
+   *
+   * The node instance to check.
+   *
+   * @param recursively
+   *
+   * Whether to keep traversing down outputs to find this node (TRUE) or stick to immediate outputs
+   * (FALSE).
    */
-  bool OutputsTo(Node* n) const;
+  bool OutputsTo(Node* n, bool recursively) const;
+
+  /**
+   * @brief Same as OutputsTo(Node*), but for a node ID rather than a specific instance.
+   */
+  bool OutputsTo(const QString& id, bool recursively) const;
+
+  /**
+   * @brief Returns whether this node ever receives an input from a particular node instance
+   */
+  bool InputsFrom(Node* n, bool recursively) const;
+
+  /**
+   * @brief Returns whether this node ever receives an input from a node with a particular ID
+   */
+  bool InputsFrom(const QString& id, bool recursively) const;
 
   /**
    * @brief Determines how many paths go from this node out to another node