moved some files around for better organization

app/widget/timebased/CMakeLists.txt

@@ -16,7 +16,11 @@
 
 set(OLIVE_SOURCES
   ${OLIVE_SOURCES}
-  widget/timebased/timebased.h
-  widget/timebased/timebased.cpp
+  widget/timebased/timebasedview.cpp
+  widget/timebased/timebasedview.h
+  widget/timebased/timebasedwidget.cpp
+  widget/timebased/timebasedwidget.h
+  widget/timebased/timescaledobject.cpp
+  widget/timebased/timescaledobject.h
   PARENT_SCOPE
 )

app/widget/timebased/timebasedview.cpp

@@ -0,0 +1,334 @@
+/***
+
+  Olive - Non-Linear Video Editor
+  Copyright (C) 2020 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/>.
+
+***/
+
+#include "timebasedview.h"
+
+#include <QGraphicsRectItem>
+#include <QMouseEvent>
+#include <QScrollBar>
+#include <QTimer>
+
+#include "common/timecodefunctions.h"
+#include "config/config.h"
+
+namespace olive {
+
+const double TimeBasedView::kMaximumScale = 8192;
+
+TimeBasedView::TimeBasedView(QWidget *parent) :
+  HandMovableView(parent),
+  playhead_(0),
+  playhead_scene_left_(-1),
+  playhead_scene_right_(-1),
+  dragging_playhead_(false),
+  snapped_(false),
+  snap_service_(nullptr),
+  y_axis_enabled_(false),
+  y_scale_(1.0)
+{
+  // Sets scene to our scene
+  setScene(&scene_);
+
+  // Set default scale (ensures non-zero scale from beginning)
+  SetScale(1.0);
+
+  // Default to no default drag mode
+  SetDefaultDragMode(NoDrag);
+
+  // Signal to update bounding rect when the scene changes
+  connect(&scene_, &QGraphicsScene::changed, this, &TimeBasedView::UpdateSceneRect);
+
+  // Always enforce maximum scale
+  SetMaximumScale(kMaximumScale);
+
+  // Workaround for Qt drawing issues with the default MinimalViewportUpdate. While this might be
+  // slower (Qt documentation says it may actually be faster in some situations),
+  // MinimalViewportUpdate causes all sorts of graphical crud building up in the scene
+  setViewportUpdateMode(QGraphicsView::FullViewportUpdate);
+}
+
+void TimeBasedView::TimebaseChangedEvent(const rational &)
+{
+  // Timebase influences position/visibility of playhead
+  viewport()->update();
+}
+
+void TimeBasedView::EnableSnap(const QList<rational> &points)
+{
+  snapped_ = true;
+  snap_time_ = points;
+
+  viewport()->update();
+}
+
+void TimeBasedView::DisableSnap()
+{
+  snapped_ = false;
+
+  viewport()->update();
+}
+
+void TimeBasedView::SetSnapService(SnapService *service)
+{
+  snap_service_ = service;
+}
+
+const double &TimeBasedView::GetYScale() const
+{
+  return y_scale_;
+}
+
+void TimeBasedView::VerticalScaleChangedEvent(double)
+{
+}
+
+void TimeBasedView::SetYScale(const double &y_scale)
+{
+  y_scale_ = y_scale;
+
+  if (y_axis_enabled_) {
+    VerticalScaleChangedEvent(y_scale_);
+
+    viewport()->update();
+  }
+}
+
+void TimeBasedView::SetTime(const int64_t time)
+{
+  playhead_ = time;
+
+  // Force redraw for playhead
+  viewport()->update();
+}
+
+void TimeBasedView::drawForeground(QPainter *painter, const QRectF &rect)
+{
+  QGraphicsView::drawForeground(painter, rect);
+
+  if (!timebase().isNull()) {
+    double width = TimeToScene(timebase());
+
+    playhead_scene_left_ = GetPlayheadX();
+    playhead_scene_right_ = playhead_scene_left_ + width;
+
+    QRectF playhead_rect(playhead_scene_left_, rect.top(), width, rect.height());
+
+    // Get playhead highlight color
+    QColor highlight = palette().text().color();
+    highlight.setAlpha(32);
+    painter->setPen(Qt::NoPen);
+    painter->setBrush(highlight);
+    painter->drawRect(playhead_rect);
+
+    // FIXME: Hardcoded...
+    painter->setPen(PLAYHEAD_COLOR);
+    painter->setBrush(Qt::NoBrush);
+    painter->drawLine(QLineF(playhead_rect.topLeft(), playhead_rect.bottomLeft()));
+  }
+
+  if (snapped_) {
+    painter->setPen(palette().text().color());
+
+    foreach (const rational& r, snap_time_) {
+      double x = TimeToScene(r);
+
+      painter->drawLine(x, rect.top(), x, rect.height());
+    }
+  }
+}
+
+rational TimeBasedView::GetPlayheadTime() const
+{
+  return Timecode::timestamp_to_time(playhead_, timebase());
+}
+
+bool TimeBasedView::PlayheadPress(QMouseEvent *event)
+{
+  QPointF scene_pos = mapToScene(event->pos());
+
+  dragging_playhead_ = (event->button() == Qt::LeftButton
+                        && scene_pos.x() >= playhead_scene_left_
+                        && scene_pos.x() < playhead_scene_right_);
+
+  return dragging_playhead_;
+}
+
+bool TimeBasedView::PlayheadMove(QMouseEvent *event)
+{
+  if (!dragging_playhead_) {
+    return false;
+  }
+
+  QPointF scene_pos = mapToScene(event->pos());
+  rational mouse_time = SceneToTime(scene_pos.x());
+
+  int64_t target_ts = qMax(static_cast<int64_t>(0), Timecode::time_to_timestamp(mouse_time, timebase()));
+
+  if (Core::instance()->snapping() && snap_service_) {
+    rational target_time = Timecode::timestamp_to_time(target_ts, timebase());
+    rational movement;
+
+    snap_service_->SnapPoint({target_time}, &movement, SnapService::kSnapAll & ~SnapService::kSnapToPlayhead);
+
+    if (!movement.isNull()) {
+      target_ts = Timecode::time_to_timestamp(target_time + movement, timebase());
+    }
+  }
+
+  SetTime(target_ts);
+  emit TimeChanged(target_ts);
+
+  return true;
+}
+
+bool TimeBasedView::PlayheadRelease(QMouseEvent*)
+{
+  if (dragging_playhead_) {
+    dragging_playhead_ = false;
+
+    if (snap_service_) {
+      snap_service_->HideSnaps();
+    }
+
+    return true;
+  }
+
+  return false;
+}
+
+qreal TimeBasedView::GetPlayheadX()
+{
+  return TimeToScene(Timecode::timestamp_to_time(playhead_, timebase()));
+}
+
+void TimeBasedView::SetEndTime(const rational &length)
+{
+  end_time_ = length;
+
+  UpdateSceneRect();
+}
+
+void TimeBasedView::UpdateSceneRect()
+{
+  QRectF bounding_rect = scene_.itemsBoundingRect();
+
+  // There's no need for a timeline to ever go below 0 on the X scale
+  bounding_rect.setLeft(0);
+
+  // Ensure the scene is always the full length of the timeline with a gap at the end to work with
+  bounding_rect.setRight(TimeToScene(end_time_) + width());
+
+  // Any further rect processing from derivatives can be done here
+  SceneRectUpdateEvent(bounding_rect);
+
+  // If the scene is already this rect, do nothing
+  if (scene_.sceneRect() != bounding_rect) {
+    scene_.setSceneRect(bounding_rect);
+  }
+}
+
+void TimeBasedView::resizeEvent(QResizeEvent *event)
+{
+  QGraphicsView::resizeEvent(event);
+
+  UpdateSceneRect();
+}
+
+void TimeBasedView::ScaleChangedEvent(const double &scale)
+{
+  TimeScaledObject::ScaleChangedEvent(scale);
+
+  // Update scene rect
+  UpdateSceneRect();
+
+  // Force redraw for playhead if the above function didn't do it
+  viewport()->update();
+}
+
+bool TimeBasedView::HandleZoomFromScroll(QWheelEvent *event)
+{
+  if (WheelEventIsAZoomEvent(event)) {
+    // If CTRL is held (or a preference is set to swap CTRL behavior), we zoom instead of scrolling
+    if (!event->angleDelta().isNull()) {
+      bool only_vertical = false;
+      bool only_horizontal = false;
+
+      // Ctrl+Shift limits to only one axis
+      // Alt switches between horizontal only (alt held) or vertical only (alt not held)
+      if (y_axis_enabled_) {
+        if (event->modifiers() & Qt::ShiftModifier) {
+          if (event->modifiers() & Qt::AltModifier) {
+            only_horizontal = true;
+          } else {
+            only_vertical = true;
+          }
+        }
+      } else {
+        only_horizontal = true;
+      }
+
+      double scale_multiplier;
+
+      if (event->angleDelta().x() + event->angleDelta().y() > 0) {
+        scale_multiplier = 1.1;
+      } else {
+        scale_multiplier = 0.9;
+      }
+
+      QPointF cursor_pos;
+#if QT_VERSION >= QT_VERSION_CHECK(5, 14, 0)
+      cursor_pos = event->position();
+#else
+      cursor_pos = event->posF();
+#endif
+
+      if (!only_vertical) {
+        double new_x_scale = GetScale() * scale_multiplier;
+
+        int new_x_scroll = qRound(horizontalScrollBar()->value() / GetScale() * new_x_scale + (cursor_pos.x() - cursor_pos.x() / new_x_scale * GetScale()));
+
+        emit ScaleChanged(new_x_scale);
+
+        horizontalScrollBar()->setValue(new_x_scroll);
+      }
+
+      if (!only_horizontal) {
+        double new_y_scale = GetYScale() * scale_multiplier;
+
+        int new_y_scroll = qRound(verticalScrollBar()->value() / GetYScale() * new_y_scale + (cursor_pos.y() - cursor_pos.y() / new_y_scale * GetYScale()));
+
+        SetYScale(new_y_scale);
+
+        verticalScrollBar()->setValue(new_y_scroll);
+      }
+    }
+
+    return true;
+  }
+
+  return false;
+}
+
+bool TimeBasedView::WheelEventIsAZoomEvent(QWheelEvent *event)
+{
+  return (static_cast<bool>(event->modifiers() & Qt::ControlModifier) == !Config::Current()["ScrollZooms"].toBool());
+}
+
+}

app/widget/timebased/timebasedview.h

@@ -0,0 +1,129 @@
+/***
+
+  Olive - Non-Linear Video Editor
+  Copyright (C) 2020 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/>.
+
+***/
+
+#ifndef TIMELINEVIEWBASE_H
+#define TIMELINEVIEWBASE_H
+
+#include <QGraphicsView>
+
+#include "core.h"
+#include "timescaledobject.h"
+#include "widget/handmovableview/handmovableview.h"
+#include "widget/snapservice/snapservice.h"
+
+namespace olive {
+
+class TimeBasedView : public HandMovableView, public TimeScaledObject
+{
+  Q_OBJECT
+public:
+  TimeBasedView(QWidget* parent = nullptr);
+
+  static const double kMaximumScale;
+
+  void EnableSnap(const QList<rational>& points);
+  void DisableSnap();
+  bool IsSnapped() const
+  {
+    return snapped_;
+  }
+
+  void SetSnapService(SnapService* service);
+
+  const double& GetYScale() const;
+  void SetYScale(const double& y_scale);
+
+public slots:
+  void SetTime(const int64_t time);
+
+  void SetEndTime(const rational& length);
+
+signals:
+  void TimeChanged(const int64_t& time);
+
+  void ScaleChanged(double scale);
+
+protected:
+  virtual void drawForeground(QPainter *painter, const QRectF &rect) override;
+
+  virtual void resizeEvent(QResizeEvent *event) override;
+
+  virtual void ScaleChangedEvent(const double& scale) override;
+
+  virtual void SceneRectUpdateEvent(QRectF&){}
+
+  virtual void VerticalScaleChangedEvent(double scale);
+
+  bool HandleZoomFromScroll(QWheelEvent* event);
+
+  bool WheelEventIsAZoomEvent(QWheelEvent* event);
+
+  rational GetPlayheadTime() const;
+
+  bool PlayheadPress(QMouseEvent* event);
+  bool PlayheadMove(QMouseEvent* event);
+  bool PlayheadRelease(QMouseEvent* event);
+
+  virtual void TimebaseChangedEvent(const rational &) override;
+
+  bool IsYAxisEnabled() const
+  {
+    return y_axis_enabled_;
+  }
+
+  void SetYAxisEnabled(bool e)
+  {
+    y_axis_enabled_ = e;
+  }
+
+private:
+  qreal GetPlayheadX();
+
+  int64_t playhead_;
+
+  double playhead_scene_left_;
+  double playhead_scene_right_;
+
+  bool dragging_playhead_;
+
+  QGraphicsScene scene_;
+
+  bool snapped_;
+  QList<rational> snap_time_;
+
+  rational end_time_;
+
+  SnapService* snap_service_;
+
+  bool y_axis_enabled_;
+
+  double y_scale_;
+
+private slots:
+  /**
+   * @brief Slot called whenever the view resizes or the scene contents change to enforce minimum scene sizes
+   */
+  void UpdateSceneRect();
+
+};
+
+}
+
+#endif // TIMELINEVIEWBASE_H

app/widget/timebased/timebasedwidget.cpp

@@ -18,7 +18,7 @@
 
 ***/
 
-#include "timebased.h"
+#include "timebasedwidget.h"
 
 #include <QInputDialog>
 #include <QUndoCommand>
@@ -132,7 +132,7 @@ void TimeBasedWidget::UpdateMaximumScroll()
     scrollbar_->setMaximum(qMax(0, qCeil(TimeToScene(length)) - width()));
   }
 
-  foreach (TimelineViewBase* base, timeline_views_) {
+  foreach (TimeBasedView* base, timeline_views_) {
     base->SetEndTime(length);
   }
 }
@@ -238,7 +238,7 @@ TimelinePoints *TimeBasedWidget::GetConnectedTimelinePoints() const
   return points_;
 }
 
-void TimeBasedWidget::ConnectTimelineView(TimelineViewBase *base)
+void TimeBasedWidget::ConnectTimelineView(TimeBasedView *base)
 {
   timeline_views_.append(base);
 }

app/widget/timebased/timebasedwidget.h

@@ -26,7 +26,7 @@
 #include "node/output/viewer/viewer.h"
 #include "timeline/timelinecommon.h"
 #include "widget/resizablescrollbar/resizabletimelinescrollbar.h"
-#include "widget/timelinewidget/timelinescaledobject.h"
+#include "widget/timebased/timescaledobject.h"
 #include "widget/timelinewidget/view/timelineview.h"
 #include "widget/timeruler/timeruler.h"
 
@@ -121,7 +121,7 @@ protected:
 
   TimelinePoints* GetConnectedTimelinePoints() const;
 
-  void ConnectTimelineView(TimelineViewBase* base);
+  void ConnectTimelineView(TimeBasedView* base);
 
   void PassWheelEventsToScrollBar(QObject* object);
 
@@ -194,7 +194,7 @@ private:
 
   TimelinePoints* points_;
 
-  QList<TimelineViewBase*> timeline_views_;
+  QList<TimeBasedView*> timeline_views_;
 
   bool toggle_show_all_;
 

app/widget/timebased/timescaledobject.cpp

@@ -0,0 +1,137 @@
+/***
+
+  Olive - Non-Linear Video Editor
+  Copyright (C) 2020 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/>.
+
+***/
+
+#include "timescaledobject.h"
+
+#include <cfloat>
+#include <QtMath>
+
+#include "common/clamp.h"
+
+namespace olive {
+
+const int TimeScaledObject::kCalculateDimensionsPadding = 10;
+
+TimeScaledObject::TimeScaledObject() :
+  scale_(1.0),
+  min_scale_(0),
+  max_scale_(DBL_MAX)
+{
+
+}
+
+void TimeScaledObject::SetTimebase(const rational &timebase)
+{
+  timebase_ = timebase;
+  timebase_dbl_ = timebase_.toDouble();
+
+  TimebaseChangedEvent(timebase);
+}
+
+const rational &TimeScaledObject::timebase() const
+{
+  return timebase_;
+}
+
+const double &TimeScaledObject::timebase_dbl() const
+{
+  return timebase_dbl_;
+}
+
+rational TimeScaledObject::SceneToTime(const double &x, const double &x_scale, const rational &timebase, bool round)
+{
+  double unscaled_time = x / x_scale / timebase.toDouble();
+
+  // Adjust screen point by scale and timebase
+  qint64 rounded_x_mvmt;
+
+  if (round) {
+    rounded_x_mvmt = qRound64(unscaled_time);
+  } else {
+    rounded_x_mvmt = qFloor(unscaled_time);
+  }
+
+  // Return a time in the timebase
+  return rational(rounded_x_mvmt * timebase.numerator(), timebase.denominator());
+}
+
+double TimeScaledObject::TimeToScene(const rational &time)
+{
+  return time.toDouble() * scale_;
+}
+
+rational TimeScaledObject::SceneToTime(const double &x, bool round)
+{
+  return SceneToTime(x, scale_, timebase_, round);
+}
+
+void TimeScaledObject::SetMaximumScale(const double &max)
+{
+  max_scale_ = max;
+
+  if (GetScale() > max_scale_) {
+    SetScale(max_scale_);
+  }
+}
+
+void TimeScaledObject::SetMinimumScale(const double &min)
+{
+  min_scale_ = min;
+
+  if (GetScale() < min_scale_) {
+    SetScale(min_scale_);
+  }
+}
+
+const double& TimeScaledObject::GetScale() const
+{
+  return scale_;
+}
+
+void TimeScaledObject::SetScale(const double& scale)
+{
+  Q_ASSERT(scale > 0);
+
+  scale_ = clamp(scale, min_scale_, max_scale_);
+
+  ScaleChangedEvent(scale_);
+}
+
+void TimeScaledObject::SetScaleFromDimensions(double viewport_width, double content_width)
+{
+  SetScale(CalculateScaleFromDimensions(viewport_width, content_width));
+}
+
+double TimeScaledObject::CalculateScaleFromDimensions(double viewport_sz, double content_sz)
+{
+  return static_cast<double>(viewport_sz / kCalculateDimensionsPadding * (kCalculateDimensionsPadding-1)) / static_cast<double>(content_sz);
+}
+
+double TimeScaledObject::CalculatePaddingFromDimensionScale(double viewport_sz)
+{
+  return (viewport_sz / (kCalculateDimensionsPadding * 2));
+}
+
+TimelineScaledWidget::TimelineScaledWidget(QWidget *parent) :
+  QWidget(parent)
+{
+}
+
+}

app/widget/timebased/timescaledobject.h

@@ -0,0 +1,90 @@
+/***
+
+  Olive - Non-Linear Video Editor
+  Copyright (C) 2020 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/>.
+
+***/
+
+#ifndef TIMELINESCALEDOBJECT_H
+#define TIMELINESCALEDOBJECT_H
+
+#include <QWidget>
+
+#include "common/rational.h"
+
+namespace olive {
+
+/**
+ * @brief Provides base functionality for any object that uses time and scale
+ */
+class TimeScaledObject
+{
+public:
+  TimeScaledObject();
+  virtual ~TimeScaledObject() = default;
+
+  void SetTimebase(const rational &timebase);
+
+  const rational& timebase() const;
+  const double& timebase_dbl() const;
+
+  static rational SceneToTime(const double &x, const double& x_scale, const rational& timebase, bool round = false);
+
+  const double& GetScale() const;
+
+  void SetScale(const double& scale);
+
+  void SetScaleFromDimensions(double viewport_width, double content_width);
+  static double CalculateScaleFromDimensions(double viewport_sz, double content_sz);
+  static double CalculatePaddingFromDimensionScale(double viewport_sz);
+
+  double TimeToScene(const rational& time);
+  rational SceneToTime(const double &x, bool round = false);
+
+protected:
+  virtual void TimebaseChangedEvent(const rational&){}
+
+  virtual void ScaleChangedEvent(const double&){}
+
+  void SetMaximumScale(const double& max);
+
+  void SetMinimumScale(const double& min);
+
+private:
+  rational timebase_;
+
+  double timebase_dbl_;
+
+  double scale_;
+
+  double min_scale_;
+
+  double max_scale_;
+
+  static const int kCalculateDimensionsPadding;
+
+};
+
+class TimelineScaledWidget : public QWidget, public TimeScaledObject
+{
+  Q_OBJECT
+public:
+  TimelineScaledWidget(QWidget* parent = nullptr);
+};
+
+}
+
+#endif // TIMELINESCALEDOBJECT_H