use frame rate and timebase less interchangeably

app/widget/timebased/timebasedwidget.cpp

@@ -74,46 +74,58 @@ ViewerOutput *TimeBasedWidget::GetConnectedNode() const
 
 void TimeBasedWidget::ConnectViewerNode(ViewerOutput *node)
 {
+  // Ignore no-op
   if (viewer_node_ == node) {
     return;
   }
 
   if (viewer_node_) {
+    // Call potential derivative functions for disconnecting the viewer node
     DisconnectNodeInternal(viewer_node_);
 
+    // Disconnect length changed signal
     disconnect(viewer_node_, &ViewerOutput::LengthChanged, this, &TimeBasedWidget::UpdateMaximumScroll);
-    disconnect(viewer_node_, &ViewerOutput::TimebaseChanged, this, &TimeBasedWidget::SetTimebase);
 
-    if (auto_set_timebase_) {
-      SetTimebase(rational());
-    }
+    // Reset timebase to null
+    SetTimebase(rational());
 
+    // Disconnect ruler and scrollbar from timeline points
     ruler()->ConnectTimelinePoints(nullptr);
     scrollbar_->ConnectTimelinePoints(nullptr);
   }
 
+  // Set viewer node
   viewer_node_ = node;
 
+  // Call derivatives
   ConnectedNodeChanged(viewer_node_);
 
   if (viewer_node_) {
+    // Connect length changed signal
     connect(viewer_node_, &ViewerOutput::LengthChanged, this, &TimeBasedWidget::UpdateMaximumScroll);
 
+    // Connect ruler and scrollbar to timeline points
     ruler()->ConnectTimelinePoints(viewer_node_->GetTimelinePoints());
     scrollbar_->ConnectTimelinePoints(viewer_node_->GetTimelinePoints());
 
+    // If we're setting the timebase, set it automatically based on the video and audio parameters
     if (auto_set_timebase_) {
-      if (!viewer_node_->GetVideoParams().time_base().isNull()) {
-        SetTimebase(viewer_node_->GetVideoParams().time_base());
-      } else if (viewer_node_->GetAudioParams().sample_rate() > 0) {
-        SetTimebase(viewer_node_->GetAudioParams().time_base());
-      } else {
-        SetTimebase(rational());
-      }
+      rational video_tb = viewer_node_->GetVideoParams().frame_rate_as_time_base();
 
-      connect(viewer_node_, &ViewerOutput::TimebaseChanged, this, &TimeBasedWidget::SetTimebase);
+      if (!video_tb.isNull()) {
+        SetTimebase(video_tb);
+      } else {
+        rational audio_tb = viewer_node_->GetAudioParams().sample_rate_as_time_base();
+
+        if (!audio_tb.isNull()) {
+          SetTimebase(audio_tb);
+        } else {
+          SetTimebase(rational());
+        }
+      }
     }
 
+    // Call derivatives
     ConnectNodeInternal(viewer_node_);
   }
 

app/widget/timelinewidget/timelinewidget.cpp

@@ -224,11 +224,10 @@ void TimelineWidget::ConnectNodeInternal(ViewerOutput *n)
 
   connect(s, &Sequence::TrackAdded, this, &TimelineWidget::AddTrack);
   connect(s, &Sequence::TrackRemoved, this, &TimelineWidget::RemoveTrack);
-  connect(n, &ViewerOutput::TimebaseChanged, this, &TimelineWidget::SetTimebase);
 
   ruler()->SetPlaybackCache(n->video_frame_cache());
 
-  SetTimebase(n->GetVideoParams().time_base());
+  SetTimebase(n->GetVideoParams().frame_rate_as_time_base());
 
   for (int i=0;i<views_.size();i++) {
     Track::Type track_type = static_cast<Track::Type>(i);
@@ -253,7 +252,6 @@ void TimelineWidget::DisconnectNodeInternal(ViewerOutput *n)
 
   disconnect(s, &Sequence::TrackAdded, this, &TimelineWidget::AddTrack);
   disconnect(s, &Sequence::TrackRemoved, this, &TimelineWidget::RemoveTrack);
-  disconnect(n, &ViewerOutput::TimebaseChanged, this, &TimelineWidget::SetTimebase);
 
   DeselectAll();
 

app/widget/timelinewidget/tool/import.cpp

@@ -281,7 +281,7 @@ void ImportTool::PrepGhosts(const rational& frame, const int& track_index)
   if (parent()->GetConnectedNode()) {
     FootageToGhosts(frame,
                     dragged_footage_,
-                    parent()->timebase(),
+                    parent()->GetConnectedNode()->GetVideoParams().time_base(),
                     track_index);
   }
 }

app/widget/videoparamedit/videoparamedit.cpp

@@ -97,6 +97,10 @@ VideoParamEdit::VideoParamEdit(QWidget* parent) :
   connect(frame_rate_combobox_, static_cast<void (FrameRateComboBox::*)(int)>(&FrameRateComboBox::currentIndexChanged), this, &VideoParamEdit::Changed);
   layout->addWidget(frame_rate_combobox_, row, 1);
 
+  frame_rate_slider_ = new FloatSlider();
+  connect(frame_rate_slider_, &FloatSlider::ValueChanged, this, &VideoParamEdit::Changed);
+  layout->addWidget(frame_rate_slider_, row, 1);
+
   row++;
 
   // Pixel Aspect Ratio
@@ -215,7 +219,8 @@ void VideoParamEdit::SetParameterMask(uint64_t mask)
   depth_slider_->setVisible(mask & kDepth);
 
   frame_rate_lbl_->setVisible(mask & kFrameRate);
-  frame_rate_combobox_->setVisible(mask & kFrameRate);
+  frame_rate_combobox_->setVisible((mask & kFrameRate) && (mask & ~kFrameRateIsArbitrary));
+  frame_rate_slider_->setVisible((mask & kFrameRate) && (mask & kFrameRateIsArbitrary));
 
   pixel_aspect_lbl_->setVisible(mask & kPixelAspect);
   pixel_aspect_combobox_->setVisible(mask & kPixelAspect);
@@ -263,12 +268,22 @@ VideoParams VideoParamEdit::GetVideoParams() const
   p.set_height(height_slider_->GetValue());
   p.set_depth(depth_slider_->GetValue());
 
-  p.set_frame_rate(frame_rate_combobox_->GetFrameRate());
-  if (mask_ & kFrameRateIsNotTimebase) {
-    // Frame rate editor will only edit the frame rate
-    p.set_time_base(timebase_temp_);
-  } else {
-    p.set_time_base(frame_rate_combobox_->GetFrameRate().flipped());
+  {
+    rational using_frame_rate;
+
+    if (mask_ & kFrameRateIsArbitrary) {
+      using_frame_rate = rational::fromDouble(frame_rate_slider_->GetValue());
+    } else {
+      using_frame_rate = frame_rate_combobox_->GetFrameRate();
+    }
+
+    p.set_frame_rate(using_frame_rate);
+    if (mask_ & kFrameRateIsNotTimebase) {
+      // Frame rate editor will only edit the frame rate
+      p.set_time_base(timebase_temp_);
+    } else {
+      p.set_time_base(using_frame_rate.flipped());
+    }
   }
 
   p.set_pixel_aspect_ratio(pixel_aspect_combobox_->GetPixelAspectRatio());
@@ -295,14 +310,9 @@ void VideoParamEdit::SetVideoParams(const VideoParams &p)
   height_slider_->SetValue(p.height());
   depth_slider_->SetValue(p.depth());
 
-  if (mask_ & kFrameRateIsNotTimebase) {
-    // Frame rate editor will only edit the frame rate
-    frame_rate_combobox_->SetFrameRate(p.frame_rate());
-    timebase_temp_ = p.time_base();
-  } else {
-    // Frame rate editor will edit both frame rate and time base
-    frame_rate_combobox_->SetFrameRate(p.time_base().flipped());
-  }
+  frame_rate_combobox_->SetFrameRate(p.frame_rate());
+  frame_rate_slider_->SetValue(p.frame_rate().toDouble());
+  timebase_temp_ = p.time_base();
 
   pixel_aspect_combobox_->SetPixelAspectRatio(p.pixel_aspect_ratio());
   interlaced_combobox_->SetInterlaceMode(p.interlacing());

app/widget/videoparamedit/videoparamedit.h

@@ -27,6 +27,7 @@
 
 #include "render/colormanager.h"
 #include "render/videoparams.h"
+#include "widget/slider/floatslider.h"
 #include "widget/slider/integerslider.h"
 #include "widget/standardcombos/frameratecombobox.h"
 #include "widget/standardcombos/interlacedcombobox.h"
@@ -60,6 +61,7 @@ public:
     kPremultipliedAlpha = 0x2000,
     kColorspace = 0x4000,
     kFrameRateIsNotTimebase = 0x8000,
+    kFrameRateIsArbitrary = 0x10000
   };
 
   void SetParameterMask(uint64_t mask);
@@ -143,6 +145,7 @@ private:
   IntegerSlider* depth_slider_;
   QLabel* frame_rate_lbl_;
   FrameRateComboBox* frame_rate_combobox_;
+  FloatSlider* frame_rate_slider_;
   QLabel* pixel_aspect_lbl_;
   PixelAspectRatioComboBox* pixel_aspect_combobox_;
   QLabel* interlaced_lbl_;

app/widget/viewer/viewer.cpp

@@ -71,10 +71,13 @@ ViewerWidget::ViewerWidget(QWidget *parent) :
   stack_->addWidget(sizer_);
 
   display_widget_ = new ViewerDisplayWidget();
+  display_widget_->setAcceptDrops(true);
   connect(display_widget_, &ViewerDisplayWidget::customContextMenuRequested, this, &ViewerWidget::ShowContextMenu);
   connect(display_widget_, &ViewerDisplayWidget::CursorColor, this, &ViewerWidget::CursorColor);
   connect(display_widget_, &ViewerDisplayWidget::ColorProcessorChanged, this, &ViewerWidget::ColorProcessorChanged);
   connect(display_widget_, &ViewerDisplayWidget::ColorManagerChanged, this, &ViewerWidget::ColorManagerChanged);
+  connect(display_widget_, &ViewerDisplayWidget::DragEntered, this, &ViewerWidget::DragEntered);
+  connect(display_widget_, &ViewerDisplayWidget::Dropped, this, &ViewerWidget::Dropped);
   connect(sizer_, &ViewerSizer::RequestScale, display_widget_, &ViewerDisplayWidget::SetMatrixZoom);
   connect(sizer_, &ViewerSizer::RequestTranslate, display_widget_, &ViewerDisplayWidget::SetMatrixTranslate);
   connect(display_widget_, &ViewerDisplayWidget::HandDragMoved, sizer_, &ViewerSizer::HandDragMove);
@@ -118,6 +121,8 @@ ViewerWidget::ViewerWidget(QWidget *parent) :
   SetAutoMaxScrollBar(true);
 
   instances_.append(this);
+
+  setAcceptDrops(true);
 }
 
 ViewerWidget::~ViewerWidget()
@@ -1214,4 +1219,37 @@ void ViewerWidget::ViewerShiftedRange(const rational &from, const rational &to)
   }
 }
 
+void ViewerWidget::DragEntered(QDragEnterEvent* event)
+{
+  if (event->mimeData()->formats().contains(QStringLiteral("application/x-oliveprojectitemdata"))) {
+    event->accept();
+  }
+}
+
+void ViewerWidget::Dropped(QDropEvent *event)
+{
+  QByteArray mimedata = event->mimeData()->data(QStringLiteral("application/x-oliveprojectitemdata"));
+  QDataStream stream(&mimedata, QIODevice::ReadOnly);
+
+  // Variables to deserialize into
+  quintptr item_ptr = 0;
+  QVector<Track::Reference> enabled_streams;
+
+  while (!stream.atEnd()) {
+    stream >> enabled_streams >> item_ptr;
+
+    // We only need the one item
+    break;
+  }
+
+  if (item_ptr) {
+    Node* item = reinterpret_cast<Node*>(item_ptr);
+    ViewerOutput* viewer = dynamic_cast<ViewerOutput*>(item);
+
+    if (viewer) {
+      ConnectViewerNode(viewer);
+    }
+  }
+}
+
 }

app/widget/viewer/viewer.h

@@ -288,6 +288,10 @@ private slots:
 
   void TimeChangedFromWaveform(qint64 t);
 
+  void DragEntered(QDragEnterEvent* event);
+
+  void Dropped(QDropEvent* event);
+
 };
 
 }

app/widget/viewer/viewerdisplay.cpp

@@ -278,20 +278,29 @@ void ViewerDisplayWidget::mouseReleaseEvent(QMouseEvent *event)
 
 void ViewerDisplayWidget::dragEnterEvent(QDragEnterEvent *event)
 {
-  emit DragEntered();
-  super::dragEnterEvent(event);
+  emit DragEntered(event);
+
+  if (!event->isAccepted()) {
+    super::dragEnterEvent(event);
+  }
 }
 
 void ViewerDisplayWidget::dragLeaveEvent(QDragLeaveEvent *event)
 {
-  emit DragLeft();
-  super::dragLeaveEvent(event);
+  emit DragLeft(event);
+
+  if (!event->isAccepted()) {
+    super::dragLeaveEvent(event);
+  }
 }
 
 void ViewerDisplayWidget::dropEvent(QDropEvent *event)
 {
-  emit Dropped();
-  super::dropEvent(event);
+  emit Dropped(event);
+
+  if (!event->isAccepted()) {
+    super::dropEvent(event);
+  }
 }
 
 void ViewerDisplayWidget::OnPaint()
@@ -345,7 +354,7 @@ void ViewerDisplayWidget::OnPaint()
     rational node_time = GetGizmoTime();
 
     gizmo_db_ = gt.GenerateDatabase(gizmos_, TimeRange(node_time,
-                                                       node_time + gizmo_params_.time_base()));
+                                                       node_time + gizmo_params_.frame_rate_as_time_base()));
 
     QPainter p(inner_widget());
     p.setWorldTransform(GenerateGizmoTransform());

app/widget/viewer/viewerdisplay.h

@@ -170,11 +170,11 @@ signals:
    */
   void CursorColor(const Color& reference, const Color& display);
 
-  void DragEntered();
+  void DragEntered(QDragEnterEvent* event);
 
-  void DragLeft();
+  void DragLeft(QDragLeaveEvent* event);
 
-  void Dropped();
+  void Dropped(QDropEvent* event);
 
 protected:
   /**