viewer: allow switching open sequences

app/codec/ffmpeg/ffmpegencoder.cpp

@@ -75,7 +75,6 @@ void FFmpegEncoder::WriteAudio(const AudioRenderingParams &pcm_info, const QStri
                                   reinterpret_cast<const uint8_t**>(&input_data_array),
                                   samples_needed);
 
-      //qDebug() << "swr_convert returned" << converted << "samples";
       frame->pts = sample_counter;
 
       sample_counter += converted;

app/codec/ffmpeg/ffmpegframecache.cpp

@@ -65,14 +65,9 @@ void FFmpegFrameCache::Client::accessed(int i)
 
 void FFmpegFrameCache::Client::remove_old_frames(qint64 older_than)
 {
-  //int counter = 0;
-
   while (!frames_.isEmpty() && frames_.first().accessed < older_than) {
     FFmpegFrameCache::Release(frames_.takeFirst().frame);
-    //counter++;
   }
-
-  //qDebug() << "  * Removed" << counter << "frames";
 }
 
 Frame* FFmpegFrameCache::Get(const VideoRenderingParams &params)

app/core.cpp

@@ -255,16 +255,16 @@ void Core::DialogProjectPropertiesShow()
 
 void Core::DialogExportShow()
 {
-  ViewerPanel* latest_viewer = PanelManager::instance()->MostRecentlyFocused<ViewerPanel>();
+  TimeBasedPanel* latest_time_based = PanelManager::instance()->MostRecentlyFocused<TimeBasedPanel>();
 
-  if (latest_viewer && latest_viewer->GetConnectedViewer()) {
-    if (latest_viewer->GetConnectedViewer()->Length() == 0) {
+  if (latest_time_based && latest_time_based->GetConnectedViewer()) {
+    if (latest_time_based->GetConnectedViewer()->Length() == 0) {
       QMessageBox::critical(main_window_,
                             tr("Error"),
                             tr("This Sequence is empty. There is nothing to export."),
                             QMessageBox::Ok);
     } else {
-      ExportDialog ed(latest_viewer->GetConnectedViewer(), main_window_);
+      ExportDialog ed(latest_time_based->GetConnectedViewer(), main_window_);
       ed.exec();
     }
   }
@@ -333,7 +333,7 @@ void Core::CreateNewSequence()
 
     Core::instance()->undo_stack()->push(aic);
 
-    Sequence::Open(new_sequence.get());
+    Core::instance()->main_window()->OpenSequence(new_sequence.get());
   }
 }
 

app/panel/CMakeLists.txt

@@ -20,6 +20,7 @@ add_subdirectory(footageviewer)
 add_subdirectory(node)
 add_subdirectory(param)
 add_subdirectory(project)
+add_subdirectory(sequenceviewer)
 add_subdirectory(taskmanager)
 add_subdirectory(timebased)
 add_subdirectory(timeline)

app/panel/project/project.cpp

@@ -30,6 +30,7 @@
 #include "project/item/sequence/sequence.h"
 #include "widget/menu/menushared.h"
 #include "widget/projecttoolbar/projecttoolbar.h"
+#include "window/mainwindow/mainwindow.h"
 
 ProjectPanel::ProjectPanel(QWidget *parent) :
   PanelWidget(parent)
@@ -154,7 +155,7 @@ void ProjectPanel::ItemDoubleClickSlot(Item *item)
     PanelManager::instance()->MostRecentlyFocused<FootageViewerPanel>()->SetFootage(static_cast<Footage*>(item));
   } else if (item->type() == Item::kSequence) {
     // Open this sequence in the Timeline
-    Sequence::Open(static_cast<Sequence*>(item));
+    Core::instance()->main_window()->OpenSequence(static_cast<Sequence*>(item));
   }
 }
 

app/panel/sequenceviewer/CMakeLists.txt

@@ -0,0 +1,22 @@
+# Olive - Non-Linear Video Editor
+# Copyright (C) 2019 Olive Team
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+set(OLIVE_SOURCES
+  ${OLIVE_SOURCES}
+  panel/sequenceviewer/sequenceviewer.h
+  panel/sequenceviewer/sequenceviewer.cpp
+  PARENT_SCOPE
+)

app/panel/sequenceviewer/sequenceviewer.cpp

@@ -0,0 +1,18 @@
+#include "sequenceviewer.h"
+
+SequenceViewerPanel::SequenceViewerPanel(QWidget *parent) :
+  ViewerPanel(parent)
+{
+  // FIXME: This won't work if there's ever more than one of this panel
+  setObjectName("SequenceViewerPanel");
+
+  // Set strings
+  Retranslate();
+}
+
+void SequenceViewerPanel::Retranslate()
+{
+  ViewerPanel::Retranslate();
+
+  SetTitle(tr("Sequence Viewer"));
+}

app/panel/sequenceviewer/sequenceviewer.h

@@ -0,0 +1,16 @@
+#ifndef SEQUENCEVIEWERPANEL_H
+#define SEQUENCEVIEWERPANEL_H
+
+#include "panel/viewer/viewer.h"
+
+class SequenceViewerPanel : public ViewerPanel
+{
+public:
+  SequenceViewerPanel(QWidget* parent);
+
+protected:
+  virtual void Retranslate() override;
+
+};
+
+#endif // SEQUENCEVIEWERPANEL_H

app/panel/viewer/viewerbase.cpp

@@ -33,6 +33,14 @@ void ViewerPanelBase::ConnectTimeBasedPanel(TimeBasedPanel *panel)
   connect(panel, &TimeBasedPanel::ShuttleRightRequested, this, &ViewerPanelBase::ShuttleRight);
 }
 
+void ViewerPanelBase::DisconnectTimeBasedPanel(TimeBasedPanel *panel)
+{
+  disconnect(panel, &TimeBasedPanel::PlayPauseRequested, this, &ViewerPanelBase::PlayPause);
+  disconnect(panel, &TimeBasedPanel::ShuttleLeftRequested, this, &ViewerPanelBase::ShuttleLeft);
+  disconnect(panel, &TimeBasedPanel::ShuttleStopRequested, this, &ViewerPanelBase::ShuttleStop);
+  disconnect(panel, &TimeBasedPanel::ShuttleRightRequested, this, &ViewerPanelBase::ShuttleRight);
+}
+
 VideoRenderBackend *ViewerPanelBase::video_renderer() const
 {
   return static_cast<ViewerWidget*>(GetTimeBasedWidget())->video_renderer();

app/panel/viewer/viewerbase.h

@@ -20,6 +20,8 @@ public:
 
   void ConnectTimeBasedPanel(TimeBasedPanel* panel);
 
+  void DisconnectTimeBasedPanel(TimeBasedPanel* panel);
+
   VideoRenderBackend* video_renderer() const;
 
 };

app/project/item/folder/folder.cpp

@@ -46,8 +46,6 @@ QIcon Folder::icon()
 
 void Folder::Load(QXmlStreamReader *reader, QHash<quintptr, StreamPtr> &footage_ptrs, QList<NodeParam::FootageConnection>& footage_connections, const QAtomicInt *cancelled)
 {
-  qDebug() << "Hello?";
-
   XMLAttributeLoop(reader, attr) {
     if (cancelled && *cancelled) {
       return;

app/project/item/sequence/sequence.cpp

@@ -32,7 +32,7 @@
 #include "panel/curve/curve.h"
 #include "panel/param/param.h"
 #include "panel/timeline/timeline.h"
-#include "panel/viewer/viewer.h"
+#include "panel/sequenceviewer/sequenceviewer.h"
 #include "ui/icons/icons.h"
 
 Sequence::Sequence()
@@ -161,19 +161,6 @@ void Sequence::Save(QXmlStreamWriter *writer) const
   writer->writeEndElement(); // sequence
 }
 
-void Sequence::Open(Sequence* sequence)
-{
-  // FIXME: This is fairly "hardcoded" behavior and doesn't support infinite panels
-
-  ViewerPanel* viewer_panel = PanelManager::instance()->MostRecentlyFocused<ViewerPanel>();
-  TimelinePanel* timeline_panel = PanelManager::instance()->MostRecentlyFocused<TimelinePanel>();
-  NodePanel* node_panel = PanelManager::instance()->MostRecentlyFocused<NodePanel>();
-
-  viewer_panel->ConnectViewerNode(sequence->viewer_output_);
-  timeline_panel->ConnectViewerNode(sequence->viewer_output_);
-  node_panel->SetGraph(sequence);
-}
-
 void Sequence::add_default_nodes()
 {
   // Create tracks and connect them to the viewer

app/project/item/sequence/sequence.h

@@ -50,8 +50,6 @@ public:
    */
   virtual void Save(QXmlStreamWriter *writer) const override;
 
-  static void Open(Sequence *sequence);
-
   void add_default_nodes();
 
   /**

app/project/project.cpp

@@ -35,8 +35,6 @@ Project::Project()
 
 void Project::Load(QXmlStreamReader *reader, const QAtomicInt* cancelled)
 {
-  qDebug() << "Hello?";
-
   QHash<quintptr, StreamPtr> footage_ptrs;
   QList<NodeInput::FootageConnection> footage_connections;
 

app/project/projectloadmanager.cpp

@@ -19,8 +19,6 @@ void ProjectLoadManager::Action()
   if (project_file.open(QFile::ReadOnly | QFile::Text)) {
     QXmlStreamReader reader(&project_file);
 
-    qDebug() << "Hello?";
-
     while (XMLReadNextStartElement(&reader)) {
       if (reader.name() == QStringLiteral("olive")) {
         while(XMLReadNextStartElement(&reader)) {

app/widget/timebased/timebased.cpp

@@ -116,7 +116,7 @@ ResizableScrollBar *TimeBasedWidget::scrollbar() const
 
 void TimeBasedWidget::TimebaseChangedEvent(const rational &timebase)
 {
-  TimelineScaledObject::TimebaseChangedEvent(timebase);
+  TimelineScaledWidget::TimebaseChangedEvent(timebase);
 
   ruler_->SetTimebase(timebase);
 
@@ -125,7 +125,7 @@ void TimeBasedWidget::TimebaseChangedEvent(const rational &timebase)
 
 void TimeBasedWidget::ScaleChangedEvent(const double &scale)
 {
-  TimelineScaledObject::ScaleChangedEvent(scale);
+  TimelineScaledWidget::ScaleChangedEvent(scale);
 
   ruler_->SetScale(scale);
 
@@ -166,13 +166,13 @@ void TimeBasedWidget::SetTime(int64_t timestamp)
 
 void TimeBasedWidget::SetTimebase(const rational &timebase)
 {
-  TimelineScaledObject::SetTimebase(timebase);
+  TimelineScaledWidget::SetTimebase(timebase);
 }
 
 void TimeBasedWidget::SetScale(const double &scale)
 {
-  // Simple QObject slot wrapper around TimelineScaledObject::SetScale()
-  TimelineScaledObject::SetScale(scale);
+  // Simple QObject slot wrapper around TimelineScaledWidget::SetScale()
+  TimelineScaledWidget::SetScale(scale);
 }
 
 void TimeBasedWidget::ZoomIn()

app/widget/timelinewidget/tool/import.cpp

@@ -35,6 +35,7 @@
 #include "node/input/media/video/video.h"
 #include "project/item/sequence/sequence.h"
 #include "widget/nodeview/nodeviewundo.h"
+#include "window/mainwindow/mainwindow.h"
 
 Timeline::TrackType TrackTypeFromStreamType(Stream::Type stream_type)
 {
@@ -433,6 +434,6 @@ void TimelineWidget::ImportTool::DropGhosts(bool insert)
   dragged_footage_.clear();
 
   if (open_sequence) {
-    Sequence::Open(open_sequence);
+    Core::instance()->main_window()->OpenSequence(open_sequence);
   }
 }

app/window/mainwindow/mainwindow.cpp

@@ -66,48 +66,80 @@ MainWindow::MainWindow(QWidget *parent) :
   param_panel_ = PanelManager::instance()->CreatePanel<ParamPanel>(this);
   tabifyDockWidget(footage_viewer_panel_, param_panel_);
   footage_viewer_panel_->raise();
-  viewer_panel_ = PanelManager::instance()->CreatePanel<ViewerPanel>(this);
-  addDockWidget(Qt::TopDockWidgetArea, viewer_panel_);
+  sequence_viewer_panel_ = PanelManager::instance()->CreatePanel<SequenceViewerPanel>(this);
+  addDockWidget(Qt::TopDockWidgetArea, sequence_viewer_panel_);
   project_panel_ = PanelManager::instance()->CreatePanel<ProjectPanel>(this);
   addDockWidget(Qt::BottomDockWidgetArea, project_panel_);
   tool_panel_ = PanelManager::instance()->CreatePanel<ToolPanel>(this);
   addDockWidget(Qt::BottomDockWidgetArea, tool_panel_);
-  timeline_panel_ = PanelManager::instance()->CreatePanel<TimelinePanel>(this);
-  addDockWidget(Qt::BottomDockWidgetArea, timeline_panel_);
-  audio_monitor_panel_ = PanelManager::instance()->CreatePanel<AudioMonitorPanel>(this);
-  addDockWidget(Qt::BottomDockWidgetArea, audio_monitor_panel_);
   task_man_panel_ = PanelManager::instance()->CreatePanel<TaskManagerPanel>(this);
   addDockWidget(Qt::BottomDockWidgetArea, task_man_panel_);
   curve_panel_ = PanelManager::instance()->CreatePanel<CurvePanel>(this);
   addDockWidget(Qt::BottomDockWidgetArea, curve_panel_);
+  AppendTimelinePanel();
+  audio_monitor_panel_ = PanelManager::instance()->CreatePanel<AudioMonitorPanel>(this);
+  addDockWidget(Qt::BottomDockWidgetArea, audio_monitor_panel_);
 
-  // FIXME: This is fairly "hardcoded" behavior and doesn't support infinite panels
+  // Make connections to sequence viewer
   connect(node_panel_, &NodePanel::SelectionChanged, param_panel_, &ParamPanel::SetNodes);
   connect(param_panel_, &ParamPanel::SelectedInputChanged, curve_panel_, &CurvePanel::SetInput);
   connect(param_panel_, &ParamPanel::TimebaseChanged, curve_panel_, &CurvePanel::SetTimebase);
-  connect(timeline_panel_, &TimelinePanel::TimeChanged, param_panel_, &ParamPanel::SetTime);
-  connect(timeline_panel_, &TimelinePanel::TimeChanged, viewer_panel_, &ViewerPanel::SetTime);
-  connect(timeline_panel_, &TimelinePanel::TimeChanged, curve_panel_, &CurvePanel::SetTime);
-  connect(timeline_panel_, &TimelinePanel::SelectionChanged, node_panel_, &NodePanel::SelectWithDependencies);
-  connect(viewer_panel_, &ViewerPanel::TimeChanged, param_panel_, &ParamPanel::SetTime);
-  connect(viewer_panel_, &ViewerPanel::TimeChanged, timeline_panel_, &TimelinePanel::SetTime);
-  connect(viewer_panel_, &ViewerPanel::TimeChanged, curve_panel_, &CurvePanel::SetTime);
-  connect(param_panel_, &ParamPanel::TimeChanged, viewer_panel_, &ViewerPanel::SetTime);
-  connect(param_panel_, &ParamPanel::TimeChanged, timeline_panel_, &TimelinePanel::SetTime);
+  connect(sequence_viewer_panel_, &SequenceViewerPanel::TimeChanged, param_panel_, &ParamPanel::SetTime);
+  connect(sequence_viewer_panel_, &SequenceViewerPanel::TimeChanged, curve_panel_, &CurvePanel::SetTime);
+  connect(param_panel_, &ParamPanel::TimeChanged, sequence_viewer_panel_, &SequenceViewerPanel::SetTime);
   connect(param_panel_, &ParamPanel::TimeChanged, curve_panel_, &CurvePanel::SetTime);
-  connect(curve_panel_, &CurvePanel::TimeChanged, viewer_panel_, &ViewerPanel::SetTime);
-  connect(curve_panel_, &CurvePanel::TimeChanged, timeline_panel_, &TimelinePanel::SetTime);
+  connect(curve_panel_, &CurvePanel::TimeChanged, sequence_viewer_panel_, &SequenceViewerPanel::SetTime);
   connect(curve_panel_, &CurvePanel::TimeChanged, param_panel_, &ParamPanel::SetTime);
-  connect(viewer_panel_->video_renderer(), &VideoRenderBackend::CachedTimeReady, timeline_panel_->ruler(), &TimeRuler::CacheTimeReady);
-  connect(viewer_panel_->video_renderer(), &VideoRenderBackend::RangeInvalidated, timeline_panel_->ruler(), &TimeRuler::CacheInvalidatedRange);
 
-  viewer_panel_->ConnectTimeBasedPanel(timeline_panel_);
-  viewer_panel_->ConnectTimeBasedPanel(param_panel_);
-  viewer_panel_->ConnectTimeBasedPanel(curve_panel_);
+  sequence_viewer_panel_->ConnectTimeBasedPanel(param_panel_);
+  sequence_viewer_panel_->ConnectTimeBasedPanel(curve_panel_);
 
   UpdateTitle();
 }
 
+void MainWindow::OpenSequence(Sequence *sequence)
+{
+  // See if this sequence is already open, and switch to it if so
+  for (int i=0;i<timeline_panels_.size();i++) {
+    TimelinePanel* tl = timeline_panels_.at(i);
+
+    if (tl->GetConnectedViewer() == sequence->viewer_output()) {
+      tl->raise();
+      return;
+    }
+  }
+
+  // See if we have any sequences open or not
+  TimelinePanel* panel;
+
+  if (!timeline_panels_.first()->GetConnectedViewer()) {
+    panel = timeline_panels_.first();
+  } else {
+    panel = AppendTimelinePanel();
+  }
+
+  panel->ConnectViewerNode(sequence->viewer_output());
+
+  TimelineFocused(panel);
+}
+
+void MainWindow::CloseSequence(Sequence *sequence)
+{
+  for (int i=0;i<timeline_panels_.size();i++) {
+    TimelinePanel* tl = timeline_panels_.at(i);
+
+    if (tl->GetConnectedViewer() == sequence->viewer_output()) {
+      tl->ConnectViewerNode(nullptr);
+
+      if (timeline_panels_.size() > 1) {
+        delete tl;
+        timeline_panels_.removeAt(i);
+        i--;
+      }
+    }
+  }
+}
+
 void MainWindow::SetFullscreen(bool fullscreen)
 {
   if (fullscreen) {
@@ -184,8 +216,8 @@ void MainWindow::closeEvent(QCloseEvent *e)
   }
 
   // Close viewers first since we don't want to delete any nodes while they might be mid-render
-  QList<ViewerPanel*> viewers = PanelManager::instance()->GetPanelsOfType<ViewerPanel>();
-  foreach (ViewerPanel* viewer, viewers) {
+  QList<ViewerPanelBase*> viewers = PanelManager::instance()->GetPanelsOfType<ViewerPanelBase>();
+  foreach (ViewerPanelBase* viewer, viewers) {
     viewer->ConnectViewerNode(nullptr);
   }
 
@@ -201,6 +233,58 @@ void MainWindow::UpdateTitle()
                                                      tr("(untitled)")));
 }
 
+TimelinePanel* MainWindow::AppendTimelinePanel()
+{
+  TimelinePanel* panel = PanelManager::instance()->CreatePanel<TimelinePanel>(this);;
+
+  if (timeline_panels_.isEmpty()) {
+    addDockWidget(Qt::BottomDockWidgetArea, panel);
+  } else {
+    tabifyDockWidget(timeline_panels_.last(), panel);
+
+    // For some reason raise() on its own doesn't do anything, we need both
+    panel->show();
+    panel->raise();
+  }
+
+  timeline_panels_.append(panel);
+
+  connect(panel, &TimelinePanel::TimeChanged, param_panel_, &ParamPanel::SetTime);
+  connect(panel, &TimelinePanel::TimeChanged, sequence_viewer_panel_, &SequenceViewerPanel::SetTime);
+  connect(panel, &TimelinePanel::TimeChanged, curve_panel_, &CurvePanel::SetTime);
+  connect(panel, &TimelinePanel::SelectionChanged, node_panel_, &NodePanel::SelectWithDependencies);
+  connect(panel, &TimelinePanel::visibilityChanged, this, &MainWindow::TimelineFocusedSlot);
+  connect(param_panel_, &ParamPanel::TimeChanged, panel, &TimelinePanel::SetTime);
+  connect(curve_panel_, &CurvePanel::TimeChanged, panel, &TimelinePanel::SetTime);
+  connect(sequence_viewer_panel_, &SequenceViewerPanel::TimeChanged, panel, &TimelinePanel::SetTime);
+  connect(sequence_viewer_panel_->video_renderer(), &VideoRenderBackend::CachedTimeReady, panel->ruler(), &TimeRuler::CacheTimeReady);
+  connect(sequence_viewer_panel_->video_renderer(), &VideoRenderBackend::RangeInvalidated, panel->ruler(), &TimeRuler::CacheInvalidatedRange);
+
+  sequence_viewer_panel_->ConnectTimeBasedPanel(panel);
+
+  return panel;
+}
+
+void MainWindow::TimelineFocused(TimelinePanel* panel)
+{
+  sequence_viewer_panel_->ConnectViewerNode(panel->GetConnectedViewer());
+
+  Sequence* seq = nullptr;
+
+  if (panel->GetConnectedViewer()) {
+    seq = static_cast<Sequence*>(panel->GetConnectedViewer()->parent());
+  }
+
+  node_panel_->SetGraph(seq);
+}
+
+void MainWindow::TimelineFocusedSlot(bool visible)
+{
+  if (visible) {
+    TimelineFocused(static_cast<TimelinePanel*>(sender()));
+  }
+}
+
 void MainWindow::SetDefaultLayout()
 {
   task_man_panel_->close();
@@ -208,11 +292,11 @@ void MainWindow::SetDefaultLayout()
   curve_panel_->close();
   curve_panel_->setFloating(true);
 
-  resizeDocks({node_panel_, param_panel_, viewer_panel_},
+  resizeDocks({node_panel_, param_panel_, sequence_viewer_panel_},
   {width()/3, width()/3, width()/3},
               Qt::Horizontal);
 
-  resizeDocks({project_panel_, tool_panel_, timeline_panel_, audio_monitor_panel_},
+  resizeDocks({project_panel_, tool_panel_, timeline_panels_.first(), audio_monitor_panel_},
   {width()/4, 1, width(), 1},
               Qt::Horizontal);
 

app/window/mainwindow/mainwindow.h

@@ -33,7 +33,7 @@
 #include "panel/timeline/timeline.h"
 #include "panel/tool/tool.h"
 #include "panel/footageviewer/footageviewer.h"
-#include "panel/viewer/viewer.h"
+#include "panel/sequenceviewer/sequenceviewer.h"
 #include "project/project.h"
 
 /**
@@ -44,6 +44,10 @@ class MainWindow : public QMainWindow {
 public:
   MainWindow(QWidget *parent = nullptr);
 
+  void OpenSequence(Sequence* sequence);
+
+  void CloseSequence(Sequence* sequence);
+
 public slots:
   void ProjectOpen(Project *p);
   void SetFullscreen(bool fullscreen);
@@ -57,20 +61,27 @@ protected:
 private:
   void UpdateTitle();
 
+  TimelinePanel* AppendTimelinePanel();
+
+  void TimelineFocused(TimelinePanel *panel);
+
   QByteArray premaximized_state_;
 
   // Standard panels
   NodePanel* node_panel_;
   ParamPanel* param_panel_;
-  ViewerPanel* viewer_panel_;
+  SequenceViewerPanel* sequence_viewer_panel_;
   FootageViewerPanel* footage_viewer_panel_;
   ProjectPanel* project_panel_;
   ToolPanel* tool_panel_;
-  TimelinePanel* timeline_panel_;
+  QList<TimelinePanel*> timeline_panels_;
   AudioMonitorPanel* audio_monitor_panel_;
   TaskManagerPanel* task_man_panel_;
   CurvePanel* curve_panel_;
 
+private slots:
+  void TimelineFocusedSlot(bool visible);
+
 };
 
 #endif