multicam: prioritize current clip under playhead

app/panel/timeline/timeline.h

@@ -107,6 +107,11 @@ public:
     return timeline_widget()->GetSelectedBlocks();
   }
 
+  Sequence *GetSequence() const
+  {
+    return dynamic_cast<Sequence*>(GetConnectedViewer());
+  }
+
 protected:
   virtual void Retranslate() override;
 

app/widget/multicam/multicamwidget.cpp

@@ -54,7 +54,6 @@ void MulticamWidget::SetMulticamNode(MultiCamNode *n)
 {
   node_ = n;
   display_->SetMulticamNode(n);
-  display_->update();
 }
 
 void MulticamWidget::SetClip(ClipBlock *clip)

app/widget/viewer/viewer.cpp

@@ -799,6 +799,14 @@ void ViewerWidget::UpdateTextureFromNode()
   }
 }
 
+void ViewerWidget::SetMulticamNode(MultiCamNode *n)
+{
+  auto_cacher()->SetMulticamNode(n);
+  if (!IsPlaying()) {
+    UpdateTextureFromNode();
+  }
+}
+
 void ViewerWidget::PlayInternal(int speed, bool in_to_out_only)
 {
   Q_ASSERT(speed != 0);

app/widget/viewer/viewer.h

@@ -109,10 +109,7 @@ public:
     playback_devices_.push_back(vw);
   }
 
-  void SetMulticamNode(MultiCamNode *n)
+  void SetMulticamNode(MultiCamNode *n);
-  {
-    auto_cacher()->SetMulticamNode(n);
-  }
 
 public slots:
   void Play(bool in_to_out_only);

app/window/mainwindow/mainwindow.cpp

@@ -38,7 +38,8 @@
 namespace olive {
 
 MainWindow::MainWindow(QWidget *parent) :
-  QMainWindow(parent)
+  QMainWindow(parent),
+  last_multicam_panel_(nullptr)
 {
   // Resizes main window to desktop geometry on startup. Fixes the following issues:
   // * Qt on Windows has a bug that "de-maximizes" the window when widgets are added, resizing the
@@ -106,25 +107,17 @@ MainWindow::MainWindow(QWidget *parent) :
   connect(param_panel_, &ParamPanel::SelectedNodesChanged, node_panel_, &NodePanel::Select);
 
   // Connect time signals together
-  connect(multicam_panel_, &SequenceViewerPanel::TimeChanged, param_panel_, &ParamPanel::SetTime);
+  AddMainTimePanel(multicam_panel_);
-  connect(multicam_panel_, &SequenceViewerPanel::TimeChanged, curve_panel_, &NodeTablePanel::SetTime);
+  AddMainTimePanel(curve_panel_);
-  connect(multicam_panel_, &SequenceViewerPanel::TimeChanged, sequence_viewer_panel_, &SequenceViewerPanel::SetTime);
+  AddMainTimePanel(param_panel_);
-  connect(sequence_viewer_panel_, &SequenceViewerPanel::TimeChanged, param_panel_, &ParamPanel::SetTime);
+  AddMainTimePanel(sequence_viewer_panel_);
-  connect(sequence_viewer_panel_, &SequenceViewerPanel::TimeChanged, curve_panel_, &NodeTablePanel::SetTime);
-  connect(sequence_viewer_panel_, &SequenceViewerPanel::TimeChanged, multicam_panel_, &MulticamPanel::SetTime);
-  connect(param_panel_, &ParamPanel::TimeChanged, sequence_viewer_panel_, &SequenceViewerPanel::SetTime);
-  connect(param_panel_, &ParamPanel::TimeChanged, curve_panel_, &NodeTablePanel::SetTime);
-  connect(param_panel_, &ParamPanel::TimeChanged, multicam_panel_, &MulticamPanel::SetTime);
-  connect(curve_panel_, &ParamPanel::TimeChanged, sequence_viewer_panel_, &SequenceViewerPanel::SetTime);
-  connect(curve_panel_, &ParamPanel::TimeChanged, param_panel_, &NodeTablePanel::SetTime);
-  connect(curve_panel_, &ParamPanel::TimeChanged, multicam_panel_, &MulticamPanel::SetTime);
-
-  connect(PanelManager::instance(), &PanelManager::FocusedPanelChanged, this, &MainWindow::FocusedPanelChanged);
 
   sequence_viewer_panel_->ConnectTimeBasedPanel(param_panel_);
   sequence_viewer_panel_->ConnectTimeBasedPanel(curve_panel_);
   sequence_viewer_panel_->ConnectTimeBasedPanel(multicam_panel_);
 
+  connect(PanelManager::instance(), &PanelManager::FocusedPanelChanged, this, &MainWindow::FocusedPanelChanged);
+
   sequence_viewer_panel_->AddPlaybackDevice(multicam_panel_->GetMulticamWidget()->GetDisplayWidget());
 
   scope_panel_->SetViewerPanel(sequence_viewer_panel_);
@@ -500,29 +493,58 @@ void MainWindow::TimelinePanelSelectionChanged(const QVector<Block *> &blocks)
   if (PanelManager::instance()->CurrentlyFocused(false) == panel) {
     UpdateNodePanelContextFromTimelinePanel(panel);
 
-    ClipBlock *clip = nullptr;
+    last_multicam_panel_ = panel;
-    MultiCamNode *multicam = nullptr;
+    UpdateMulticamNode();
+  }
+}
 
-    for (Block *b : blocks) {
+void MainWindow::UpdateMulticamNode()
+{
+  TimelinePanel *panel = last_multicam_panel_;
+  if (!panel) {
+    return;
+  }
+
+  ClipBlock *clip = nullptr;
+  MultiCamNode *multicam = nullptr;
+
+  for (Block *b : panel->GetSelectedBlocks()) {
+    if (b->range().Contains(panel->GetTime())) {
       if ((clip = dynamic_cast<ClipBlock*>(b))) {
         if ((multicam = clip->FindMulticam())) {
           break;
         }
       }
     }
+  }
 
-    if (multicam) {
+  if (!multicam && panel->GetSequence()) {
-      sequence_viewer_panel_->SetMulticamNode(multicam);
+    const QVector<Track*> &tracks = panel->GetSequence()->GetTracks();
-      multicam_panel_->SetMulticamNode(multicam);
+    for (Track *t : tracks) {
-      multicam_panel_->SetClip(clip);
+      if (t->IsLocked()) {
-      multicam_panel_->ConnectViewerNode(panel->GetConnectedViewer());
+        continue;
-    } else {
+      }
-      sequence_viewer_panel_->SetMulticamNode(nullptr);
+
-      multicam_panel_->ConnectViewerNode(nullptr);
+      Block *b = t->NearestBlockBeforeOrAt(panel->GetTime());
-      multicam_panel_->SetMulticamNode(nullptr);
+      if ((clip = dynamic_cast<ClipBlock*>(b))) {
-      multicam_panel_->SetClip(nullptr);
+        if ((multicam = clip->FindMulticam())) {
+          break;
+        }
+      }
     }
   }
+
+  if (multicam) {
+    multicam_panel_->SetMulticamNode(multicam);
+    sequence_viewer_panel_->SetMulticamNode(multicam);
+    multicam_panel_->SetClip(clip);
+    multicam_panel_->ConnectViewerNode(panel->GetConnectedViewer());
+  } else {
+    multicam_panel_->ConnectViewerNode(nullptr);
+    sequence_viewer_panel_->SetMulticamNode(nullptr);
+    multicam_panel_->SetMulticamNode(nullptr);
+    multicam_panel_->SetClip(nullptr);
+  }
 }
 
 void MainWindow::ShowWelcomeDialog()
@@ -624,23 +646,34 @@ void MainWindow::FloatingPanelCloseRequested()
   panel->deleteLater();
 }
 
+void MainWindow::AddMainTimePanel(TimeBasedPanel *p)
+{
+  main_time_panels_.append(p);
+  connect(p, &TimeBasedPanel::TimeChanged, this, &MainWindow::UpdateMainTimePanels);
+}
+
+void MainWindow::UpdateMainTimePanels(const rational &r)
+{
+  for (TimeBasedPanel *p : main_time_panels_) {
+    if (p != sender()) {
+      p->SetTime(r);
+    }
+  }
+
+  UpdateMulticamNode();
+}
+
 TimelinePanel* MainWindow::AppendTimelinePanel()
 {
   TimelinePanel* panel = AppendPanelInternal<TimelinePanel>(timeline_panels_);
 
   connect(panel, &PanelWidget::CloseRequested, this, &MainWindow::TimelineCloseRequested);
-  connect(panel, &TimelinePanel::TimeChanged, curve_panel_, &ParamPanel::SetTime);
-  connect(panel, &TimelinePanel::TimeChanged, param_panel_, &ParamPanel::SetTime);
-  connect(panel, &TimelinePanel::TimeChanged, sequence_viewer_panel_, &SequenceViewerPanel::SetTime);
-  connect(panel, &TimelinePanel::TimeChanged, multicam_panel_, &MulticamPanel::SetTime);
   connect(panel, &TimelinePanel::RequestCaptureStart, sequence_viewer_panel_, &SequenceViewerPanel::StartCapture);
   connect(panel, &TimelinePanel::BlockSelectionChanged, this, &MainWindow::TimelinePanelSelectionChanged);
   connect(panel, &TimelinePanel::RevealViewerInProject, this, &MainWindow::RevealViewerInProject);
   connect(panel, &TimelinePanel::RevealViewerInFootageViewer, this, &MainWindow::RevealViewerInFootageViewer);
-  connect(param_panel_, &ParamPanel::TimeChanged, panel, &TimelinePanel::SetTime);
+
-  connect(curve_panel_, &ParamPanel::TimeChanged, panel, &TimelinePanel::SetTime);
+  AddMainTimePanel(panel);
-  connect(multicam_panel_, &SequenceViewerPanel::TimeChanged, panel, &TimelinePanel::SetTime);
-  connect(sequence_viewer_panel_, &SequenceViewerPanel::TimeChanged, panel, &TimelinePanel::SetTime);
 
   sequence_viewer_panel_->ConnectTimeBasedPanel(panel);
 
@@ -660,6 +693,9 @@ ProjectPanel *MainWindow::AppendProjectPanel()
 void MainWindow::RemoveTimelinePanel(TimelinePanel *panel)
 {
   // Stop showing this timeline in the viewer
+  if (last_multicam_panel_ == panel) {
+    last_multicam_panel_ = nullptr;
+  }
   TimelineFocused(nullptr);
   panel->ConnectViewerNode(nullptr);
 

app/window/mainwindow/mainwindow.h

@@ -147,6 +147,10 @@ private:
 
   void SelectFootageForProjectPanel(const QVector<Footage*> &e, ProjectPanel *p);
 
+  void UpdateMulticamNode();
+
+  void AddMainTimePanel(TimeBasedPanel *p);
+
   QByteArray premaximized_state_;
 
   // Standard panels
@@ -174,6 +178,10 @@ private:
 
   bool first_show_;
 
+  QVector<TimeBasedPanel*> main_time_panels_;
+
+  TimelinePanel *last_multicam_panel_;
+
 private slots:
   void FocusedPanelChanged(PanelWidget* panel);
 
@@ -204,6 +212,8 @@ private slots:
   void RevealViewerInProject(ViewerOutput *r);
   void RevealViewerInFootageViewer(ViewerOutput *r, const TimeRange &range);
 
+  void UpdateMainTimePanels(const rational &r);
+
 };
 
 }