nodes: remove graph and merge into project

app/widget/keyframeview/keyframeview.cpp

@@ -27,6 +27,7 @@
 #include "common/qtutils.h"
 #include "dialog/keyframeproperties/keyframeproperties.h"
 #include "keyframeviewundo.h"
+#include "node/group/group.h"
 #include "node/node.h"
 #include "node/project/serializer/serializer.h"
 #include "widget/menu/menu.h"

app/widget/nodeparamview/nodeparamview.h

@@ -24,6 +24,7 @@
 #include <QVBoxLayout>
 #include <QWidget>
 
+#include "node/group/group.h"
 #include "node/node.h"
 #include "node/project/serializer/serializer.h"
 #include "nodeparamviewcontext.h"

app/widget/nodeparamview/nodeparamviewcontext.cpp

@@ -157,7 +157,7 @@ void NodeParamViewContext::AddEffectMenuItemTriggered(QAction *a)
     NodeInput new_node_input = n->GetEffectInput();
     MultiUndoCommand *command = new MultiUndoCommand();
 
-    QVector<NodeGraph*> graphs_added_to;
+    QVector<Project*> graphs_added_to;
 
     foreach (Node *ctx, contexts_) {
       NodeInput ctx_input = ctx->GetEffectInput();

app/widget/nodeparamview/nodeparamviewitem.cpp

@@ -26,6 +26,7 @@
 #include "common/qtutils.h"
 #include "core.h"
 #include "dialog/speedduration/speeddurationdialog.h"
+#include "node/group/group.h"
 #include "node/project/sequence/sequence.h"
 #include "nodeparamviewundo.h"
 

app/widget/nodeparamview/nodeparamviewwidgetbridge.cpp

@@ -28,6 +28,7 @@
 
 #include "common/qtutils.h"
 #include "core.h"
+#include "node/group/group.h"
 #include "node/node.h"
 #include "node/project/sequence/sequence.h"
 #include "nodeparamviewarraywidget.h"

app/widget/nodeview/nodeview.h

@@ -25,7 +25,7 @@
 #include <QTimer>
 
 #include "core.h"
-#include "node/graph.h"
+#include "node/group/group.h"
 #include "nodeviewedge.h"
 #include "nodeviewcontext.h"
 #include "nodeviewminimap.h"

app/widget/nodeview/nodeviewcontext.cpp

@@ -9,8 +9,9 @@
 
 #include "core.h"
 #include "node/block/block.h"
-#include "node/graph.h"
+#include "node/group/group.h"
 #include "node/output/track/track.h"
+#include "node/project.h"
 #include "node/project/sequence/sequence.h"
 #include "nodeviewitem.h"
 #include "ui/colorcoding.h"

app/widget/nodeview/nodeviewscene.h

@@ -24,7 +24,7 @@
 #include <QGraphicsScene>
 #include <QTimer>
 
-#include "node/graph.h"
+#include "node/project.h"
 #include "nodeviewcontext.h"
 #include "nodeviewedge.h"
 #include "nodeviewitem.h"
@@ -74,7 +74,7 @@ public slots:
 private:
   QHash<Node*, NodeViewContext*> context_map_;
 
-  NodeGraph* graph_;
+  Project* graph_;
 
   NodeViewCommon::FlowDirection direction_;
 

app/widget/nodeview/nodeviewundo.cpp

@@ -84,7 +84,7 @@ Project *NodeEdgeRemoveCommand::GetRelevantProject() const
   return output_->project();
 }
 
-NodeAddCommand::NodeAddCommand(NodeGraph *graph, Node *node) :
+NodeAddCommand::NodeAddCommand(Project *graph, Node *node) :
   graph_(graph),
   node_(node)
 {

app/widget/nodeview/nodeviewundo.h

@@ -21,9 +21,8 @@
 #ifndef NODEVIEWUNDO_H
 #define NODEVIEWUNDO_H
 
-#include "node/graph.h"
 #include "node/node.h"
-#include "node/project/project.h"
+#include "node/project.h"
 #include "undo/undocommand.h"
 
 namespace olive {
@@ -76,7 +75,7 @@ private:
 
 class NodeAddCommand : public UndoCommand {
 public:
-  NodeAddCommand(NodeGraph* graph, Node* node);
+  NodeAddCommand(Project* graph, Node* node);
 
   void PushToThread(QThread* thread);
 
@@ -89,7 +88,7 @@ protected:
 private:
   QObject memory_manager_;
 
-  NodeGraph* graph_;
+  Project* graph_;
   Node* node_;
 };
 
@@ -109,7 +108,7 @@ public:
 
   virtual Project* GetRelevantProject() const override
   {
-    return dynamic_cast<Project*>(graph_);
+    return graph_;
   }
 
 protected:
@@ -135,7 +134,7 @@ private:
   QObject memory_manager_;
 
   Node* node_;
-  NodeGraph* graph_;
+  Project* graph_;
 
   MultiUndoCommand* command_;
 
@@ -372,7 +371,7 @@ private:
     Node *node;
     Node *context;
     QPointF pos;
-    NodeGraph *removed_from_graph;
+    Project *removed_from_graph;
   };
 
   QVector<RemovedNode> removed_nodes_;

app/widget/projectexplorer/CMakeLists.txt

@@ -16,22 +16,24 @@
 
 set(OLIVE_SOURCES
   ${OLIVE_SOURCES}
-  widget/projectexplorer/projectexplorer.h
   widget/projectexplorer/projectexplorer.cpp
-  widget/projectexplorer/projectexplorertreeview.h
-  widget/projectexplorer/projectexplorertreeview.cpp
-  widget/projectexplorer/projectexplorerlistview.h
-  widget/projectexplorer/projectexplorerlistview.cpp
-  widget/projectexplorer/projectexplorerlistviewbase.h
-  widget/projectexplorer/projectexplorerlistviewbase.cpp
-  widget/projectexplorer/projectexplorerlistviewitemdelegate.h
-  widget/projectexplorer/projectexplorerlistviewitemdelegate.cpp
-  widget/projectexplorer/projectexplorericonview.h
+  widget/projectexplorer/projectexplorer.h
   widget/projectexplorer/projectexplorericonview.cpp
-  widget/projectexplorer/projectexplorericonviewitemdelegate.h
+  widget/projectexplorer/projectexplorericonview.h
   widget/projectexplorer/projectexplorericonviewitemdelegate.cpp
-  widget/projectexplorer/projectexplorernavigation.h
+  widget/projectexplorer/projectexplorericonviewitemdelegate.h
+  widget/projectexplorer/projectexplorerlistview.cpp
+  widget/projectexplorer/projectexplorerlistview.h
+  widget/projectexplorer/projectexplorerlistviewbase.cpp
+  widget/projectexplorer/projectexplorerlistviewbase.h
+  widget/projectexplorer/projectexplorerlistviewitemdelegate.cpp
+  widget/projectexplorer/projectexplorerlistviewitemdelegate.h
   widget/projectexplorer/projectexplorernavigation.cpp
+  widget/projectexplorer/projectexplorernavigation.h
+  widget/projectexplorer/projectexplorertreeview.cpp
+  widget/projectexplorer/projectexplorertreeview.h
   widget/projectexplorer/projectexplorerundo.h
+  widget/projectexplorer/projectviewmodel.cpp
+  widget/projectexplorer/projectviewmodel.h
   PARENT_SCOPE
 )

app/widget/projectexplorer/projectexplorer.h

@@ -26,8 +26,8 @@
 #include <QTimer>
 #include <QTreeView>
 
-#include "node/project/project.h"
-#include "node/project/projectviewmodel.h"
+#include "node/project.h"
+#include "projectviewmodel.h"
 #include "widget/projectexplorer/projectexplorericonview.h"
 #include "widget/projectexplorer/projectexplorerlistview.h"
 #include "widget/projectexplorer/projectexplorertreeview.h"

app/widget/projectexplorer/projectviewmodel.cpp

@@ -0,0 +1,544 @@
+/***
+
+  Olive - Non-Linear Video Editor
+  Copyright (C) 2022 Olive Team
+
+  This program is free software: you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation, either version 3 of the License, or
+  (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+***/
+
+#include "projectviewmodel.h"
+
+#include <QDebug>
+#include <QMimeData>
+#include <QUrl>
+
+#include "common/qtutils.h"
+#include "core.h"
+#include "widget/nodeview/nodeviewundo.h"
+#include "widget/nodeparamview/nodeparamviewundo.h"
+
+namespace olive {
+
+ProjectViewModel::ProjectViewModel(QObject *parent) :
+  QAbstractItemModel(parent),
+  project_(nullptr)
+{
+}
+
+Project *ProjectViewModel::project() const
+{
+  return project_;
+}
+
+void ProjectViewModel::set_project(Project *p)
+{
+  beginResetModel();
+
+  if (project_) {
+    DisconnectItem(project_->root());
+  }
+
+  project_ = p;
+
+  if (project_) {
+    ConnectItem(project_->root());
+  }
+
+  endResetModel();
+}
+
+QModelIndex ProjectViewModel::index(int row, int column, const QModelIndex &parent) const
+{
+  // I'm actually not 100% sure what this does, but it seems logical and was in the earlier code
+  if (!hasIndex(row, column, parent)) {
+    return QModelIndex();
+  }
+
+  // Get the parent object, we assume it's a folder since only folders can have children
+  Folder* item_parent = static_cast<Folder*>(GetItemObjectFromIndex(parent));
+
+  // Return an index to this object
+  return createIndex(row, column, item_parent->item_child(row));
+}
+
+QModelIndex ProjectViewModel::parent(const QModelIndex &child) const
+{
+  // Get the Item object from the index
+  Node* item = GetItemObjectFromIndex(child);
+
+  // Get Item's parent object
+  Folder* par = item->folder();
+
+  // If the parent is the root, return an empty index
+  if (par == project_->root()) {
+    return QModelIndex();
+  }
+
+  // Otherwise return a true index to its parent
+  int parent_index = IndexOfChild(par);
+
+  // Make sure the index is valid (there's no reason it shouldn't be)
+  Q_ASSERT(parent_index > -1);
+
+  // Return an index to the parent
+  return createIndex(parent_index, 0, par);
+}
+
+int ProjectViewModel::rowCount(const QModelIndex &parent) const
+{
+  // If there's no project, there are obviously no items to show
+  if (project_ == nullptr) {
+    return 0;
+  }
+
+  // If the index is the root, return the root child count
+  if (parent == QModelIndex()) {
+    return project_->root()->item_child_count();
+  }
+
+  // Otherwise, the index must contain a valid pointer, so we just return its child count
+  return static_cast<Folder*>(GetItemObjectFromIndex(parent))->item_child_count();
+}
+
+int ProjectViewModel::columnCount(const QModelIndex &parent) const
+{
+  Q_UNUSED(parent)
+
+  // Not strictly necessary, but a decent visual cue that there's no project currently active
+  if (project_ == nullptr) {
+    return 0;
+  }
+
+  return kColumnCount;
+}
+
+QVariant ProjectViewModel::data(const QModelIndex &index, int role) const
+{
+  Node* internal_item = GetItemObjectFromIndex(index);
+
+  ColumnType column_type = static_cast<ColumnType>(index.column());
+
+  switch (role) {
+  case Qt::DisplayRole:
+  case kInnerTextRole:
+  {
+    // Standard text role
+
+    switch (column_type) {
+    case kName:
+      return internal_item->GetLabel();
+    case kDuration:
+      return internal_item->duration();
+    case kRate:
+      return internal_item->rate();
+    case kLastModified:
+    case kCreatedTime:
+    {
+      qint64 using_time = (column_type == kLastModified) ? internal_item->mod_time() : internal_item->creation_time();
+
+      if (using_time == 0) {
+        // 0 is the null value, return nothing
+        break;
+      }
+
+      QVariant ret;
+
+      if (role == kInnerTextRole) {
+        // Use time value directly for correct sorting
+        ret = using_time;
+      } else {
+        // Display role, format to a human readable string
+        ret = QtUtils::GetFormattedDateTime(QDateTime::fromSecsSinceEpoch(using_time));
+      }
+
+      return ret;
+    }
+    case kColumnCount:
+      break;
+    }
+  }
+    break;
+  case Qt::EditRole:
+    if (column_type == kName) {
+      return internal_item->GetLabel();
+    }
+    break;
+  case Qt::DecorationRole:
+    // If this is the first column, return the Item's icon
+    if (column_type == kName) {
+      return internal_item->icon();
+    }
+    break;
+  case Qt::ToolTipRole:
+    return internal_item->ToolTip();
+  }
+
+  return QVariant();
+}
+
+QVariant ProjectViewModel::headerData(int section, Qt::Orientation orientation, int role) const
+{
+  // Check if we need text data (DisplayRole) and orientation is horizontal
+  // FIXME I'm not 100% sure what happens if the orientation is vertical/if that check is necessary
+  if (orientation == Qt::Horizontal && role == Qt::DisplayRole) {
+    ColumnType column_type = static_cast<ColumnType>(section);
+
+    // Return the name based on the column's current type
+    switch (column_type) {
+    case kName:
+      return tr("Name");
+    case kDuration:
+      return tr("Duration");
+    case kRate:
+      return tr("Rate");
+    case kLastModified:
+      return tr("Modified");
+    case kCreatedTime:
+      return tr("Created");
+    case kColumnCount:
+      break;
+    }
+  }
+
+  return QAbstractItemModel::headerData(section, orientation, role);
+}
+
+bool ProjectViewModel::hasChildren(const QModelIndex &parent) const
+{
+  // If it's a folder, we always return TRUE in order to always show the "expand triangle" icon,
+  // even when there are no "physical" children
+  Node* item = GetItemObjectFromIndex(parent);
+
+  return dynamic_cast<Folder*>(item);
+}
+
+bool ProjectViewModel::setData(const QModelIndex &index, const QVariant &value, int role)
+{
+  // The name is editable
+  if (index.isValid() && index.column() == kName && role == Qt::EditRole) {
+    Node* item = GetItemObjectFromIndex(index);
+
+    QString new_name = value.toString();
+
+    if (!new_name.isEmpty()) {
+      NodeRenameCommand* nrc = new NodeRenameCommand();
+
+      nrc->AddNode(item, value.toString());
+
+      Core::instance()->undo_stack()->push(nrc);
+
+      return true;
+    }
+  }
+
+  return false;
+}
+
+bool ProjectViewModel::canFetchMore(const QModelIndex &parent) const
+{
+  // Use the same hack that always returns true with folders so the expand triangle is always visible
+  return hasChildren(parent);
+}
+
+Qt::ItemFlags ProjectViewModel::flags(const QModelIndex &index) const
+{
+  if (!index.isValid()) {
+    // Allow dropping files from external sources
+    return Qt::ItemIsDropEnabled;
+  }
+
+  Qt::ItemFlags f = Qt::ItemIsDragEnabled | QAbstractItemModel::flags(index);
+
+  if (dynamic_cast<Folder*>(GetItemObjectFromIndex(index))) {
+    f |= Qt::ItemIsDropEnabled;
+  }
+
+  // If the column is the kName column, that means it's editable
+  if (index.column() == kName) {
+    f |= Qt::ItemIsEditable;
+  }
+
+  return f;
+}
+
+QStringList ProjectViewModel::mimeTypes() const
+{
+  // Allow data from this model and a file list from external sources
+  return {Project::kItemMimeType, QStringLiteral("text/uri-list")};
+}
+
+QMimeData *ProjectViewModel::mimeData(const QModelIndexList &indexes) const
+{
+  // Compliance with Qt standard
+  if (indexes.isEmpty()) {
+    return nullptr;
+  }
+
+  // Encode mime data for the rows/items that were dragged
+  QMimeData* data = new QMimeData();
+
+  // Use QDataStream to stream the item data into a byte array
+  QByteArray encoded_data;
+  QDataStream stream(&encoded_data, QIODevice::WriteOnly);
+
+  // The indexes list includes indexes for each column which we don't use. To make sure each row only gets sent *once*,
+  // we keep a list of dragged items
+  QVector<void*> dragged_items;
+
+  foreach (QModelIndex index, indexes) {
+    if (index.isValid()) {
+      // Check if we've dragged this item before
+      if (!dragged_items.contains(index.internalPointer())) {
+        // If not, add it to the stream (and also keep track of it in the vector)
+        Node *item = static_cast<Node*>(index.internalPointer());
+        QVector<Track::Reference> streams;
+
+        if (ViewerOutput* footage = dynamic_cast<ViewerOutput*>(item)) {
+          streams = footage->GetEnabledStreamsAsReferences();
+        }
+
+        stream << streams << reinterpret_cast<quintptr>(item);
+
+        dragged_items.append(item);
+      }
+    }
+  }
+
+  // Set byte array as the mime data and return the mime data
+  data->setData(Project::kItemMimeType, encoded_data);
+
+  return data;
+}
+
+bool ProjectViewModel::dropMimeData(const QMimeData *data, Qt::DropAction action, int row, int column, const QModelIndex &drop)
+{
+  // Default recommended checks from https://doc.qt.io/qt-5/model-view-programming.html#using-drag-and-drop-with-item-views
+  if (!canDropMimeData(data, action, row, column, drop)) {
+    return false;
+  }
+
+  if (action == Qt::IgnoreAction) {
+    return true;
+  }
+
+  // Probe mime data for its format
+  QStringList mime_formats = data->formats();
+
+  if (mime_formats.contains(Project::kItemMimeType)) {
+    // Data is drag/drop data from this model
+    QByteArray model_data = data->data(Project::kItemMimeType);
+
+    // Use QDataStream to deserialize the data
+    QDataStream stream(&model_data, QIODevice::ReadOnly);
+
+    // Get the Item object that the items were dropped on
+    Folder* drop_location = dynamic_cast<Folder*>(GetItemObjectFromIndex(drop));
+
+    // If this is not a folder, we cannot drop these items here
+    if (!drop_location) {
+      return false;
+    }
+
+    // Variables to deserialize into
+    quintptr item_ptr;
+    QList<Track::Reference> streams;
+
+    // Loop through all data
+    MultiUndoCommand* move_command = new MultiUndoCommand();
+
+    move_command->set_name(tr("Move Items"));
+
+    while (!stream.atEnd()) {
+      stream >> streams >> item_ptr;
+
+      Node* item = reinterpret_cast<Node*>(item_ptr);
+
+      // Check if Item is already the drop location or if its parent is the drop location, in which case this is a
+      // no-op
+
+      if (item != drop_location && item->folder() != drop_location
+          && (!dynamic_cast<Folder*>(item) || !ItemIsParentOfChild(static_cast<Folder*>(item), drop_location))) {
+        move_command->add_child(new NodeEdgeRemoveCommand(item, NodeInput(item->folder(), Folder::kChildInput, item->folder()->index_of_child_in_array(item))));
+        move_command->add_child(new FolderAddChild(drop_location, item));
+      }
+    }
+
+    Core::instance()->undo_stack()->pushIfHasChildren(move_command);
+
+    return true;
+
+  } else if (mime_formats.contains(QStringLiteral("text/uri-list"))) {
+    // We received a list of files
+    QByteArray file_data = data->data(QStringLiteral("text/uri-list"));
+
+    // Use text stream to parse (just an easy way of sifting through line breaks
+    QTextStream stream(&file_data);
+
+    // Convert QByteArray to QStringList (which Core takes for importing)
+    QStringList urls;
+    while (!stream.atEnd()) {
+      QUrl url = stream.readLine();
+
+      if (!url.isEmpty()) {
+        urls.append(url.toLocalFile());
+      }
+    }
+
+    // Get folder dropped onto
+    Node* drop_item = GetItemObjectFromIndex(drop);
+
+    // If we didn't drop onto an item, find the nearest parent folder (should eventually terminate at root either way)
+    if (!dynamic_cast<Folder*>(drop_item)) {
+      drop_item = drop_item->folder();
+
+      if (!drop_item) {
+        // Failed to find folder to place this in
+        return false;
+      }
+    }
+
+    // Trigger an import
+    Core::instance()->ImportFiles(urls, static_cast<Folder*>(drop_item));
+
+    return true;
+  }
+
+  return false;
+}
+
+int ProjectViewModel::IndexOfChild(Node *item) const
+{
+  // Find parent's index within its own parent
+  Folder* parent = item->folder();
+
+  if (parent) {
+    return parent->index_of_child(item);
+  }
+
+  return -1;
+}
+
+Node *ProjectViewModel::GetItemObjectFromIndex(const QModelIndex &index) const
+{
+  if (index.isValid()) {
+    return static_cast<Node*>(index.internalPointer());
+  }
+
+  return project_ ? project_->root() : nullptr;
+}
+
+bool ProjectViewModel::ItemIsParentOfChild(Folder *parent, Node *child) const
+{
+  // Loop through parent hierarchy checking if `parent` is one of its parents
+  do {
+    child = child->folder();
+
+    if (parent == child) {
+      return true;
+    }
+  } while (child != nullptr);
+
+  return false;
+}
+
+void ProjectViewModel::ConnectItem(Node *n)
+{
+  connect(n, &Node::LabelChanged, this, &ProjectViewModel::ItemRenamed);
+
+  Folder* f = dynamic_cast<Folder*>(n);
+  if (f) {
+    connect(f, &Folder::BeginInsertItem, this, &ProjectViewModel::FolderBeginInsertItem);
+    connect(f, &Folder::EndInsertItem, this, &ProjectViewModel::FolderEndInsertItem);
+    connect(f, &Folder::BeginRemoveItem, this, &ProjectViewModel::FolderBeginRemoveItem);
+    connect(f, &Folder::EndRemoveItem, this, &ProjectViewModel::FolderEndRemoveItem);
+
+    foreach (Node* c, f->children()) {
+      ConnectItem(c);
+    }
+  }
+}
+
+void ProjectViewModel::DisconnectItem(Node *n)
+{
+  disconnect(n, &Node::LabelChanged, this, &ProjectViewModel::ItemRenamed);
+
+  Folder* f = dynamic_cast<Folder*>(n);
+  if (f) {
+    disconnect(f, &Folder::BeginInsertItem, this, &ProjectViewModel::FolderBeginInsertItem);
+    disconnect(f, &Folder::EndInsertItem, this, &ProjectViewModel::FolderEndInsertItem);
+    disconnect(f, &Folder::BeginRemoveItem, this, &ProjectViewModel::FolderBeginRemoveItem);
+    disconnect(f, &Folder::EndRemoveItem, this, &ProjectViewModel::FolderEndRemoveItem);
+
+    foreach (Node* c, f->children()) {
+      DisconnectItem(c);
+    }
+  }
+}
+
+void ProjectViewModel::FolderBeginInsertItem(Node *n, int insert_index)
+{
+  Folder* folder = static_cast<Folder*>(sender());
+
+  ConnectItem(n);
+
+  QModelIndex index;
+
+  if (folder != project_->root()) {
+    index = CreateIndexFromItem(folder);
+  }
+
+  beginInsertRows(index, insert_index, insert_index);
+}
+
+void ProjectViewModel::FolderEndInsertItem()
+{
+  endInsertRows();
+}
+
+void ProjectViewModel::FolderBeginRemoveItem(Node *n, int child_index)
+{
+  Folder* folder = static_cast<Folder*>(sender());
+
+  DisconnectItem(n);
+
+  QModelIndex index;
+
+  if (folder != project_->root()) {
+    index = CreateIndexFromItem(folder);
+  }
+
+  beginRemoveRows(index, child_index, child_index);
+}
+
+void ProjectViewModel::FolderEndRemoveItem()
+{
+  endRemoveRows();
+}
+
+void ProjectViewModel::ItemRenamed()
+{
+  Node* item = static_cast<Node*>(sender());
+
+  QModelIndex index = CreateIndexFromItem(item);
+
+  emit dataChanged(index, index, {Qt::DisplayRole, Qt::EditRole});
+}
+
+QModelIndex ProjectViewModel::CreateIndexFromItem(Node *item, int column)
+{
+  return createIndex(IndexOfChild(item), column, item);
+}
+
+}

app/widget/projectexplorer/projectviewmodel.h

@@ -0,0 +1,166 @@
+/***
+
+  Olive - Non-Linear Video Editor
+  Copyright (C) 2022 Olive Team
+
+  This program is free software: you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation, either version 3 of the License, or
+  (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+***/
+
+#ifndef VIEWMODEL_H
+#define VIEWMODEL_H
+
+#include <QAbstractItemModel>
+
+#include "node/block/block.h"
+#include "node/project.h"
+#include "undo/undocommand.h"
+
+namespace olive {
+
+/**
+ * @brief An adapter that interprets the data in a Project into a Qt item model for usage in ViewModel Views.
+ *
+ * Assuming a Project is currently "open" (i.e. the Project is connected to a ProjectExplorer/ProjectPanel through
+ * a ProjectViewModel), it may be better to make modifications (e.g. additions/removals/renames) through the
+ * ProjectViewModel so that the views can be efficiently and correctly updated. ProjectViewModel contains several
+ * "wrapper" functions for Project and Item functions that also signal any connected views to update accordingly.
+ */
+class ProjectViewModel : public QAbstractItemModel
+{
+  Q_OBJECT
+public:
+  enum ColumnType {
+    /// Media name
+    kName,
+
+    /// Media duration
+    kDuration,
+
+    /// Media rate (frame rate for video, sample rate for audio)
+    kRate,
+
+    /// Last modified time (for footage/files)
+    kLastModified,
+
+    /// Creation time (for footage/files)
+    kCreatedTime,
+
+    /// Count
+    kColumnCount
+  };
+
+  static const int kInnerTextRole = Qt::UserRole + 1;
+
+  /**
+   * @brief ProjectViewModel Constructor
+   *
+   * @param parent
+   * Parent object for memory handling
+   */
+  ProjectViewModel(QObject* parent);
+
+  /**
+   * @brief Get currently active project
+   *
+   * @return
+   *
+   * Currently active project or nullptr if there is none
+   */
+  Project* project() const;
+
+  /**
+   * @brief Set the project to adapt
+   *
+   * Any views attached to this model will get updated by this function.
+   *
+   * @param p
+   *
+   * Project to adapt, can be set to nullptr to "close" the project (will show an empty model that cannot be modified)
+   */
+  void set_project(Project* p);
+
+  /** Compulsory Qt QAbstractItemModel overrides */
+  virtual QModelIndex index(int row, int column, const QModelIndex &parent = QModelIndex()) const override;
+  virtual QModelIndex parent(const QModelIndex &child) const override;
+  virtual int rowCount(const QModelIndex &parent = QModelIndex()) const override;
+  virtual int columnCount(const QModelIndex &parent = QModelIndex()) const override;
+  virtual QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override;
+
+  /** Optional Qt QAbstractItemModel overrides */
+  virtual QVariant headerData(int section, Qt::Orientation orientation, int role = Qt::DisplayRole) const override;
+  virtual bool hasChildren(const QModelIndex &parent = QModelIndex()) const override;
+  virtual bool setData(const QModelIndex &index, const QVariant &value, int role = Qt::EditRole) override;
+  virtual bool canFetchMore(const QModelIndex &parent) const override;
+
+  /** Drag and drop support */
+  virtual Qt::ItemFlags flags(const QModelIndex &index) const override;
+  virtual QStringList mimeTypes() const override;
+  virtual QMimeData * mimeData(const QModelIndexList &indexes) const override;
+  virtual bool dropMimeData(const QMimeData *data, Qt::DropAction action, int row, int column, const QModelIndex &parent) override;
+
+  /**
+   * @brief Convenience function for creating QModelIndexes from an Item object
+   */
+  QModelIndex CreateIndexFromItem(Node *item, int column = 0);
+
+private:
+  /**
+   * @brief Retrieve the index of `item` in its parent
+   *
+   * This function will return the index of a specified item in its parent according to whichever sorting algorithm
+   * is currently active.
+   *
+   * @return
+   *
+   * Index of the specified item, or -1 if the item is root (in which case it has no parent).
+   */
+  int IndexOfChild(Node* item) const;
+
+  /**
+   * @brief Retrieves the Item object from a given index
+   *
+   * A convenience function for retrieving Item objects. If the index is not valid, this returns the root Item.
+   */
+  Node* GetItemObjectFromIndex(const QModelIndex& index) const;
+
+  /**
+   * @brief Check if an Item is a parent of a Child
+   *
+   * Checks entire "parent hierarchy" of `child` to see if `parent` is one of its parents.
+   */
+  bool ItemIsParentOfChild(Folder *parent, Node* child) const;
+
+  void ConnectItem(Node* n);
+
+  void DisconnectItem(Node *n);
+
+  Project* project_;
+
+private slots:
+  void FolderBeginInsertItem(Node *n, int insert_index);
+
+  void FolderEndInsertItem();
+
+  void FolderBeginRemoveItem(Node* n, int child_index);
+
+  void FolderEndRemoveItem();
+
+  void ItemRenamed();
+
+};
+
+}
+
+#endif // VIEWMODEL_H

app/widget/timelinewidget/timelinewidget.cpp

@@ -724,7 +724,7 @@ void TimelineWidget::DeleteInToOut(bool ripple)
 
       gap->set_length_and_media_out(GetConnectedNode()->GetWorkArea()->length());
 
-      command->add_child(new NodeAddCommand(static_cast<NodeGraph*>(track->parent()),
+      command->add_child(new NodeAddCommand(static_cast<Project*>(track->parent()),
                                             gap));
 
       command->add_child(new TrackPlaceBlockCommand(sequence()->track_list(track->type()),

app/widget/timelinewidget/tool/add.cpp

@@ -134,7 +134,7 @@ Node *AddTool::CreateAddableClip(MultiUndoCommand *command, Sequence *sequence,
   }
   clip->set_length_and_media_out(length);
 
-  NodeGraph* graph = sequence->parent();
+  Project* graph = sequence->parent();
 
   command->add_child(new NodeAddCommand(graph, clip));
   command->add_child(new NodeSetPositionCommand(clip, clip, QPointF(0, 0)));

app/widget/timelinewidget/tool/import.cpp

@@ -302,7 +302,7 @@ void ImportTool::DropGhosts(bool insert, MultiUndoCommand *parent_command)
     command->add_child(c);
   }
 
-  NodeGraph* dst_graph = nullptr;
+  Project* dst_graph = nullptr;
   Sequence* sequence = this->sequence();
   bool open_sequence = false;
 

app/widget/timelinewidget/tool/transition.cpp

@@ -110,7 +110,7 @@ void TransitionTool::MouseRelease(TimelineViewMouseEvent *event)
       MultiUndoCommand* command = new MultiUndoCommand();
 
       // Place transition in place
-      command->add_child(new NodeAddCommand(static_cast<NodeGraph*>(parent()->GetConnectedNode()->parent()),
+      command->add_child(new NodeAddCommand(parent()->GetConnectedNode()->parent(),
                                             transition));
 
       command->add_child(new NodeSetPositionCommand(transition, transition, QPointF(0, 0)));

app/widget/timelinewidget/undo/timelineundopointer.cpp

@@ -22,7 +22,7 @@
 
 #include "node/block/gap/gap.h"
 #include "node/block/transition/transition.h"
-#include "node/graph.h"
+#include "node/project.h"
 #include "timelineundocommon.h"
 
 namespace olive {

app/widget/timelinewidget/undo/timelineundoworkarea.h

@@ -21,7 +21,7 @@
 #ifndef TIMELINEUNDOWORKAREA_H
 #define TIMELINEUNDOWORKAREA_H
 
-#include "node/project/project.h"
+#include "node/project.h"
 
 namespace olive {
 

app/widget/viewer/footageviewer.cpp

@@ -24,7 +24,7 @@
 #include <QMimeData>
 
 #include "config/config.h"
-#include "node/project/project.h"
+#include "node/project.h"
 
 namespace olive {
 

app/widget/viewer/viewer.cpp

@@ -37,7 +37,7 @@
 #include "core.h"
 #include "node/block/gap/gap.h"
 #include "node/generator/shape/shapenodebase.h"
-#include "node/project/project.h"
+#include "node/project.h"
 #include "panel/multicam/multicampanel.h"
 #include "panel/panelmanager.h"
 #include "render/rendermanager.h"