constructed keyframeview and timeruler together inside nodeparamview and connected them

app/node/node.h

@@ -202,6 +202,12 @@ public:
    */
   void DisconnectAll();
 
+  template<class T>
+  /**
+   * @brief Find a node of a certain type that this Node outputs to
+   */
+  const T* FindOutputNode() const;
+
   /**
    * @brief Convert a pointer to a value that can be sent between NodeParams
    */
@@ -385,4 +391,29 @@ T* Node::ValueToPtr(const QVariant &ptr)
   return reinterpret_cast<T*>(ptr.value<quintptr>());
 }
 
+template<class T>
+const Node* FindOutputNodeInternal(const Node* n) {
+  foreach (NodeEdgePtr edge, n->output()->edges()) {
+    Node* connected = edge->input()->parentNode();
+    T* cast_test = dynamic_cast<T*>(connected);
+
+    if (cast_test) {
+      return cast_test;
+    } else {
+      const Node* drill_test = FindOutputNodeInternal<T>(connected);
+      if (drill_test) {
+        return drill_test;
+      }
+    }
+  }
+
+  return nullptr;
+}
+
+template<class T>
+const T* Node::FindOutputNode() const
+{
+  return static_cast<const T*>(FindOutputNodeInternal<T>(this));
+}
+
 #endif // NODE_H

app/node/output/viewer/viewer.cpp

@@ -93,12 +93,12 @@ void ViewerOutput::InvalidateCache(const rational &start_range, const rational &
   SendInvalidateCache(start_range, end_range);
 }
 
-const VideoParams &ViewerOutput::video_params()
+const VideoParams &ViewerOutput::video_params() const
 {
   return video_params_;
 }
 
-const AudioParams &ViewerOutput::audio_params()
+const AudioParams &ViewerOutput::audio_params() const
 {
   return audio_params_;
 }

app/node/output/viewer/viewer.h

@@ -51,8 +51,8 @@ public:
 
   virtual void InvalidateCache(const rational &start_range, const rational &end_range, NodeInput *from = nullptr) override;
 
-  const VideoParams& video_params();
+  const VideoParams& video_params() const;
-  const AudioParams& audio_params();
+  const AudioParams& audio_params() const;
 
   void set_video_params(const VideoParams& video);
   void set_audio_params(const AudioParams& audio);

app/panel/param/param.cpp

@@ -33,6 +33,16 @@ ParamPanel::ParamPanel(QWidget* parent) :
   Retranslate();
 }
 
+void ParamPanel::ZoomIn()
+{
+  view_->SetScale(view_->GetScale() * 2);
+}
+
+void ParamPanel::ZoomOut()
+{
+  view_->SetScale(view_->GetScale() * 0.5);
+}
+
 void ParamPanel::SetNodes(QList<Node *> nodes)
 {
   view_->SetNodes(nodes);

app/panel/param/param.h

@@ -30,11 +30,15 @@ class ParamPanel : public PanelWidget
 public:
   ParamPanel(QWidget* parent);
 
+  virtual void ZoomIn() override;
+
+  virtual void ZoomOut() override;
+
 public slots:
   void SetNodes(QList<Node*> nodes);
 
 protected:
-  virtual void changeEvent(QEvent* e);
+  virtual void changeEvent(QEvent* e) override;
 
 private:
   void Retranslate();

app/widget/keyframeview/keyframeview.cpp

@@ -3,25 +3,36 @@
 #include <QVBoxLayout>
 
 KeyframeView::KeyframeView(QWidget *parent) :
-  QWidget(parent)
+  TimelineViewBase(parent)
 {
-  QVBoxLayout* layout = new QVBoxLayout(this);
+  setBackgroundRole(QPalette::Base);
-  layout->setSpacing(0);
+  setAlignment(Qt::AlignLeft | Qt::AlignTop);
-  layout->setMargin(0);
+  setDragMode(QGraphicsView::RubberBandDrag);
-
-  ruler_ = new TimeRuler();
-  ruler_->SetTextVisible(true);
-  layout->addWidget(ruler_);
-
-  view_ = new QGraphicsView();
-  view_->setScene(&scene_);
-  view_->setBackgroundRole(QPalette::Base);
-  view_->setAlignment(Qt::AlignLeft | Qt::AlignTop);
-  view_->setDragMode(QGraphicsView::RubberBandDrag);
-  layout->addWidget(view_);
 }
 
-void KeyframeView::SetTimebase(const rational &timebase)
+void KeyframeView::mousePressEvent(QMouseEvent *event)
 {
-  ruler_->SetTimebase(timebase);
+  if (PlayheadPress(event)) {
+    return;
+  }
+
+  QGraphicsView::mousePressEvent(event);
+}
+
+void KeyframeView::mouseMoveEvent(QMouseEvent *event)
+{
+  if (PlayheadMove(event)) {
+    return;
+  }
+
+  QGraphicsView::mouseMoveEvent(event);
+}
+
+void KeyframeView::mouseReleaseEvent(QMouseEvent *event)
+{
+  if (PlayheadRelease(event)) {
+    return;
+  }
+
+  QGraphicsView::mouseReleaseEvent(event);
 }

app/widget/keyframeview/keyframeview.h

@@ -5,22 +5,22 @@
 
 #include "common/rational.h"
 #include "keyframeviewitem.h"
-#include "widget/timeruler/timeruler.h"
+#include "widget/timelinewidget/view/timelineviewbase.h"
 
-class KeyframeView : public QWidget
+class KeyframeView : public TimelineViewBase
 {
 public:
   KeyframeView(QWidget* parent = nullptr);
 
   void AddKeyframe(const rational& time, int y);
 
-  void SetTimebase(const rational& timebase);
+protected:
+  virtual void mousePressEvent(QMouseEvent *event) override;
+  virtual void mouseMoveEvent(QMouseEvent *event) override;
+  virtual void mouseReleaseEvent(QMouseEvent *event) override;
 
 private:
-  TimeRuler* ruler_;
-  QGraphicsView* view_;
 
-  QGraphicsScene scene_;
 };
 
 #endif // KEYFRAMEVIEW_H

app/widget/nodeparamview/nodeparamview.cpp

@@ -23,16 +23,18 @@
 #include <QScrollArea>
 #include <QSplitter>
 
+#include "node/output/viewer/viewer.h"
+
 NodeParamView::NodeParamView(QWidget *parent) :
   QWidget(parent)
 {
   // Create horizontal layout to place scroll area in (and keyframe editing eventually)
-  QHBoxLayout* widget_layout = new QHBoxLayout(this);
+  QVBoxLayout* layout = new QVBoxLayout(this);
-  widget_layout->setSpacing(0);
+  layout->setSpacing(0);
-  widget_layout->setMargin(0);
+  layout->setMargin(0);
 
   QSplitter* splitter = new QSplitter(Qt::Horizontal);
-  widget_layout->addWidget(splitter);
+  layout->addWidget(splitter);
 
   // Set up scroll area for params
   QScrollArea* scroll_area = new QScrollArea();
@@ -52,8 +54,24 @@ NodeParamView::NodeParamView(QWidget *parent) :
   param_layout_->addStretch();
 
   // Set up keyframe view
+  QWidget* keyframe_area = new QWidget();
+  QVBoxLayout* keyframe_area_layout = new QVBoxLayout(keyframe_area);
+  keyframe_area_layout->setSpacing(0);
+  keyframe_area_layout->setMargin(0);
+
+  // Create ruler object
+  ruler_ = new TimeRuler(true);
+  keyframe_area_layout->addWidget(ruler_);
+
+  // Create keyframe view
   keyframe_view_ = new KeyframeView();
-  splitter->addWidget(keyframe_view_);
+  keyframe_area_layout->addWidget(keyframe_view_);
+
+  // Connect ruler and keyframe view together
+  connect(ruler_, SIGNAL(TimeChanged(const int64_t&)), keyframe_view_, SLOT(SetTime(const int64_t&)));
+  connect(keyframe_view_, SIGNAL(TimeChanged(const int64_t&)), ruler_, SLOT(SetTime(const int64_t&)));
+
+  splitter->addWidget(keyframe_area);
 
   // Disable collapsing param view (but collapsing keyframe view is permitted)
   splitter->setCollapsible(0, false);
@@ -67,6 +85,9 @@ void NodeParamView::SetNodes(QList<Node *> nodes)
   }
   items_.clear();
 
+  // Reset keyframe view
+  SetTimebase(rational());
+
   // Set the internal list to the one we've received
   nodes_ = nodes;
 
@@ -97,9 +118,34 @@ void NodeParamView::SetNodes(QList<Node *> nodes)
       items_.append(item);
     }
   }
+
+  if (!nodes_.isEmpty()) {
+    const ViewerOutput* viewer = nodes_.first()->FindOutputNode<ViewerOutput>();
+
+    if (viewer) {
+      SetTimebase(viewer->video_params().time_base());
+    }
+  }
 }
 
 const QList<Node *> &NodeParamView::nodes()
 {
   return nodes_;
 }
+
+const double &NodeParamView::GetScale() const
+{
+  return ruler_->scale();
+}
+
+void NodeParamView::SetScale(const double& scale)
+{
+  ruler_->SetScale(scale);
+  keyframe_view_->SetScale(scale);
+}
+
+void NodeParamView::SetTimebase(const rational &timebase)
+{
+  ruler_->SetTimebase(timebase);
+  keyframe_view_->SetTimebase(timebase);
+}

app/widget/nodeparamview/nodeparamview.h

@@ -27,6 +27,7 @@
 #include "node/node.h"
 #include "nodeparamviewitem.h"
 #include "widget/keyframeview/keyframeview.h"
+#include "widget/timeruler/timeruler.h"
 
 class NodeParamView : public QWidget
 {
@@ -36,11 +37,18 @@ public:
   void SetNodes(QList<Node*> nodes);
   const QList<Node*>& nodes();
 
+  const double& GetScale() const;
+  void SetScale(const double &scale);
+
 private:
+  void SetTimebase(const rational& timebase);
+
   QVBoxLayout* param_layout_;
 
   KeyframeView* keyframe_view_;
 
+  TimeRuler* ruler_;
+
   QList<Node*> nodes_;
 
   QList<NodeParamViewItem*> items_;