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/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_);