make nodes more const friendly and prepare their functions for stateless work

Since the nodes won't be holding any rendering data themselves in this system,
we may as well enforce some level of non-write access by setting all the
functions to const. They were already const-friendly, they just weren't
labelled as such.

app/node/output/timeline/timeline.cpp

@@ -35,7 +35,6 @@ TimelineOutput::TimelineOutput()
   for (int i=0;i<kTrackTypeCount;i++) {
     // Create track input
     NodeInput* track_input = new NodeInput(QString("track_in_%1").arg(i));
-    track_input->set_data_type(NodeParam::kTrack);
     AddParameter(track_input);
     track_inputs_.replace(i, track_input);
 
@@ -53,58 +52,61 @@ TimelineOutput::TimelineOutput()
   AddParameter(length_output_);
 }
 
-Node *TimelineOutput::copy()
+Node *TimelineOutput::copy() const
 {
   return new TimelineOutput();
 }
 
-QString TimelineOutput::Name()
+QString TimelineOutput::Name() const
 {
   return tr("Timeline");
 }
 
-QString TimelineOutput::id()
+QString TimelineOutput::id() const
 {
   return "org.olivevideoeditor.Olive.timeline";
 }
 
-QString TimelineOutput::Category()
+QString TimelineOutput::Category() const
 {
   return tr("Output");
 }
 
-QString TimelineOutput::Description()
+QString TimelineOutput::Description() const
 {
   return tr("Node for communicating between a Timeline panel and the node graph.");
 }
 
-QVector<TrackOutput *> TimelineOutput::Tracks()
-{
-  return track_cache_;
-}
-
-NodeOutput *TimelineOutput::length_output()
-{
-  return length_output_;
-}
-
-const rational &TimelineOutput::timeline_length()
+const rational &TimelineOutput::length() const
 {
   return length_;
 }
 
-const rational &TimelineOutput::Timebase()
+const QVector<TrackOutput *>& TimelineOutput::Tracks() const
+{
+  return track_cache_;
+}
+
+NodeOutput *TimelineOutput::length_output() const
+{
+  return length_output_;
+}
+
+const rational &TimelineOutput::timeline_length() const
+{
+  return length_;
+}
+
+const rational &TimelineOutput::timebase() const
 {
   return timebase_;
 }
 
-QVariant TimelineOutput::Value(NodeOutput *output)
+NodeValueTable TimelineOutput::Value(const NodeValueDatabase &value) const
 {
-  if (output == length_output_) {
-    return QVariant::fromValue(length_);
-  }
-
-  return 0;
+  NodeValueTable table = value.Merge();
+  table.Push(NodeParam::kRational, QVariant::fromValue(length()));
+  return table;
 }
 
 void TimelineOutput::UpdateTrackCache()
@@ -150,12 +152,12 @@ void TimelineOutput::SetTimebase(const rational &timebase)
   emit TimebaseChanged(timebase_);
 }
 
-NodeInput *TimelineOutput::track_input(TrackType type)
+NodeInput *TimelineOutput::track_input(TrackType type) const
 {
   return track_inputs_.at(type);
 }
 
-TrackList *TimelineOutput::track_list(TrackType type)
+TrackList *TimelineOutput::track_list(TrackType type) const
 {
   return track_lists_.at(type);
 }

app/node/output/timeline/timeline.h

@@ -37,24 +37,26 @@ class TimelineOutput : public Node
 public:
   TimelineOutput();
 
-  virtual Node* copy() override;
+  virtual Node* copy() const override;
 
-  virtual QString Name() override;
-  virtual QString id() override;
-  virtual QString Category() override;
-  virtual QString Description() override;
+  virtual QString Name() const override;
+  virtual QString id() const override;
+  virtual QString Category() const override;
+  virtual QString Description() const override;
 
-  QVector<TrackOutput*> Tracks();
+  const rational& length() const;
 
-  NodeInput* track_input(TrackType type);
+  const QVector<TrackOutput *> &Tracks() const;
 
-  TrackList* track_list(TrackType type);
+  NodeInput* track_input(TrackType type) const;
 
-  NodeOutput* length_output();
+  TrackList* track_list(TrackType type) const;
 
-  const rational& timeline_length();
+  NodeOutput* length_output() const;
 
-  const rational& Timebase();
+  const rational& timeline_length() const;
+
+  const rational& timebase() const;
 
   void SetTimebase(const rational &timebase);
 
@@ -69,7 +71,7 @@ signals:
   void TrackRemoved(TrackOutput* track);
 
 protected:
-  virtual QVariant Value(NodeOutput* output) override;
+  virtual NodeValueTable Value(const NodeValueDatabase& value) const override;
 
 private:
   QVector<NodeInput*> track_inputs_;

app/node/output/track/track.cpp

@@ -37,7 +37,6 @@ TrackOutput::TrackOutput() :
   connect(block_input_, SIGNAL(SizeChanged(int)), this, SLOT(BlockListSizeChanged(int)));
 
   track_input_ = new NodeInput("track_in");
-  track_input_->set_data_type(NodeParam::kTrack);
   track_input_->set_dependent(false);
   AddParameter(track_input_);
 
@@ -55,32 +54,32 @@ const TrackType& TrackOutput::track_type()
   return track_type_;
 }
 
-Block::Type TrackOutput::type()
+Block::Type TrackOutput::type() const
 {
   return kTrack;
 }
 
-Block *TrackOutput::copy()
+Block *TrackOutput::copy() const
 {
   return new TrackOutput();
 }
 
-QString TrackOutput::Name()
+QString TrackOutput::Name() const
 {
   return tr("Track");
 }
 
-QString TrackOutput::id()
+QString TrackOutput::id() const
 {
   return "org.olivevideoeditor.Olive.track";
 }
 
-QString TrackOutput::Category()
+QString TrackOutput::Category() const
 {
   return tr("Output");
 }
 
-QString TrackOutput::Description()
+QString TrackOutput::Description() const
 {
   return tr("Node for representing and processing a single array of Blocks sorted by time. Also represents the end of "
             "a Sequence.");
@@ -98,7 +97,8 @@ void TrackOutput::SetIndex(const int &index)
 
 TrackOutput *TrackOutput::next_track()
 {
-  return ValueToPtr<TrackOutput>(track_input_->get_realtime_value_of_connected_output());
+  // FIXME: Re-do this without dynamic_cast at some point
+  return dynamic_cast<TrackOutput*>(track_input_->get_connected_node());
 }
 
 NodeInput *TrackOutput::track_input()
@@ -111,7 +111,7 @@ NodeOutput* TrackOutput::track_output()
   return track_output_;
 }
 
-Block *TrackOutput::BlockContainingTime(const rational &time)
+Block *TrackOutput::BlockContainingTime(const rational &time) const
 {
   foreach (Block* block, block_cache_) {
     if (block->in() < time && block->out() > time) {
@@ -124,7 +124,7 @@ Block *TrackOutput::BlockContainingTime(const rational &time)
   return nullptr;
 }
 
-Block *TrackOutput::NearestBlockBefore(const rational &time)
+Block *TrackOutput::NearestBlockBefore(const rational &time) const
 {
   foreach (Block* block, block_cache_) {
     // Blocks are sorted by time, so the first Block who's out point is at/after this time is the correct Block
@@ -133,10 +133,10 @@ Block *TrackOutput::NearestBlockBefore(const rational &time)
     }
   }
 
-  return this;
+  return nullptr;
 }
 
-Block *TrackOutput::NearestBlockAfter(const rational &time)
+Block *TrackOutput::NearestBlockAfter(const rational &time) const
 {
   foreach (Block* block, block_cache_) {
     // Blocks are sorted by time, so the first Block after this time is the correct Block
@@ -145,10 +145,10 @@ Block *TrackOutput::NearestBlockAfter(const rational &time)
     }
   }
 
-  return this;
+  return nullptr;
 }
 
-const QVector<Block *> &TrackOutput::Blocks()
+const QVector<Block *> &TrackOutput::Blocks() const
 {
   return block_cache_;
 }
@@ -163,17 +163,6 @@ void TrackOutput::InvalidateCache(const rational &start_range, const rational &e
   Node::InvalidateCache(start_range, end_range, from);
 }
 
-QVariant TrackOutput::Value(NodeOutput *output)
-{
-  if (output == track_output_) {
-    // Set track output correctly
-    return PtrToValue(this);
-  }
-
-  // Run default node processing
-  return Block::Value(output);
-}
-
 void TrackOutput::InsertBlockBefore(Block* block, Block* after)
 {
   InsertBlockAtIndex(block, block_cache_.indexOf(after));
@@ -301,12 +290,12 @@ TrackOutput *TrackOutput::TrackFromBlock(Block *block)
   return nullptr;
 }
 
-const rational &TrackOutput::track_length()
+const rational &TrackOutput::track_length() const
 {
   return track_length_;
 }
 
-bool TrackOutput::IsTrack()
+bool TrackOutput::IsTrack() const
 {
   return true;
 }

app/node/output/track/track.h

@@ -36,14 +36,14 @@ public:
   const TrackType& track_type();
   void set_track_type(const TrackType& track_type);
 
-  virtual Type type() override;
+  virtual Type type() const override;
 
-  virtual Block* copy() override;
+  virtual Block* copy() const override;
 
-  virtual QString Name() override;
-  virtual QString id() override;
-  virtual QString Category() override;
-  virtual QString Description() override;
+  virtual QString Name() const override;
+  virtual QString id() const override;
+  virtual QString Category() const override;
+  virtual QString Description() const override;
 
   const int& Index();
   void SetIndex(const int& index);
@@ -54,13 +54,13 @@ public:
 
   NodeOutput* track_output();
 
-  Block* BlockContainingTime(const rational& time);
+  Block* BlockContainingTime(const rational& time) const;
 
-  Block* NearestBlockBefore(const rational& time);
+  Block* NearestBlockBefore(const rational& time) const;
 
-  Block* NearestBlockAfter(const rational& time);
+  Block* NearestBlockAfter(const rational& time) const;
 
-  const QVector<Block*>& Blocks();
+  const QVector<Block*>& Blocks() const;
 
   virtual void InvalidateCache(const rational& start_range, const rational& end_range, NodeInput* from = nullptr) override;
 
@@ -124,9 +124,9 @@ public:
 
   static TrackOutput* TrackFromBlock(Block* block);
 
-  const rational& track_length();
+  const rational& track_length() const;
 
-  virtual bool IsTrack() override;
+  virtual bool IsTrack() const override;
 
 signals:
   /**
@@ -145,7 +145,6 @@ signals:
   void TrackLengthChanged();
 
 protected:
-  virtual QVariant Value(NodeOutput* output) override;
 
 private:
   void UpdateInOutFrom(int index);

app/node/output/viewer/viewer.cpp

@@ -35,27 +35,27 @@ ViewerOutput::ViewerOutput()
   AddParameter(length_input_);
 }
 
-Node *ViewerOutput::copy()
+Node *ViewerOutput::copy() const
 {
   return new ViewerOutput();
 }
 
-QString ViewerOutput::Name()
+QString ViewerOutput::Name() const
 {
   return tr("Viewer");
 }
 
-QString ViewerOutput::id()
+QString ViewerOutput::id() const
 {
   return "org.olivevideoeditor.Olive.vieweroutput";
 }
 
-QString ViewerOutput::Category()
+QString ViewerOutput::Category() const
 {
   return tr("Output");
 }
 
-QString ViewerOutput::Description()
+QString ViewerOutput::Description() const
 {
   return tr("Interface between a Viewer panel and the node system.");
 }
@@ -115,7 +115,8 @@ void ViewerOutput::set_audio_params(const AudioParams &audio)
 
 rational ViewerOutput::Length()
 {
-  return length_input_->get_realtime_value_of_connected_output().value<rational>();
+  // FIXME: This is pretty messy, there's probably a better way...
+  return length_input_->get_connected_node()->Value(NodeValueDatabase()).Get(NodeParam::kRational).value<rational>();
 }
 
 void ViewerOutput::DependentEdgeChanged(NodeInput *from)

app/node/output/viewer/viewer.h

@@ -36,12 +36,12 @@ class ViewerOutput : public Node
 public:
   ViewerOutput();
 
-  virtual Node* copy() override;
+  virtual Node* copy() const override;
 
-  virtual QString Name() override;
-  virtual QString id() override;
-  virtual QString Category() override;
-  virtual QString Description() override;
+  virtual QString Name() const override;
+  virtual QString id() const override;
+  virtual QString Category() const override;
+  virtual QString Description() const override;
 
   NodeInput* texture_input();
   NodeInput* samples_input();