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