arranged items so they are inputs of folder rather than outputs

app/project/item/folder/folder.cpp

@@ -27,8 +27,13 @@
 
 namespace olive {
 
+#define super Node
+
+const QString Folder::kChildInput = QStringLiteral("child_in");
+
 Folder::Folder()
 {
+  AddInput(kChildInput, NodeValue::kNone, InputFlags(kInputFlagArray | kInputFlagNotKeyframable));
 }
 
 QIcon Folder::icon() const
@@ -36,6 +41,13 @@ QIcon Folder::icon() const
   return icon::Folder;
 }
 
+void Folder::Retranslate()
+{
+  super::Retranslate();
+
+  SetInputName(kChildInput, tr("Children"));
+}
+
 bool ChildExistsWithNameInternal(const Folder* n, const QString& s)
 {
   foreach (const Node::OutputConnection& c, n->output_connections()) {
@@ -60,33 +72,69 @@ bool Folder::ChildExistsWithName(const QString &s) const
   return ChildExistsWithNameInternal(this, s);
 }
 
-void Folder::OutputConnectedEvent(const QString &output, const NodeInput &input)
+int Folder::index_of_child_in_array(Node *item) const
 {
-  Q_UNUSED(output)
+  int index_of_item = item_children_.indexOf(item);
 
-  Item* item = dynamic_cast<Item*>(input.node());
+  if (index_of_item == -1) {
+    return -1;
+  }
+
+  return item_element_index_.at(index_of_item);
+}
+
+void Folder::InputConnectedEvent(const QString &input, int element, const NodeOutput &output)
+{
+  if (input == kChildInput && element != -1) {
+    Node* item = output.node();
 
-  if (item) {
     // The insert index is always our "count" because we only support appending in our internal
     // model. For sorting/organizing, a QSortFilterProxyModel is used instead.
     emit BeginInsertItem(item, item_child_count());
     item_children_.append(item);
+    item_element_index_.append(element);
+    item->SetFolder(this);
     emit EndInsertItem();
   }
 }
 
-void Folder::OutputDisconnectedEvent(const QString &output, const NodeInput &input)
+void Folder::InputDisconnectedEvent(const QString &input, int element, const NodeOutput &output)
 {
-  Q_UNUSED(output)
+  if (input == kChildInput && element != -1) {
+    Node* item = output.node();
 
-  Item* item = dynamic_cast<Item*>(input.node());
-
-  if (item) {
     int child_index = item_children_.indexOf(item);
     emit BeginRemoveItem(item, child_index);
     item_children_.removeAt(child_index);
+    item_element_index_.removeAt(child_index);
+    item->SetFolder(nullptr);
     emit EndRemoveItem();
   }
 }
 
+FolderAddChild::FolderAddChild(Folder *folder, Node *child, bool autoposition) :
+  folder_(folder),
+  child_(child),
+  autoposition_(autoposition)
+{
+}
+
+Project *FolderAddChild::GetRelevantProject() const
+{
+  return folder_->project();
+}
+
+void FolderAddChild::redo()
+{
+  int array_index = folder_->InputArraySize(Folder::kChildInput);
+  folder_->InputArrayAppend(Folder::kChildInput, false);
+  Node::ConnectEdge(child_, NodeInput(folder_, Folder::kChildInput, array_index));
+}
+
+void FolderAddChild::undo()
+{
+  Node::DisconnectEdge(child_, NodeInput(folder_, Folder::kChildInput, folder_->InputArraySize(Folder::kChildInput)-1));
+  folder_->InputArrayRemoveLast(Folder::kChildInput);
+}
+
 }

app/project/item/folder/folder.h

@@ -22,7 +22,6 @@
 #define FOLDER_H
 
 #include "node/node.h"
-#include "project/item/item.h"
 
 namespace olive {
 
@@ -32,7 +31,7 @@ namespace olive {
  * The Item base class already has support for children, but this functionality is disabled by default
  * (see CanHaveChildren() override). The Folder is a specific type that enables this functionality.
  */
-class Folder : public Item
+class Folder : public Node
 {
   Q_OBJECT
 public:
@@ -65,6 +64,8 @@ public:
 
   virtual QIcon icon() const override;
 
+  virtual void Retranslate() override;
+
   bool ChildExistsWithName(const QString& s) const;
 
   int item_child_count() const
@@ -72,16 +73,21 @@ public:
     return item_children_.size();
   }
 
-  Item* item_child(int i) const
+  Node* item_child(int i) const
   {
     return item_children_.at(i);
   }
 
-  const QVector<Item*>& children() const
+  const QVector<Node*>& children() const
   {
     return item_children_;
   }
 
+  virtual bool IsItem() const override
+  {
+    return true;
+  }
+
   /**
    * @brief Returns a list of nodes that are of a certain type that this node outputs to
    */
@@ -95,24 +101,28 @@ public:
     return list;
   }
 
-  int index_of_child(Item* item) const
+  int index_of_child(Node* item) const
   {
     return item_children_.indexOf(item);
   }
 
+  int index_of_child_in_array(Node* item) const;
+
+  static const QString kChildInput;
+
 signals:
-  void BeginInsertItem(Item* n, int index);
+  void BeginInsertItem(Node* n, int index);
 
   void EndInsertItem();
 
-  void BeginRemoveItem(Item* n, int index);
+  void BeginRemoveItem(Node* n, int index);
 
   void EndRemoveItem();
 
 protected:
-  virtual void OutputConnectedEvent(const QString& output, const NodeInput& input) override;
+  virtual void InputConnectedEvent(const QString& input, int element, const NodeOutput& output) override;
 
-  virtual void OutputDisconnectedEvent(const QString& output, const NodeInput& input) override;
+  virtual void InputDisconnectedEvent(const QString& input, int element, const NodeOutput& output) override;
 
 private:
   template<typename T>
@@ -140,7 +150,30 @@ private:
     }
   }
 
-  QVector<Item*> item_children_;
+  QVector<Node*> item_children_;
+  QVector<int> item_element_index_;
+
+};
+
+class FolderAddChild : public UndoCommand
+{
+public:
+  FolderAddChild(Folder* folder, Node* child, bool autoposition = true);
+
+  virtual Project * GetRelevantProject() const override;
+
+  virtual void redo() override;
+
+  virtual void undo() override;
+
+private:
+  Folder* folder_;
+
+  Node* child_;
+
+  bool autoposition_;
+
+  QPointF old_position_;
 
 };