various: implemented multiple project support

This required various changes to various parts of the infrastructure (mostly
using paths to finding the "root project" of any given object throughout).
Now theoretically infinite projects can be opened and accounted for at any
given time.

app/widget/keyframeview/keyframeviewundo.cpp

@@ -20,6 +20,10 @@
 
 #include "keyframeviewundo.h"
 
+#include "node/input.h"
+#include "node/node.h"
+#include "project/item/sequence/sequence.h"
+
 OLIVE_NAMESPACE_ENTER
 
 KeyframeSetTypeCommand::KeyframeSetTypeCommand(NodeKeyframePtr key, NodeKeyframe::Type type, QUndoCommand *parent) :
@@ -30,6 +34,11 @@ KeyframeSetTypeCommand::KeyframeSetTypeCommand(NodeKeyframePtr key, NodeKeyframe
 {
 }
 
+Project *KeyframeSetTypeCommand::GetRelevantProject() const
+{
+  return static_cast<Sequence*>(key_->parent()->parentNode()->parent())->project();
+}
+
 void KeyframeSetTypeCommand::redo_internal()
 {
   key_->set_type(new_type_);
@@ -58,6 +67,11 @@ KeyframeSetBezierControlPoint::KeyframeSetBezierControlPoint(NodeKeyframePtr key
 {
 }
 
+Project *KeyframeSetBezierControlPoint::GetRelevantProject() const
+{
+  return static_cast<Sequence*>(key_->parent()->parentNode()->parent())->project();
+}
+
 void KeyframeSetBezierControlPoint::redo_internal()
 {
   key_->set_bezier_control(mode_, new_point_);

app/widget/keyframeview/keyframeviewundo.h

@@ -30,6 +30,8 @@ class KeyframeSetTypeCommand : public UndoCommand {
 public:
   KeyframeSetTypeCommand(NodeKeyframePtr key, NodeKeyframe::Type type, QUndoCommand* parent = nullptr);
 
+  virtual Project* GetRelevantProject() const override;
+
 protected:
   virtual void redo_internal() override;
   virtual void undo_internal() override;
@@ -48,6 +50,8 @@ public:
   KeyframeSetBezierControlPoint(NodeKeyframePtr key, NodeKeyframe::BezierType mode, const QPointF& point, QUndoCommand* parent = nullptr);
   KeyframeSetBezierControlPoint(NodeKeyframePtr key, NodeKeyframe::BezierType mode, const QPointF& new_point, const QPointF& old_point, QUndoCommand* parent = nullptr);
 
+  virtual Project* GetRelevantProject() const override;
+
 protected:
   virtual void redo_internal() override;
   virtual void undo_internal() override;

app/widget/menu/menu.cpp

@@ -41,13 +41,13 @@ Menu::Menu(Menu *menu)
 Menu::Menu(QWidget *parent) :
   QMenu(parent)
 {
-  StyleManager::UseNativeWindowsStyling(this);
+  Init();
 }
 
 Menu::Menu(const QString &s, QWidget *parent) :
   QMenu(s, parent)
 {
-  StyleManager::UseNativeWindowsStyling(this);
+  Init();
 }
 
 QAction* Menu::InsertAlphabetically(const QString &s)
@@ -101,7 +101,9 @@ void Menu::SetBooleanAction(QAction *a, bool* boolean)
 
 void Menu::Init()
 {
+#ifdef Q_OS_WINDOWS
   StyleManager::UseNativeWindowsStyling(this);
+#endif
 }
 
 OLIVE_NAMESPACE_EXIT

app/widget/menu/menushared.cpp

@@ -31,7 +31,7 @@ MenuShared* MenuShared::instance_ = nullptr;
 MenuShared::MenuShared()
 {
   // "New" menu shared items
-  new_project_item_ = Menu::CreateItem(this, "newproj", this, &MenuShared::NewProjectTriggered, "Ctrl+N");
+  new_project_item_ = Menu::CreateItem(this, "newproj", Core::instance(), &Core::CreateNewProject, "Ctrl+N");
   new_sequence_item_ = Menu::CreateItem(this, "newseq", Core::instance(), &Core::CreateNewSequence, "Ctrl+Shift+N");
   new_folder_item_ = Menu::CreateItem(this, "newfolder", Core::instance(), &Core::CreateNewFolder);
 
@@ -114,11 +114,6 @@ MenuShared *MenuShared::instance()
   return instance_;
 }
 
-void MenuShared::NewProjectTriggered()
-{
-  qDebug() << "FIXME: Stub";
-}
-
 void MenuShared::SplitAtPlayheadTriggered()
 {
   TimelinePanel* timeline = PanelManager::instance()->MostRecentlyFocused<TimelinePanel>();

app/widget/menu/menushared.h

@@ -77,8 +77,6 @@ private:
   static MenuShared* instance_;
 
 private slots:
-  void NewProjectTriggered();
-
   void SplitAtPlayheadTriggered();
 
   void DeleteSelectedTriggered();

app/widget/nodeparamview/nodeparamviewundo.cpp

@@ -20,6 +20,9 @@
 
 #include "nodeparamviewundo.h"
 
+#include "node/node.h"
+#include "project/item/sequence/sequence.h"
+
 OLIVE_NAMESPACE_ENTER
 
 NodeParamSetKeyframingCommand::NodeParamSetKeyframingCommand(NodeInput *input, bool setting, QUndoCommand *parent) :
@@ -30,6 +33,11 @@ NodeParamSetKeyframingCommand::NodeParamSetKeyframingCommand(NodeInput *input, b
   Q_ASSERT(setting != input_->is_keyframing());
 }
 
+Project *NodeParamSetKeyframingCommand::GetRelevantProject() const
+{
+  return static_cast<Sequence*>(input_->parentNode()->parent())->project();
+}
+
 void NodeParamSetKeyframingCommand::redo_internal()
 {
   input_->set_is_keyframing(setting_);
@@ -57,6 +65,11 @@ NodeParamSetKeyframeValueCommand::NodeParamSetKeyframeValueCommand(NodeKeyframeP
 
 }
 
+Project *NodeParamSetKeyframeValueCommand::GetRelevantProject() const
+{
+  return static_cast<Sequence*>(key_->parent()->parentNode()->parent())->project();
+}
+
 void NodeParamSetKeyframeValueCommand::redo_internal()
 {
   key_->set_value(new_value_);
@@ -83,6 +96,11 @@ NodeParamInsertKeyframeCommand::NodeParamInsertKeyframeCommand(NodeInput *input,
 {
 }
 
+Project *NodeParamInsertKeyframeCommand::GetRelevantProject() const
+{
+  return static_cast<Sequence*>(input_->parentNode()->parent())->project();
+}
+
 void NodeParamInsertKeyframeCommand::redo_internal()
 {
   if (!done_) {
@@ -103,6 +121,11 @@ NodeParamRemoveKeyframeCommand::NodeParamRemoveKeyframeCommand(NodeInput *input,
 {
 }
 
+Project *NodeParamRemoveKeyframeCommand::GetRelevantProject() const
+{
+  return static_cast<Sequence*>(input_->parentNode()->parent())->project();
+}
+
 void NodeParamRemoveKeyframeCommand::redo_internal()
 {
   input_->remove_keyframe(keyframe_);
@@ -129,6 +152,11 @@ NodeParamSetKeyframeTimeCommand::NodeParamSetKeyframeTimeCommand(NodeKeyframePtr
 {
 }
 
+Project *NodeParamSetKeyframeTimeCommand::GetRelevantProject() const
+{
+  return static_cast<Sequence*>(key_->parent()->parentNode()->parent())->project();
+}
+
 void NodeParamSetKeyframeTimeCommand::redo_internal()
 {
   key_->set_time(new_time_);
@@ -157,6 +185,11 @@ NodeParamSetStandardValueCommand::NodeParamSetStandardValueCommand(NodeInput *in
 {
 }
 
+Project *NodeParamSetStandardValueCommand::GetRelevantProject() const
+{
+  return static_cast<Sequence*>(input_->parentNode()->parent())->project();
+}
+
 void NodeParamSetStandardValueCommand::redo_internal()
 {
   input_->set_standard_value(new_value_, track_);

app/widget/nodeparamview/nodeparamviewundo.h

@@ -30,6 +30,8 @@ class NodeParamSetKeyframingCommand : public UndoCommand {
 public:
   NodeParamSetKeyframingCommand(NodeInput* input, bool setting, QUndoCommand* parent = nullptr);
 
+  virtual Project* GetRelevantProject() const override;
+
 protected:
   virtual void redo_internal() override;
   virtual void undo_internal() override;
@@ -44,6 +46,8 @@ public:
   NodeParamInsertKeyframeCommand(NodeInput* input, NodeKeyframePtr keyframe, QUndoCommand *parent = nullptr);
   NodeParamInsertKeyframeCommand(NodeInput* input, NodeKeyframePtr keyframe, bool already_done, QUndoCommand *parent = nullptr);
 
+  virtual Project* GetRelevantProject() const override;
+
 protected:
   virtual void redo_internal() override;
   virtual void undo_internal() override;
@@ -61,6 +65,8 @@ class NodeParamRemoveKeyframeCommand : public UndoCommand {
 public:
   NodeParamRemoveKeyframeCommand(NodeInput* input, NodeKeyframePtr keyframe, QUndoCommand *parent = nullptr);
 
+  virtual Project* GetRelevantProject() const override;
+
 protected:
   virtual void redo_internal() override;
   virtual void undo_internal() override;
@@ -77,6 +83,8 @@ public:
   NodeParamSetKeyframeTimeCommand(NodeKeyframePtr key, const rational& time, QUndoCommand* parent = nullptr);
   NodeParamSetKeyframeTimeCommand(NodeKeyframePtr key, const rational& new_time, const rational& old_time, QUndoCommand* parent = nullptr);
 
+  virtual Project* GetRelevantProject() const override;
+
 protected:
   virtual void redo_internal() override;
   virtual void undo_internal() override;
@@ -94,6 +102,8 @@ public:
   NodeParamSetKeyframeValueCommand(NodeKeyframePtr key, const QVariant& value, QUndoCommand* parent = nullptr);
   NodeParamSetKeyframeValueCommand(NodeKeyframePtr key, const QVariant& new_value, const QVariant& old_value, QUndoCommand* parent = nullptr);
 
+  virtual Project* GetRelevantProject() const override;
+
 protected:
   virtual void redo_internal() override;
   virtual void undo_internal() override;
@@ -111,6 +121,8 @@ public:
   NodeParamSetStandardValueCommand(NodeInput* input, int track, const QVariant& value, QUndoCommand* parent = nullptr);
   NodeParamSetStandardValueCommand(NodeInput* input, int track, const QVariant& new_value, const QVariant& old_value, QUndoCommand* parent = nullptr);
 
+  virtual Project* GetRelevantProject() const override;
+
 protected:
   virtual void redo_internal() override;
   virtual void undo_internal() override;

app/widget/nodeview/nodeviewundo.cpp

@@ -20,6 +20,8 @@
 
 #include "nodeviewundo.h"
 
+#include "project/item/sequence/sequence.h"
+
 OLIVE_NAMESPACE_ENTER
 
 NodeEdgeAddCommand::NodeEdgeAddCommand(NodeOutput *output, NodeInput *input, QUndoCommand *parent) :
@@ -59,6 +61,11 @@ void NodeEdgeAddCommand::undo_internal()
   done_ = false;
 }
 
+Project *NodeEdgeAddCommand::GetRelevantProject() const
+{
+  return static_cast<Sequence*>(output_->parentNode()->parent())->project();
+}
+
 NodeEdgeRemoveCommand::NodeEdgeRemoveCommand(NodeOutput *output, NodeInput *input, QUndoCommand *parent) :
   UndoCommand(parent),
   output_(output),
@@ -95,6 +102,11 @@ void NodeEdgeRemoveCommand::undo_internal()
   done_ = false;
 }
 
+Project *NodeEdgeRemoveCommand::GetRelevantProject() const
+{
+  return static_cast<Sequence*>(output_->parentNode()->parent())->project();
+}
+
 NodeAddCommand::NodeAddCommand(NodeGraph *graph, Node *node, QUndoCommand *parent) :
   UndoCommand(parent),
   graph_(graph),
@@ -114,6 +126,11 @@ void NodeAddCommand::undo_internal()
   graph_->TakeNode(node_, &memory_manager_);
 }
 
+Project *NodeAddCommand::GetRelevantProject() const
+{
+  return static_cast<Sequence*>(graph_)->project();
+}
+
 NodeRemoveCommand::NodeRemoveCommand(NodeGraph *graph, const QList<Node *> &nodes, QUndoCommand *parent) :
   UndoCommand(parent),
   graph_(graph),
@@ -156,6 +173,11 @@ void NodeRemoveCommand::undo_internal()
   edges_.clear();
 }
 
+Project *NodeRemoveCommand::GetRelevantProject() const
+{
+  return static_cast<Sequence*>(graph_)->project();
+}
+
 NodeRemoveWithExclusiveDeps::NodeRemoveWithExclusiveDeps(NodeGraph *graph, Node *node, QUndoCommand *parent) :
   UndoCommand(parent)
 {
@@ -166,8 +188,13 @@ NodeRemoveWithExclusiveDeps::NodeRemoveWithExclusiveDeps(NodeGraph *graph, Node
   remove_command_ = new NodeRemoveCommand(graph, node_and_its_deps, this);
 }
 
+Project *NodeRemoveWithExclusiveDeps::GetRelevantProject() const
+{
+  return remove_command_->GetRelevantProject();
+}
+
 NodeCopyInputsCommand::NodeCopyInputsCommand(Node *src, Node *dest, bool include_connections, QUndoCommand *parent) :
-  UndoCommand(parent),
+  QUndoCommand(parent),
   src_(src),
   dest_(dest),
   include_connections_(include_connections)
@@ -175,14 +202,14 @@ NodeCopyInputsCommand::NodeCopyInputsCommand(Node *src, Node *dest, bool include
 }
 
 NodeCopyInputsCommand::NodeCopyInputsCommand(Node *src, Node *dest, QUndoCommand *parent) :
-  UndoCommand(parent),
+  QUndoCommand(parent),
   src_(src),
   dest_(dest),
   include_connections_(true)
 {
 }
 
-void NodeCopyInputsCommand::redo_internal()
+void NodeCopyInputsCommand::redo()
 {
   Node::CopyInputs(src_, dest_, include_connections_);
 }

app/widget/nodeview/nodeviewundo.h

@@ -39,6 +39,8 @@ class NodeEdgeAddCommand : public UndoCommand {
 public:
   NodeEdgeAddCommand(NodeOutput* output, NodeInput* input, QUndoCommand* parent = nullptr);
 
+  virtual Project* GetRelevantProject() const override;
+
 protected:
   virtual void redo_internal() override;
   virtual void undo_internal() override;
@@ -62,6 +64,8 @@ public:
   NodeEdgeRemoveCommand(NodeOutput* output, NodeInput* input, QUndoCommand* parent = nullptr);
   NodeEdgeRemoveCommand(NodeEdgePtr edge, QUndoCommand* parent = nullptr);
 
+  virtual Project* GetRelevantProject() const override;
+
 protected:
   virtual void redo_internal() override;
   virtual void undo_internal() override;
@@ -77,6 +81,8 @@ class NodeAddCommand : public UndoCommand {
 public:
   NodeAddCommand(NodeGraph* graph, Node* node, QUndoCommand* parent = nullptr);
 
+  virtual Project* GetRelevantProject() const override;
+
 protected:
   virtual void redo_internal() override;
   virtual void undo_internal() override;
@@ -94,6 +100,8 @@ public:
                     const QList<Node*>& nodes,
                     QUndoCommand* parent = nullptr);
 
+  virtual Project* GetRelevantProject() const override;
+
 protected:
   virtual void redo_internal() override;
   virtual void undo_internal() override;
@@ -112,11 +120,13 @@ public:
                               Node* node,
                               QUndoCommand* parent = nullptr);
 
+  virtual Project* GetRelevantProject() const override;
+
 private:
   NodeRemoveCommand* remove_command_;
 };
 
-class NodeCopyInputsCommand : public UndoCommand {
+class NodeCopyInputsCommand : public QUndoCommand {
 public:
   NodeCopyInputsCommand(Node* src,
                         Node* dest,
@@ -128,7 +138,7 @@ public:
                         QUndoCommand* parent = nullptr);
 
 protected:
-  virtual void redo_internal() override;
+  virtual void redo() override;
 
 private:
   Node* src_;

app/widget/panel/panel.cpp

@@ -20,6 +20,8 @@
 
 #include "panel.h"
 
+#include <QCloseEvent>
+#include <QDebug>
 #include <QPainter>
 #include <QStyle>
 #include <QStyleOption>
@@ -29,9 +31,12 @@ OLIVE_NAMESPACE_ENTER
 
 PanelWidget::PanelWidget(QWidget *parent) :
   QDockWidget(parent),
-  border_visible_(false)
+  border_visible_(false),
+  signal_instead_of_close_(false)
 {
   setFocusPolicy(Qt::ClickFocus);
+
+  connect(this, &PanelWidget::visibilityChanged, this, &PanelWidget::PanelVisibilityChanged);
 }
 
 void PanelWidget::SetMovementLocked(bool locked)
@@ -104,6 +109,28 @@ void PanelWidget::UpdateTitle()
   }
 }
 
+void PanelWidget::PanelVisibilityChanged(bool e)
+{
+  if (e) {
+    setFocus();
+  }
+}
+
+void PanelWidget::SetSignalInsteadOfClose(bool e)
+{
+  signal_instead_of_close_ = e;
+}
+
+void PanelWidget::closeEvent(QCloseEvent *event)
+{
+  if (signal_instead_of_close_) {
+    event->ignore();
+    emit CloseRequested();
+  } else {
+    QDockWidget::closeEvent(event);
+  }
+}
+
 void PanelWidget::changeEvent(QEvent *e)
 {
   if (e->type() == QEvent::LanguageChange) {

app/widget/panel/panel.h

@@ -56,6 +56,13 @@ public:
    */
   void SetBorderVisible(bool enabled);
 
+  /**
+   * @brief If enabled, sends signal CloseRequested() when the user closes instead of closing
+   *
+   * Defaults to FALSE. Use this to override default panel closing functionality.
+   */
+  void SetSignalInsteadOfClose(bool e);
+
   /**
    * @brief Called whenever this panel is focused and user uses "Zoom In" (either in menus or as a keyboard shortcut)
    *
@@ -156,6 +163,9 @@ public:
 
   virtual void ToggleSelectedEnabled(){}
 
+signals:
+  void CloseRequested();
+
 protected:
   /**
    * @brief paintEvent
@@ -165,6 +175,8 @@ protected:
 
   virtual void changeEvent(QEvent* e) override;
 
+  virtual void closeEvent(QCloseEvent* event) override;
+
   virtual void Retranslate();
 
 protected slots:
@@ -204,20 +216,17 @@ private:
    */
   void UpdateTitle();
 
-  /**
-   * @brief Internal title string
-   */
   QString title_;
 
-  /**
-   * @brief Internal subtitle string
-   */
   QString subtitle_;
 
-  /**
-   * @brief Internal border visibility value
-   */
   bool border_visible_;
+
+  bool signal_instead_of_close_;
+
+private slots:
+  void PanelVisibilityChanged(bool e);
+
 };
 
 OLIVE_NAMESPACE_EXIT

app/widget/timebased/timebased.cpp

@@ -189,6 +189,11 @@ TimelinePoints *TimeBasedWidget::ConnectTimelinePoints()
   return static_cast<Sequence*>(viewer_node_->parent());
 }
 
+Project *TimeBasedWidget::GetTimelinePointsProject()
+{
+  return static_cast<Sequence*>(viewer_node_->parent())->project();
+}
+
 TimelinePoints *TimeBasedWidget::GetConnectedTimelinePoints() const
 {
   return points_;
@@ -339,7 +344,7 @@ void TimeBasedWidget::SetPoint(Timeline::MovementMode m, const rational& time)
 
   // Enable workarea if it isn't already enabled
   if (!points_->workarea()->enabled()) {
-    new WorkareaSetEnabledCommand(points_, true, command);
+    new WorkareaSetEnabledCommand(GetTimelinePointsProject(), points_, true, command);
   }
 
   // Determine our new range
@@ -364,7 +369,7 @@ void TimeBasedWidget::SetPoint(Timeline::MovementMode m, const rational& time)
   }
 
   // Set workarea
-  new WorkareaSetRangeCommand(points_, TimeRange(in_point, out_point), command);
+  new WorkareaSetRangeCommand(GetTimelinePointsProject(), points_, TimeRange(in_point, out_point), command);
 
   Core::instance()->undo_stack()->push(command);
 }
@@ -383,7 +388,7 @@ void TimeBasedWidget::ResetPoint(Timeline::MovementMode m)
     r.set_out(TimelineWorkArea::kResetOut);
   }
 
-  Core::instance()->undo_stack()->push(new WorkareaSetRangeCommand(points_, r));
+  Core::instance()->undo_stack()->push(new WorkareaSetRangeCommand(GetTimelinePointsProject(), points_, r));
 }
 
 void TimeBasedWidget::SetInAtPlayhead()
@@ -413,7 +418,7 @@ void TimeBasedWidget::ClearInOutPoints()
   }
 
 
-  Core::instance()->undo_stack()->push(new WorkareaSetEnabledCommand(points_, false));
+  Core::instance()->undo_stack()->push(new WorkareaSetEnabledCommand(GetTimelinePointsProject(), points_, false));
 }
 
 void TimeBasedWidget::SetMarker()

app/widget/timebased/timebased.h

@@ -116,6 +116,8 @@ protected:
 
   virtual TimelinePoints* ConnectTimelinePoints();
 
+  virtual Project* GetTimelinePointsProject();
+
   TimelinePoints* GetConnectedTimelinePoints() const;
 
   void ConnectTimelineView(TimelineViewBase* base);

app/widget/timelinewidget/timelinewidget.cpp

@@ -156,16 +156,13 @@ TimelineWidget::~TimelineWidget()
 
 void TimelineWidget::Clear()
 {
-  SetTimebase(0);
-
-  QMap<Block*, TimelineViewBlockItem*>::iterator iterator = block_items_.begin();
-
-  while (iterator != block_items_.end()) {
+  QMap<Block*, TimelineViewBlockItem*>::const_iterator iterator;
+  for (iterator=block_items_.begin(); iterator!=block_items_.end(); iterator++) {
     delete iterator.value();
-    iterator = block_items_.erase(iterator);
   }
-
   block_items_.clear();
+
+  SetTimebase(0);
 }
 
 void TimelineWidget::TimebaseChangedEvent(const rational &timebase)
@@ -725,7 +722,7 @@ void TimelineWidget::DeleteInToOut(bool ripple)
   }
 
   // Clear workarea after this
-  new WorkareaSetEnabledCommand(GetConnectedTimelinePoints(), false, command);
+  new WorkareaSetEnabledCommand(GetTimelinePointsProject(), GetConnectedTimelinePoints(), false, command);
 
   Core::instance()->undo_stack()->push(command);
 }

app/widget/timelinewidget/undo/undo.cpp

@@ -42,6 +42,11 @@ BlockResizeCommand::BlockResizeCommand(Block *block, rational new_length, QUndoC
 {
 }
 
+Project *BlockResizeCommand::GetRelevantProject() const
+{
+  return static_cast<Sequence*>(block_->parent())->project();
+}
+
 void BlockResizeCommand::redo_internal()
 {
   block_->set_length_and_media_out(new_length_);
@@ -60,6 +65,11 @@ BlockResizeWithMediaInCommand::BlockResizeWithMediaInCommand(Block *block, ratio
 {
 }
 
+Project *BlockResizeWithMediaInCommand::GetRelevantProject() const
+{
+  return static_cast<Sequence*>(block_->parent())->project();
+}
+
 void BlockResizeWithMediaInCommand::redo_internal()
 {
   block_->set_length_and_media_in(new_length_);
@@ -78,6 +88,11 @@ BlockSetMediaInCommand::BlockSetMediaInCommand(Block *block, rational new_media_
 {
 }
 
+Project *BlockSetMediaInCommand::GetRelevantProject() const
+{
+  return static_cast<Sequence*>(block_->parent())->project();
+}
+
 void BlockSetMediaInCommand::redo_internal()
 {
   block_->set_media_in(new_media_in_);
@@ -95,6 +110,11 @@ TrackRippleRemoveBlockCommand::TrackRippleRemoveBlockCommand(TrackOutput *track,
 {
 }
 
+Project *TrackRippleRemoveBlockCommand::GetRelevantProject() const
+{
+  return static_cast<Sequence*>(block_->parent())->project();
+}
+
 void TrackRippleRemoveBlockCommand::redo_internal()
 {
   before_ = block_->previous();
@@ -111,9 +131,9 @@ void TrackRippleRemoveBlockCommand::undo_internal()
 }
 
 TrackInsertBlockAfterCommand::TrackInsertBlockAfterCommand(TrackOutput *track,
-                                                                           Block *block,
-                                                                           Block *before,
-                                                                           QUndoCommand *parent) :
+                                                           Block *block,
+                                                           Block *before,
+                                                           QUndoCommand *parent) :
   UndoCommand(parent),
   track_(track),
   block_(block),
@@ -121,6 +141,11 @@ TrackInsertBlockAfterCommand::TrackInsertBlockAfterCommand(TrackOutput *track,
 {
 }
 
+Project *TrackInsertBlockAfterCommand::GetRelevantProject() const
+{
+  return static_cast<Sequence*>(block_->parent())->project();
+}
+
 void TrackInsertBlockAfterCommand::redo_internal()
 {
   track_->InsertBlockAfter(block_, before_);
@@ -143,6 +168,11 @@ TrackRippleRemoveAreaCommand::TrackRippleRemoveAreaCommand(TrackOutput *track, r
 {
 }
 
+Project *TrackRippleRemoveAreaCommand::GetRelevantProject() const
+{
+  return static_cast<Sequence*>(track_->parent())->project();
+}
+
 void TrackRippleRemoveAreaCommand::SetInsert(Block *insert)
 {
   insert_ = insert;
@@ -386,10 +416,15 @@ BlockSplitCommand::BlockSplitCommand(TrackOutput* track, Block *block, rational
   }
 }
 
+Project *BlockSplitCommand::GetRelevantProject() const
+{
+  return static_cast<Sequence*>(block_->parent())->project();
+}
+
 void BlockSplitCommand::redo_internal()
 {
   // FIXME: Reintroduce this optimization when block waveforms update automatically
-//  track_->BlockInvalidateCache();
+  //  track_->BlockInvalidateCache();
 
   static_cast<NodeGraph*>(block_->parent())->AddNode(new_block_);
   Node::CopyInputs(block_, new_block_);
@@ -407,12 +442,12 @@ void BlockSplitCommand::redo_internal()
     NodeParam::ConnectEdge(new_block_->output(), transition);
   }
 
-//  track_->UnblockInvalidateCache();
+  //  track_->UnblockInvalidateCache();
 }
 
 void BlockSplitCommand::undo_internal()
 {
-//  track_->BlockInvalidateCache();
+  //  track_->BlockInvalidateCache();
 
   block_->set_length_and_media_out(old_length_);
   track_->RippleRemoveBlock(new_block_);
@@ -424,7 +459,7 @@ void BlockSplitCommand::undo_internal()
     NodeParam::ConnectEdge(block_->output(), transition);
   }
 
-//  track_->UnblockInvalidateCache();
+  //  track_->UnblockInvalidateCache();
 }
 
 Block *BlockSplitCommand::new_block()
@@ -433,7 +468,8 @@ Block *BlockSplitCommand::new_block()
 }
 
 TrackSplitAtTimeCommand::TrackSplitAtTimeCommand(TrackOutput *track, rational point, QUndoCommand *parent) :
-  UndoCommand(parent)
+  UndoCommand(parent),
+  track_(track)
 {
   // Find Block that contains this time
   foreach (Block* b, track->Blocks()) {
@@ -442,12 +478,17 @@ TrackSplitAtTimeCommand::TrackSplitAtTimeCommand(TrackOutput *track, rational po
       return;
     } else if (b->in() < point && b->out() > point) {
       // We found the Block, split it
-      new BlockSplitCommand(track, b, point, this);
+      new BlockSplitCommand(track_, b, point, this);
       return;
     }
   }
 }
 
+Project *TrackSplitAtTimeCommand::GetRelevantProject() const
+{
+  return static_cast<Sequence*>(track_->parent())->project();
+}
+
 TrackReplaceBlockCommand::TrackReplaceBlockCommand(TrackOutput* track, Block *old, Block *replace, QUndoCommand *parent) :
   UndoCommand(parent),
   track_(track),
@@ -456,6 +497,11 @@ TrackReplaceBlockCommand::TrackReplaceBlockCommand(TrackOutput* track, Block *ol
 {
 }
 
+Project *TrackReplaceBlockCommand::GetRelevantProject() const
+{
+  return static_cast<Sequence*>(track_->parent())->project();
+}
+
 void TrackReplaceBlockCommand::redo_internal()
 {
   track_->ReplaceBlock(old_, replace_);
@@ -473,6 +519,11 @@ TrackPrependBlockCommand::TrackPrependBlockCommand(TrackOutput *track, Block *bl
 {
 }
 
+Project *TrackPrependBlockCommand::GetRelevantProject() const
+{
+  return static_cast<Sequence*>(track_->parent())->project();
+}
+
 void TrackPrependBlockCommand::redo_internal()
 {
   track_->PrependBlock(block_);
@@ -535,6 +586,11 @@ BlockSplitPreservingLinksCommand::BlockSplitPreservingLinksCommand(const QVector
   }
 }
 
+Project *BlockSplitPreservingLinksCommand::GetRelevantProject() const
+{
+  return static_cast<Sequence*>(blocks_.first()->parent())->project();
+}
+
 TrackCleanGapsCommand::TrackCleanGapsCommand(TrackList *track_list, int index, QUndoCommand *parent) :
   UndoCommand(parent),
   track_list_(track_list),
@@ -542,6 +598,11 @@ TrackCleanGapsCommand::TrackCleanGapsCommand(TrackList *track_list, int index, Q
 {
 }
 
+Project *TrackCleanGapsCommand::GetRelevantProject() const
+{
+  return static_cast<Sequence*>(track_list_->GetParentGraph())->project();
+}
+
 void TrackCleanGapsCommand::redo_internal()
 {
   GapBlock* on_gap = nullptr;
@@ -632,6 +693,11 @@ BlockSetSpeedCommand::BlockSetSpeedCommand(Block *block, const rational &new_spe
 {
 }
 
+Project *BlockSetSpeedCommand::GetRelevantProject() const
+{
+  return static_cast<Sequence*>(block_->parent())->project();
+}
+
 void BlockSetSpeedCommand::redo_internal()
 {
   block_->set_speed(new_speed_);
@@ -649,6 +715,11 @@ TimelineRippleDeleteGapsAtRegionsCommand::TimelineRippleDeleteGapsAtRegionsComma
 {
 }
 
+Project *TimelineRippleDeleteGapsAtRegionsCommand::GetRelevantProject() const
+{
+  return static_cast<Sequence*>(timeline_->parent())->project();
+}
+
 void TimelineRippleDeleteGapsAtRegionsCommand::redo_internal()
 {
   foreach (const TimeRange& range, regions_) {
@@ -699,14 +770,20 @@ void TimelineRippleDeleteGapsAtRegionsCommand::undo_internal()
   commands_.empty();
 }
 
-WorkareaSetEnabledCommand::WorkareaSetEnabledCommand(TimelinePoints *points, bool enabled, QUndoCommand *parent) :
+WorkareaSetEnabledCommand::WorkareaSetEnabledCommand(Project* project, TimelinePoints *points, bool enabled, QUndoCommand *parent) :
   UndoCommand(parent),
+  project_(project),
   points_(points),
   old_enabled_(points_->workarea()->enabled()),
   new_enabled_(enabled)
 {
 }
 
+Project *WorkareaSetEnabledCommand::GetRelevantProject() const
+{
+  return project_;
+}
+
 void WorkareaSetEnabledCommand::redo_internal()
 {
   points_->workarea()->set_enabled(new_enabled_);
@@ -717,14 +794,20 @@ void WorkareaSetEnabledCommand::undo_internal()
   points_->workarea()->set_enabled(old_enabled_);
 }
 
-WorkareaSetRangeCommand::WorkareaSetRangeCommand(TimelinePoints *points, const TimeRange &range, QUndoCommand *parent) :
+WorkareaSetRangeCommand::WorkareaSetRangeCommand(Project* project, TimelinePoints *points, const TimeRange &range, QUndoCommand *parent) :
   UndoCommand(parent),
+  project_(project),
   points_(points),
   old_range_(points_->workarea()->range()),
   new_range_(range)
 {
 }
 
+Project *WorkareaSetRangeCommand::GetRelevantProject() const
+{
+  return project_;
+}
+
 void WorkareaSetRangeCommand::redo_internal()
 {
   points_->workarea()->set_range(new_range_);
@@ -743,6 +826,11 @@ BlockLinkCommand::BlockLinkCommand(Block *a, Block *b, bool link, QUndoCommand *
 {
 }
 
+Project *BlockLinkCommand::GetRelevantProject() const
+{
+  return static_cast<Sequence*>(a_->parent())->project();
+}
+
 void BlockLinkCommand::redo_internal()
 {
   if (link_) {
@@ -769,6 +857,11 @@ BlockUnlinkAllCommand::BlockUnlinkAllCommand(Block *block, QUndoCommand *parent)
 {
 }
 
+Project *BlockUnlinkAllCommand::GetRelevantProject() const
+{
+  return static_cast<Sequence*>(block_->parent())->project();
+}
+
 void BlockUnlinkAllCommand::redo_internal()
 {
   unlinked_ = block_->linked_clips();
@@ -788,10 +881,11 @@ void BlockUnlinkAllCommand::undo_internal()
 }
 
 BlockLinkManyCommand::BlockLinkManyCommand(const QList<Block *> blocks, bool link, QUndoCommand *parent) :
-  UndoCommand(parent)
+  UndoCommand(parent),
+  blocks_(blocks)
 {
-  foreach (Block* a, blocks) {
-    foreach (Block* b, blocks) {
+  foreach (Block* a, blocks_) {
+    foreach (Block* b, blocks_) {
       if (a != b) {
         new BlockLinkCommand(a, b, link, this);
       }
@@ -799,6 +893,11 @@ BlockLinkManyCommand::BlockLinkManyCommand(const QList<Block *> blocks, bool lin
   }
 }
 
+Project *BlockLinkManyCommand::GetRelevantProject() const
+{
+  return static_cast<Sequence*>(blocks_.first()->parent())->project();
+}
+
 BlockEnableDisableCommand::BlockEnableDisableCommand(Block *block, bool enabled, QUndoCommand *parent) :
   UndoCommand(parent),
   block_(block),
@@ -807,6 +906,11 @@ BlockEnableDisableCommand::BlockEnableDisableCommand(Block *block, bool enabled,
 {
 }
 
+Project *BlockEnableDisableCommand::GetRelevantProject() const
+{
+  return static_cast<Sequence*>(block_->parent())->project();
+}
+
 void BlockEnableDisableCommand::redo_internal()
 {
   block_->set_enabled(new_enabled_);

app/widget/timelinewidget/undo/undo.h

@@ -36,6 +36,8 @@ class BlockResizeCommand : public UndoCommand {
 public:
   BlockResizeCommand(Block* block, rational new_length, QUndoCommand* parent = nullptr);
 
+  virtual Project* GetRelevantProject() const override;
+
 protected:
   virtual void redo_internal() override;
   virtual void undo_internal() override;
@@ -50,6 +52,8 @@ class BlockResizeWithMediaInCommand : public UndoCommand {
 public:
   BlockResizeWithMediaInCommand(Block* block, rational new_length, QUndoCommand* parent = nullptr);
 
+  virtual Project* GetRelevantProject() const override;
+
 protected:
   virtual void redo_internal() override;
   virtual void undo_internal() override;
@@ -64,6 +68,8 @@ class BlockSetMediaInCommand : public UndoCommand {
 public:
   BlockSetMediaInCommand(Block* block, rational new_media_in, QUndoCommand* parent = nullptr);
 
+  virtual Project* GetRelevantProject() const override;
+
 protected:
   virtual void redo_internal() override;
   virtual void undo_internal() override;
@@ -78,6 +84,8 @@ class BlockSetSpeedCommand : public UndoCommand {
 public:
   BlockSetSpeedCommand(Block* block, const rational& new_speed, QUndoCommand* parent = nullptr);
 
+  virtual Project* GetRelevantProject() const override;
+
 protected:
   virtual void redo_internal() override;
   virtual void undo_internal() override;
@@ -93,6 +101,8 @@ class TrackRippleRemoveBlockCommand : public UndoCommand {
 public:
   TrackRippleRemoveBlockCommand(TrackOutput* track, Block* block, QUndoCommand* parent = nullptr);
 
+  virtual Project* GetRelevantProject() const override;
+
 protected:
   virtual void redo_internal() override;
   virtual void undo_internal() override;
@@ -109,6 +119,8 @@ class TrackPrependBlockCommand : public UndoCommand {
 public:
   TrackPrependBlockCommand(TrackOutput* track, Block* block, QUndoCommand* parent = nullptr);
 
+  virtual Project* GetRelevantProject() const override;
+
 protected:
   virtual void redo_internal() override;
   virtual void undo_internal() override;
@@ -122,6 +134,8 @@ class TrackInsertBlockAfterCommand : public UndoCommand {
 public:
   TrackInsertBlockAfterCommand(TrackOutput* track, Block* block, Block* before, QUndoCommand* parent = nullptr);
 
+  virtual Project* GetRelevantProject() const override;
+
 protected:
   virtual void redo_internal() override;
   virtual void undo_internal() override;
@@ -145,6 +159,8 @@ class TrackRippleRemoveAreaCommand : public UndoCommand {
 public:
   TrackRippleRemoveAreaCommand(TrackOutput* track, rational in, rational out, QUndoCommand* parent = nullptr);
 
+  virtual Project* GetRelevantProject() const override;
+
   void SetInsert(Block* insert);
 
 protected:
@@ -203,6 +219,8 @@ class BlockSplitCommand : public UndoCommand {
 public:
   BlockSplitCommand(TrackOutput* track, Block* block, rational point, QUndoCommand* parent = nullptr);
 
+  virtual Project* GetRelevantProject() const override;
+
   Block* new_block();
 
 protected:
@@ -228,12 +246,20 @@ private:
 class TrackSplitAtTimeCommand : public UndoCommand {
 public:
   TrackSplitAtTimeCommand(TrackOutput* track, rational point, QUndoCommand* parent = nullptr);
+
+  virtual Project* GetRelevantProject() const override;
+
+private:
+  TrackOutput* track_;
+
 };
 
 class BlockSplitPreservingLinksCommand : public UndoCommand {
 public:
   BlockSplitPreservingLinksCommand(const QVector<Block *> &blocks, const QList<rational>& times, QUndoCommand* parent = nullptr);
 
+  virtual Project* GetRelevantProject() const override;
+
 private:
   QVector<Block *> blocks_;
 
@@ -249,6 +275,8 @@ class TrackReplaceBlockCommand : public UndoCommand {
 public:
   TrackReplaceBlockCommand(TrackOutput* track, Block* old, Block* replace, QUndoCommand* parent = nullptr);
 
+  virtual Project* GetRelevantProject() const override;
+
 protected:
   virtual void redo_internal() override;
   virtual void undo_internal() override;
@@ -263,6 +291,8 @@ class TrackCleanGapsCommand : public UndoCommand {
 public:
   TrackCleanGapsCommand(TrackList* track_list, int index, QUndoCommand* parent = nullptr);
 
+  virtual Project* GetRelevantProject() const override;
+
 protected:
   virtual void redo_internal() override;
   virtual void undo_internal() override;
@@ -290,6 +320,8 @@ class TimelineRippleDeleteGapsAtRegionsCommand : public UndoCommand {
 public:
   TimelineRippleDeleteGapsAtRegionsCommand(ViewerOutput* vo, const TimeRangeList& regions, QUndoCommand* parent = nullptr);
 
+  virtual Project* GetRelevantProject() const override;
+
 protected:
   virtual void redo_internal() override;
   virtual void undo_internal() override;
@@ -304,13 +336,17 @@ private:
 
 class WorkareaSetEnabledCommand : public UndoCommand {
 public:
-  WorkareaSetEnabledCommand(TimelinePoints* points, bool enabled, QUndoCommand* parent = nullptr);
+  WorkareaSetEnabledCommand(Project *project, TimelinePoints* points, bool enabled, QUndoCommand* parent = nullptr);
+
+  virtual Project* GetRelevantProject() const override;
 
 protected:
   virtual void redo_internal() override;
   virtual void undo_internal() override;
 
 private:
+  Project* project_;
+
   TimelinePoints* points_;
 
   bool old_enabled_;
@@ -321,13 +357,17 @@ private:
 
 class WorkareaSetRangeCommand : public UndoCommand {
 public:
-  WorkareaSetRangeCommand(TimelinePoints* points, const TimeRange& range, QUndoCommand* parent = nullptr);
+  WorkareaSetRangeCommand(Project *project, TimelinePoints* points, const TimeRange& range, QUndoCommand* parent = nullptr);
+
+  virtual Project* GetRelevantProject() const override;
 
 protected:
   virtual void redo_internal() override;
   virtual void undo_internal() override;
 
 private:
+  Project* project_;
+
   TimelinePoints* points_;
 
   TimeRange old_range_;
@@ -339,12 +379,20 @@ private:
 class BlockLinkManyCommand : public UndoCommand {
 public:
   BlockLinkManyCommand(const QList<Block*> blocks, bool link, QUndoCommand* parent = nullptr);
+
+  virtual Project* GetRelevantProject() const override;
+
+private:
+  QList<Block*> blocks_;
+
 };
 
 class BlockLinkCommand : public UndoCommand {
 public:
   BlockLinkCommand(Block* a, Block* b, bool link, QUndoCommand* parent = nullptr);
 
+  virtual Project* GetRelevantProject() const override;
+
 protected:
   virtual void redo_internal() override;
   virtual void undo_internal() override;
@@ -364,6 +412,8 @@ class BlockUnlinkAllCommand : public UndoCommand {
 public:
   BlockUnlinkAllCommand(Block* block, QUndoCommand* parent = nullptr);
 
+  virtual Project* GetRelevantProject() const override;
+
 protected:
   virtual void redo_internal() override;
   virtual void undo_internal() override;
@@ -379,6 +429,8 @@ class BlockEnableDisableCommand : public UndoCommand {
 public:
   BlockEnableDisableCommand(Block* block, bool enabled, QUndoCommand* parent = nullptr);
 
+  virtual Project* GetRelevantProject() const override;
+
 protected:
   virtual void redo_internal() override;
   virtual void undo_internal() override;

app/widget/viewer/footageviewer.cpp

@@ -98,6 +98,11 @@ TimelinePoints *FootageViewerWidget::ConnectTimelinePoints()
   return footage_;
 }
 
+Project *FootageViewerWidget::GetTimelinePointsProject()
+{
+  return footage_->project();
+}
+
 void FootageViewerWidget::StartFootageDragInternal(bool enable_video, bool enable_audio)
 {
   if (!GetFootage()) {

app/widget/viewer/footageviewer.h

@@ -40,6 +40,8 @@ public:
 protected:
   virtual TimelinePoints* ConnectTimelinePoints() override;
 
+  virtual Project* GetTimelinePointsProject() override;
+
 private:
   void StartFootageDragInternal(bool enable_video, bool enable_audio);