timeline: heavily optimized and improved nearly all timeline optimizations

Features a lot of timeline-related cache optimizations as well as general optimizations and improvements in timeline behavior. Should improve usability significantly.
2020-06-01 04:42:59 +10:00
parent 93f8b4f79c
commit c2e47a296c
35 changed files with 1496 additions and 939 deletions
@@ -23,8 +23,8 @@

 #include <QWidget>

-#include "common/timelinecommon.h"
 #include "node/output/viewer/viewer.h"
+#include "timeline/timelinecommon.h"
 #include "widget/resizablescrollbar/resizablescrollbar.h"
 #include "widget/timelinewidget/timelinescaledobject.h"
 #include "widget/timelinewidget/view/timelineview.h"
@@ -473,7 +473,7 @@ void TimelineWidget::DeleteSelectedInternal(const QList<Block *> &blocks,
  foreach (Block* b, blocks) {
    TrackOutput* original_track = TrackOutput::TrackFromBlock(b);

-    if (transition_aware && b->type() == Block::kTransition) {
+    /*if (transition_aware && b->type() == Block::kTransition) {
      // Deleting transitions restores their in/out offsets to their attached blocks
      TransitionBlock* transition = static_cast<TransitionBlock*>(b);

@@ -494,20 +494,39 @@ void TimelineWidget::DeleteSelectedInternal(const QList<Block *> &blocks,
                               transition->connected_out_block()->length() + transition->out_offset(),
                               command);
      }
-    } else {
-      // Make new gap and replace old Block with it for now
-      GapBlock* gap = new GapBlock();
-      gap->set_length_and_media_out(b->length());
+    } else */

-      new NodeAddCommand(static_cast<NodeGraph*>(b->parent()),
-                         gap,
-                         command);

-      new TrackReplaceBlockCommand(original_track,
-                                   b,
-                                   gap,
-                                   command);
+    /*
+    if (b->next()) {
+
+      new TrackRippleRemoveBlockCommand(original_track, b, command);
+
+      if (b->previous() && b->previous()->type() == Block::kGap
+          && b->next() && b->next()->type() == Block::kGap) {
+
+        // Both previous AND next are blocks. We'll want to merge them together.
+        new TrackRippleRemoveBlockCommand(original_track, b->next(), command);
+
+      } else {
+
+        // Make new gap and replace old Block with it for now
+        GapBlock* gap = new GapBlock();
+        gap->set_length_and_media_out(b->length());
+
+        new NodeAddCommand(static_cast<NodeGraph*>(b->parent()),
+                           gap,
+                           command);
+
+        new TrackReplaceBlockCommand(original_track,
+                                     b,
+                                     gap,
+                                     command);
+      }
    }
+    */
+
+    new TrackReplaceBlockWithGapCommand(original_track, b, command);

    if (remove_from_graph) {
      new BlockUnlinkAllCommand(b, command);
@@ -543,12 +562,14 @@ void TimelineWidget::DeleteSelected(bool ripple)
  // Replace blocks with gaps (effectively deleting them)
  DeleteSelectedInternal(blocks_to_delete, true, true, command);

+  /*
  // Clean each track
  foreach (const TrackReference& track, tracks_affected) {
    new TrackCleanGapsCommand(GetConnectedNode()->track_list(track.type()),
                              track.index(),
                              command);
  }
+  */

  // Insert ripple command now that it's all cleaned up gaps
  if (ripple) {
@@ -1225,17 +1246,17 @@ void TimelineWidget::SetBlockLinksSelected(Block* block, bool selected)
  }
 }

-QVector<TimelineWidget::EditToInfo> TimelineWidget::GetEditToInfo(const rational& playhead_time,
+QVector<Timeline::EditToInfo> TimelineWidget::GetEditToInfo(const rational& playhead_time,
                                                                  Timeline::MovementMode mode)
 {
  // Get list of unlocked tracks
  QVector<TrackOutput*> tracks = GetConnectedNode()->GetUnlockedTracks();

  // Create list to cache nearest times and the blocks at this point
-  QVector<EditToInfo> info_list(tracks.size());
+  QVector<Timeline::EditToInfo> info_list(tracks.size());

  for (int i=0;i<tracks.size();i++) {
-    EditToInfo info;
+    Timeline::EditToInfo info;

    TrackOutput* track = tracks.at(i);
    info.track = track;
@@ -1275,12 +1296,12 @@ void TimelineWidget::RippleTo(Timeline::MovementMode mode)
 {
  rational playhead_time = GetTime();

-  QVector<EditToInfo> tracks = GetEditToInfo(playhead_time, mode);
+  QVector<Timeline::EditToInfo> tracks = GetEditToInfo(playhead_time, mode);

  // Find each track's nearest point and determine the overall timeline's nearest point
  rational closest_point_to_playhead = (mode == Timeline::kTrimIn) ? rational() : RATIONAL_MAX;

-  foreach (const EditToInfo& info, tracks) {
+  foreach (const Timeline::EditToInfo& info, tracks) {
    if (info.nearest_block) {
      if (mode == Timeline::kTrimIn) {
        closest_point_to_playhead = qMax(info.nearest_time, closest_point_to_playhead);
@@ -1306,7 +1327,7 @@ void TimelineWidget::RippleTo(Timeline::MovementMode mode)

  QUndoCommand* command = new QUndoCommand();

-  foreach (const EditToInfo& info, tracks) {
+  foreach (const Timeline::EditToInfo& info, tracks) {
    TrackOutput* track = info.track;

    // Simply remove this region
@@ -1335,63 +1356,32 @@ void TimelineWidget::EditTo(Timeline::MovementMode mode)
  const rational playhead_time = GetTime();

  // Get list of unlocked tracks
-  QVector<EditToInfo> tracks = GetEditToInfo(playhead_time, mode);
+  QVector<Timeline::EditToInfo> tracks = GetEditToInfo(playhead_time, mode);
+
+  if (tracks.isEmpty()) {
+    return;
+  }

  QUndoCommand* command = new QUndoCommand();

-  foreach (const EditToInfo& info, tracks) {
-    TrackOutput* track = info.track;
+  foreach (const Timeline::EditToInfo& info, tracks) {
+    if (info.nearest_block
+        && info.nearest_block->type() != Block::kGap
+        && info.nearest_time != playhead_time) {
+      rational new_len;

-    Block* block_here = info.nearest_block;
-
-    // Check if this track's nearest time was the playhead or if there's no block here, in which
-    // case this is a no-op
-    if (!block_here || info.nearest_time == playhead_time) {
-      continue;
-    }
-
-    GapBlock* gap = nullptr;
-
-    // Resize the block at this time
-    if (mode == Timeline::kTrimIn) {
-      rational trim_length = playhead_time - block_here->in();
-
-      gap = new GapBlock();
-      gap->set_length_and_media_out(trim_length);
-      new NodeAddCommand(static_cast<NodeGraph*>(track->parent()), gap, command);
-
-      new BlockResizeWithMediaInCommand(block_here,
-                                        block_here->length() - trim_length,
-                                        command);
-
-      if (block_here->previous()) {
-        new TrackInsertBlockAfterCommand(track, gap, block_here->previous(), command);
+      if (mode == Timeline::kTrimIn) {
+        new_len = playhead_time - info.nearest_time;
      } else {
-        new TrackPrependBlockCommand(track, gap, command);
+        new_len = info.nearest_time - playhead_time;
      }
-    } else {
-      rational trim_length = block_here->out() - playhead_time;
+      new_len = info.nearest_block->length() - new_len;

-      new BlockResizeCommand(block_here,
-                             block_here->length() - trim_length,
-                             command);
-
-      // We only need to add a gap if there's actually a block after this one, otherwise it
-      // doesn't matter
-      if (block_here->next()) {
-        gap = new GapBlock();
-        gap->set_length_and_media_out(trim_length);
-        new NodeAddCommand(static_cast<NodeGraph*>(track->parent()), gap, command);
-
-        new TrackInsertBlockAfterCommand(track, gap, block_here, command);
-      }
-    }
-
-    // If a gap was added, clean the gaps on this track too
-    if (gap) {
-      new TrackCleanGapsCommand(GetConnectedNode()->track_list(track->track_type()),
-                                track->Index(),
-                                command);
+      new BlockTrimCommand(info.track,
+                           info.nearest_block,
+                           new_len,
+                           mode,
+                           command);
    }
  }

@@ -26,8 +26,9 @@
 #include <QWidget>

 #include "core.h"
-#include "timelineandtrackview.h"
 #include "node/output/viewer/viewer.h"
+#include "timeline/timelinecommon.h"
+#include "timelineandtrackview.h"
 #include "widget/nodecopypaste/nodecopypaste.h"
 #include "widget/slider/timeslider.h"
 #include "widget/timebased/timebased.h"
@@ -179,7 +180,7 @@ private:
     * Validation is the process of ensuring that whatever movements the user is making are "valid" and "legal". This
     * function's validation ensures that no Ghost's in point ends up in a negative timecode.
     */
-    rational ValidateFrameMovement(rational movement, const QVector<TimelineViewGhostItem*> ghosts);
+    rational ValidateTimeMovement(rational movement, const QVector<TimelineViewGhostItem*> ghosts);

    /**
     * @brief Validates Ghosts that are moving vertically (track-based)
@@ -226,15 +227,11 @@ private:
    virtual void HoverMove(TimelineViewMouseEvent *event) override;

  protected:
-    void SetMovementAllowed(bool allowed);
-    void SetTrackMovementAllowed(bool allowed);
-    void SetTrimmingAllowed(bool allowed);
-    virtual void MouseReleaseInternal(TimelineViewMouseEvent *event);
-    virtual rational FrameValidateInternal(rational time_movement, const QVector<TimelineViewGhostItem *> &ghosts);
+    virtual void FinishDrag(TimelineViewMouseEvent *event);

-    virtual void InitiateGhosts(TimelineViewBlockItem* clicked_item,
-                                Timeline::MovementMode trim_mode,
-                                bool allow_gap_trimming);
+    virtual void InitiateDrag(TimelineViewBlockItem* clicked_item,
+                              Timeline::MovementMode trim_mode,
+                              bool allow_gap_trimming);

    TimelineViewGhostItem* AddGhostFromBlock(Block *block, const TrackReference& track, Timeline::MovementMode mode);

@@ -258,24 +255,51 @@ private:

    virtual void ProcessDrag(const TimelineCoordinate &mouse_pos);

+    const Timeline::MovementMode& drag_movement_mode() const
+    {
+      return drag_movement_mode_;
+    }
+
+    void SetMovementAllowed(bool e)
+    {
+      movement_allowed_ = e;
+    }
+
+    void SetTrimmingAllowed(bool e)
+    {
+      trimming_allowed_ = e;
+    }
+
+    void SetTrackMovementAllowed(bool e)
+    {
+      track_movement_allowed_ = e;
+    }
+
+    void SetTrimOverwriteAllowed(bool e)
+    {
+      trim_overwrite_allowed_ = e;
+    }
+
  private:
    Timeline::MovementMode IsCursorInTrimHandle(TimelineViewBlockItem* block, qreal cursor_x);

-    void InitiateDrag(TimelineViewMouseEvent *mouse_pos);
-
    void AddGhostInternal(TimelineViewGhostItem* ghost, Timeline::MovementMode mode);

    bool IsClipTrimmable(TimelineViewBlockItem* clip,
                         const QList<TimelineViewBlockItem*>& items,
                         const Timeline::MovementMode& mode);

-    TrackReference track_start_;
    bool movement_allowed_;
    bool trimming_allowed_;
    bool track_movement_allowed_;
+    bool trim_overwrite_allowed_;
    bool rubberband_selecting_;

    Timeline::TrackType drag_track_type_;
+    Timeline::MovementMode drag_movement_mode_;
+
+    TimelineViewBlockItem* clicked_item_;
+
  };

  class ImportTool : public Tool
@@ -332,12 +356,11 @@ private:
  public:
    RippleTool(TimelineWidget* parent);
  protected:
-    virtual void MouseReleaseInternal(TimelineViewMouseEvent *event) override;
-    virtual rational FrameValidateInternal(rational time_movement, const QVector<TimelineViewGhostItem*>& ghosts) override;
+    virtual void FinishDrag(TimelineViewMouseEvent *event) override;

-    virtual void InitiateGhosts(TimelineViewBlockItem* clicked_item,
-                                Timeline::MovementMode trim_mode,
-                                bool allow_gap_trimming) override;
+    virtual void InitiateDrag(TimelineViewBlockItem* clicked_item,
+                              Timeline::MovementMode trim_mode,
+                              bool allow_gap_trimming) override;
  };

  class RollingTool : public PointerTool
@@ -346,12 +369,11 @@ private:
    RollingTool(TimelineWidget* parent);

  protected:
-    virtual void MouseReleaseInternal(TimelineViewMouseEvent *event) override;
-    virtual rational FrameValidateInternal(rational time_movement, const QVector<TimelineViewGhostItem*>& ghosts) override;
+    virtual void FinishDrag(TimelineViewMouseEvent *event) override;

-    virtual void InitiateGhosts(TimelineViewBlockItem* clicked_item,
-                                Timeline::MovementMode trim_mode,
-                                bool allow_gap_trimming) override;
+    virtual void InitiateDrag(TimelineViewBlockItem* clicked_item,
+                              Timeline::MovementMode trim_mode,
+                              bool allow_gap_trimming) override;
  };

  class SlideTool : public PointerTool
@@ -360,11 +382,11 @@ private:
    SlideTool(TimelineWidget* parent);

  protected:
-    virtual void MouseReleaseInternal(TimelineViewMouseEvent *event) override;
-    virtual rational FrameValidateInternal(rational time_movement, const QVector<TimelineViewGhostItem*>& ghosts) override;
-    virtual void InitiateGhosts(TimelineViewBlockItem* clicked_item,
-                                Timeline::MovementMode trim_mode,
-                                bool allow_gap_trimming) override;
+    virtual void FinishDrag(TimelineViewMouseEvent *event) override;
+    virtual void InitiateDrag(TimelineViewBlockItem* clicked_item,
+                              Timeline::MovementMode trim_mode,
+                              bool allow_gap_trimming) override;
+
  };

  class SlipTool : public PointerTool
@@ -374,7 +396,7 @@ private:

  protected:
    virtual void ProcessDrag(const TimelineCoordinate &mouse_pos) override;
-    virtual void MouseReleaseInternal(TimelineViewMouseEvent *event) override;
+    virtual void FinishDrag(TimelineViewMouseEvent *event) override;
  };

  class ZoomTool : public Tool
@@ -425,13 +447,7 @@ private:

  void SetBlockLinksSelected(Block *block, bool selected);

-  struct EditToInfo {
-    TrackOutput* track;
-    rational nearest_time;
-    Block* nearest_block;
-  };
-
-  QVector<EditToInfo> GetEditToInfo(const rational &playhead_time, Timeline::MovementMode mode);
+  QVector<Timeline::EditToInfo> GetEditToInfo(const rational &playhead_time, Timeline::MovementMode mode);

  void RippleTo(Timeline::MovementMode mode);

@@ -37,7 +37,7 @@ void TimelineWidget::AddTool::MousePress(TimelineViewMouseEvent *event)
  const TrackReference& track = event->GetTrack();
  TrackOutput* t = parent()->GetTrackFromReference(track);

-  if (t && t->IsLocked()) {
+  if (!t || t->IsLocked()) {
    return;
  }

@@ -127,7 +127,7 @@ void TimelineWidget::ImportTool::DragMove(TimelineViewMouseEvent *event)
        SnapPoint(snap_points_, &time_movement);
      }

-      time_movement = ValidateFrameMovement(time_movement, parent()->ghost_items_);
+      time_movement = ValidateTimeMovement(time_movement, parent()->ghost_items_);
      track_movement = ValidateTrackMovement(track_movement, parent()->ghost_items_);

      rational earliest_ghost = RATIONAL_MAX;
@@ -236,11 +236,14 @@ void TimelineWidget::ImportTool::FootageToGhosts(rational ghost_start, const QLi
        footage_duration = Config::Current()["DefaultStillLength"].value<rational>();
      } else {
        // Rescale stream duration to timeline timebase
-        int64_t stream_duration = Timecode::rescale_timestamp_ceil(stream->duration(), stream->timebase(), dest_tb);
-
        // Convert to rational time
-        footage_duration = rational(dest_tb.numerator() * stream_duration,
-                                    dest_tb.denominator());
+        if (footage.footage()->workarea()->enabled()) {
+          footage_duration = footage.footage()->workarea()->range().length();
+          ghost->SetMediaIn(footage.footage()->workarea()->in());
+        } else {
+          int64_t stream_duration = Timecode::rescale_timestamp_ceil(stream->duration(), stream->timebase(), dest_tb);
+          footage_duration = Timecode::timestamp_to_time(stream_duration, dest_tb);
+        }
      }

      ghost->SetIn(ghost_start);
@@ -387,6 +390,7 @@ void TimelineWidget::ImportTool::DropGhosts(bool insert)
      StreamPtr footage_stream = ghost->data(TimelineViewGhostItem::kAttachedFootage).value<StreamPtr>();

      ClipBlock* clip = new ClipBlock();
+      clip->set_media_in(ghost->MediaIn());
      clip->set_length_and_media_out(ghost->Length());
      clip->set_block_name(footage_stream->footage()->name());
      new NodeAddCommand(dst_graph, clip, command);
@@ -41,41 +41,39 @@ TimelineWidget::PointerTool::PointerTool(TimelineWidget *parent) :
  movement_allowed_(true),
  trimming_allowed_(true),
  track_movement_allowed_(true),
+  trim_overwrite_allowed_(false),
  rubberband_selecting_(false)
 {
 }

 void TimelineWidget::PointerTool::MousePress(TimelineViewMouseEvent *event)
 {
-  // Main selection code
+  // Determine if item clicked on is selectable
+  clicked_item_ = GetItemAtScenePos(event->GetCoordinates());

-  TimelineViewBlockItem* item = GetItemAtScenePos(event->GetCoordinates());
-
-  bool selectable_item = (item != nullptr
-      && item->flags() & QGraphicsItem::ItemIsSelectable
-      && !parent()->GetTrackFromReference(item->Track())->IsLocked());
+  bool selectable_item = (clicked_item_
+                          && clicked_item_->flags() & QGraphicsItem::ItemIsSelectable
+                          && !parent()->GetTrackFromReference(clicked_item_->Track())->IsLocked());

  if (selectable_item) {
    // Cache the clip's type for use later
-    drag_track_type_ = item->Track().type();
-  }
+    drag_track_type_ = clicked_item_->Track().type();

-  // If this item is already selected
-  if (selectable_item
-      && item->isSelected()) {
+    // If this item is already selected, no further selection needs to be made
+    if (clicked_item_->isSelected()) {

-    // If shift is held, deselect it
-    if (event->GetModifiers() & Qt::ShiftModifier) {
-      item->setSelected(false);
+      // If shift is held, deselect it
+      if (event->GetModifiers() & Qt::ShiftModifier) {
+        clicked_item_->setSelected(false);

-      // If not holding alt, deselect all links as well
-      if (!(event->GetModifiers() & Qt::AltModifier)) {
-        parent()->SetBlockLinksSelected(item->block(), false);
+        // If not holding alt, deselect all links as well
+        if (!(event->GetModifiers() & Qt::AltModifier)) {
+          parent()->SetBlockLinksSelected(clicked_item_->block(), false);
+        }
      }
-    }

-    // Otherwise do nothing
-    return;
+      return;
+    }
  }

  // If not holding shift, deselect all clips
@@ -85,11 +83,11 @@ void TimelineWidget::PointerTool::MousePress(TimelineViewMouseEvent *event)

  if (selectable_item) {
    // Select this item
-    item->setSelected(true);
+    clicked_item_->setSelected(true);

    // If not holding alt, select all links as well
    if (!(event->GetModifiers() & Qt::AltModifier)) {
-      parent()->SetBlockLinksSelected(item->block(), true);
+      parent()->SetBlockLinksSelected(clicked_item_->block(), true);
    }
  } else if (event->GetButton() == Qt::LeftButton) {
    // Start rubberband drag
@@ -110,7 +108,28 @@ void TimelineWidget::PointerTool::MouseMove(TimelineViewMouseEvent *event)
    // Now that the cursor has moved, we will assume the intention is to drag

    // If we haven't started dragging yet, we'll initiate a drag here
-    InitiateDrag(event);
+    // Record where the drag started in timeline coordinates
+    drag_start_ = event->GetCoordinates();
+
+    // Clear snap points
+    snap_points_.clear();
+
+    // Determine whether we're trimming or moving based on the position of the cursor
+    drag_movement_mode_ = IsCursorInTrimHandle(clicked_item_,
+                                               event->GetSceneX());
+
+    // If we're not in a trim mode, we must be in a move mode (provided the tool allows movement and
+    // the block is not a gap)
+    if (drag_movement_mode_ == Timeline::kNone
+        && movement_allowed_
+        && clicked_item_->block()->type() != Block::kGap) {
+      drag_movement_mode_ = Timeline::kMove;
+    }
+
+    // If we're performing an action, we can initiate ghosts
+    if (drag_movement_mode_ != Timeline::kNone) {
+      InitiateDrag(clicked_item_, drag_movement_mode_, false);
+    }

    // Set dragging to true here so no matter what, the drag isn't re-initiated until it's completed
    dragging_ = true;
@@ -132,11 +151,11 @@ void TimelineWidget::PointerTool::MouseRelease(TimelineViewMouseEvent *event)
    return;
  }

-  if (!parent()->ghost_items_.isEmpty()) {
-    MouseReleaseInternal(event);
-  }
-
  if (dragging_) {
+    if (!parent()->ghost_items_.isEmpty()) {
+      FinishDrag(event);
+    }
+
    parent()->ClearGhosts();
    snap_points_.clear();
  }
@@ -146,18 +165,22 @@ void TimelineWidget::PointerTool::MouseRelease(TimelineViewMouseEvent *event)

 void TimelineWidget::PointerTool::HoverMove(TimelineViewMouseEvent *event)
 {
-  // No dragging, but we still want to process cursors
-  TimelineViewBlockItem* block_at_cursor = GetItemAtScenePos(event->GetCoordinates());
+  if (trimming_allowed_) {
+    // No dragging, but we still want to process cursors
+    TimelineViewBlockItem* block_at_cursor = GetItemAtScenePos(event->GetCoordinates());

-  if (block_at_cursor) {
-    switch (IsCursorInTrimHandle(block_at_cursor, event->GetSceneX())) {
-    case Timeline::kTrimIn:
-      parent()->setCursor(Qt::SizeHorCursor);
-      break;
-    case Timeline::kTrimOut:
-      parent()->setCursor(Qt::SizeHorCursor);
-      break;
-    default:
+    if (block_at_cursor) {
+      switch (IsCursorInTrimHandle(block_at_cursor, event->GetSceneX())) {
+      case Timeline::kTrimIn:
+        parent()->setCursor(Qt::SizeHorCursor);
+        break;
+      case Timeline::kTrimOut:
+        parent()->setCursor(Qt::SizeHorCursor);
+        break;
+      default:
+        parent()->unsetCursor();
+      }
+    } else {
      parent()->unsetCursor();
    }
  } else {
@@ -165,200 +188,123 @@ void TimelineWidget::PointerTool::HoverMove(TimelineViewMouseEvent *event)
  }
 }

-void TimelineWidget::PointerTool::SetMovementAllowed(bool allowed)
+void TimelineWidget::PointerTool::FinishDrag(TimelineViewMouseEvent *event)
 {
-  movement_allowed_ = allowed;
-}
+  QList<TimelineViewGhostItem*> ghosts_moving;
+  QList<Block*> blocks_moving;
+  QList<TimelineViewGhostItem*> ghosts_trimming;
+  QList<Block*> blocks_trimming;

-void TimelineWidget::PointerTool::SetTrackMovementAllowed(bool allowed)
-{
-  track_movement_allowed_ = allowed;
-}
+  foreach (TimelineViewGhostItem* ghost, parent()->ghost_items_) {
+    if (!ghost->HasBeenAdjusted()) {
+      continue;
+    }

-void TimelineWidget::PointerTool::SetTrimmingAllowed(bool allowed)
-{
-  trimming_allowed_ = allowed;
-}
+    Block* b = Node::ValueToPtr<Block>(ghost->data(TimelineViewGhostItem::kAttachedBlock));
+
+    if (ghost->mode() == Timeline::kMove) {
+      ghosts_moving.append(ghost);
+      blocks_moving.append(b);
+    } else if (Timeline::IsATrimMode(ghost->mode())) {
+      ghosts_trimming.append(ghost);
+      blocks_trimming.append(b);
+    }
+  }
+
+  if (blocks_moving.isEmpty() && blocks_trimming.isEmpty()) {
+    // Likely means no block was adjusted, so we can skip the rest of the processing
+    return;
+  }
+
+  // See if we're duplicated because ALT is held (only moved blocks can duplicate)
+  bool duplicate_clips = (!blocks_moving.isEmpty() && event->GetModifiers() & Qt::AltModifier);
+  bool inserting = (!blocks_moving.isEmpty() && event->GetModifiers() & Qt::ControlModifier);

-void TimelineWidget::PointerTool::MouseReleaseInternal(TimelineViewMouseEvent *event)
-{
  QUndoCommand* command = new QUndoCommand();

-  QList<Block*> blocks_to_temp_remove;
-  QList<TrackReference> tracks_affected;
-  QList<TimelineViewGhostItem*> ignore_ghosts;
+  for (int i=0;i<ghosts_trimming.size();i++) {
+    TimelineViewGhostItem* ghost = ghosts_trimming.at(i);

-  bool duplicate_clips = (event->GetModifiers() & Qt::AltModifier);
-
-  // Since all the ghosts will be leaving their old position in some way, we replace all of them with gaps here so the
-  // entire timeline isn't disrupted in the process
-  for (int i=0;i<parent()->ghost_items_.size();i++) {
-    TimelineViewGhostItem* ghost = parent()->ghost_items_.at(i);
-
-    // If the ghost has not been adjusted nothing needs to be done
-    if (!ghost->HasBeenAdjusted()) {
-      ignore_ghosts.append(ghost);
-      continue;
-    }
-
-    Block* b = Node::ValueToPtr<Block>(ghost->data(TimelineViewGhostItem::kAttachedBlock));
-
-    if (!duplicate_clips || ghost->mode() != Timeline::kMove || b->type() == Block::kTransition) {
-      // If we're duplicating (user is holding ALT), no need to remove the original clip. However if the ghost was
-      // trimmed, it can't be duplicated.
-      blocks_to_temp_remove.append(b);
-    }
-
-    if (!tracks_affected.contains(ghost->Track())) {
-      tracks_affected.append(ghost->Track());
-    }
-
-    if (!tracks_affected.contains(ghost->GetAdjustedTrack())) {
-      tracks_affected.append(ghost->GetAdjustedTrack());
-    }
-  }
-
-  bool inserting = (event->GetModifiers() & Qt::ControlModifier);
-
-  // If there are any blocks to remove, remove them
-  parent()->DeleteSelectedInternal(blocks_to_temp_remove, false, false, command);
-
-  if (inserting) {
-    // Make room to insert clips to
-    InsertGapsAtGhostDestination(parent()->ghost_items_, command);
-  }
-
-  // Now we place the clips back in the timeline where the user moved them. It's legal for them to overwrite parts or
-  // all of the gaps we inserted earlier
-  for (int i=0;i<parent()->ghost_items_.size();i++) {
-    TimelineViewGhostItem* ghost = parent()->ghost_items_.at(i);
-
-    // If the ghost has not been adjusted nothing needs to be done
-    if (ignore_ghosts.contains(ghost)) {
-      continue;
-    }
-
-    const TrackReference& track_ref = ghost->GetAdjustedTrack();
-    //TrackOutput* track = parent()->GetTrackFromReference(track_ref);
-
-    Block* b = Node::ValueToPtr<Block>(ghost->data(TimelineViewGhostItem::kAttachedBlock));
-
-    // Normal blocks work in conjunction with the gap made above
-    if (Timeline::IsATrimMode(ghost->mode())) {
-      // If we were trimming, we'll need to change the length
-
-      // If we were trimming the in point, we'll need to adjust the media in too
-      if (ghost->mode() == Timeline::kTrimIn) {
-        new BlockResizeWithMediaInCommand(b, ghost->AdjustedLength(), command);
-      } else {
-        new BlockResizeCommand(b, ghost->AdjustedLength(), command);
-      }
-    } else if (duplicate_clips && ghost->mode() == Timeline::kMove && b->type() != Block::kTransition) {
-      // Duplicate rather than move
-      Node* copy = b->copy();
-
-      new NodeAddCommand(static_cast<NodeGraph*>(b->parent()),
-                         copy,
+    new BlockTrimCommand(parent()->GetTrackFromReference(ghost->GetAdjustedTrack()),
+                         blocks_trimming.at(i),
+                         ghost->AdjustedLength(),
+                         ghost->mode(),
                         command);
+  }

-      new NodeCopyInputsCommand(b, copy, true, command);
-
-      // Place the copy instead of the original block
-      b = static_cast<Block*>(copy);
-    } else if (b->type() == Block::kTransition) {
-      // If the block is a dual transition and we're moving it, the mid point should be moved
-      TransitionBlock* transition = static_cast<TransitionBlock*>(b);
-
-      if (transition->connected_in_block() && transition->connected_out_block()) {
-        new BlockSetMediaInCommand(transition,
-                                   transition->media_in() + ghost->InAdjustment(),
-                                   command);
-      }
+  if (!blocks_moving.isEmpty()) {
+    // If we're not duplicating, "remove" the clips and replace them with gaps
+    if (!duplicate_clips) {
+      parent()->DeleteSelectedInternal(blocks_moving, false, false, command);
    }

-    if (b->type() == Block::kTransition && ghost->AdjustedLength() == 0) {
-      // Remove transitions that have been reduced to zero length
-      new NodeRemoveCommand(static_cast<NodeGraph*>(b->parent()),
-                            {b},
-                            command);
-    } else {
-      // Normal block placement
+    if (inserting) {
+      // If we're inserting, ripple everything at the destination with gaps
+      InsertGapsAtGhostDestination(parent()->ghost_items_, command);
+    }
+
+    /*
+    QList<TrackReference> tracks_affected;
+    */
+
+    // Now we can re-add each clip
+    for (int i=0;i<ghosts_moving.size();i++) {
+      TimelineViewGhostItem* ghost = ghosts_moving.at(i);
+      Block* block = blocks_moving.at(i);
+
+      /*
+      if (!tracks_affected.contains(ghost->GetAdjustedTrack())) {
+        tracks_affected.append(ghost->GetAdjustedTrack());
+      }
+      */
+
+      if (duplicate_clips) {
+        // Duplicate rather than move
+        Node* copy = block->copy();
+
+        new NodeAddCommand(static_cast<NodeGraph*>(block->parent()),
+                           copy,
+                           command);
+
+        new NodeCopyInputsCommand(block, copy, true, command);
+
+        // Place the copy instead of the original block
+        block = static_cast<Block*>(copy);
+        /*
+      } else if (!tracks_affected.contains(ghost->Track())) {
+        // Block moved from its original position. Mark its track as affected.
+        tracks_affected.append(ghost->Track());
+        */
+      }
+
+      const TrackReference& track_ref = ghost->GetAdjustedTrack();
      new TrackPlaceBlockCommand(parent()->GetConnectedNode()->track_list(track_ref.type()),
                                 track_ref.index(),
-                                 b,
+                                 block,
                                 ghost->GetAdjustedIn(),
                                 command);
    }
-  }

-  if (command->childCount() > 0) {
+    /*
    foreach (const TrackReference& t, tracks_affected) {
      new TrackCleanGapsCommand(parent()->GetConnectedNode()->track_list(t.type()),
                                t.index(),
                                command);
    }
+    */
+
+    // FIXME: Heavy optimization since MOST of the timeline does NOT change in this time
  }

  Core::instance()->undo_stack()->pushIfHasChildren(command);
 }

-rational TimelineWidget::PointerTool::FrameValidateInternal(rational time_movement, const QVector<TimelineViewGhostItem *>& ghosts)
-{
-  // Default behavior is to validate all movement and trimming
-  time_movement = ValidateFrameMovement(time_movement, ghosts);
-  time_movement = ValidateInTrimming(time_movement, ghosts, true);
-  time_movement = ValidateOutTrimming(time_movement, ghosts, true);
-
-  return time_movement;
-}
-
-void TimelineWidget::PointerTool::InitiateDrag(TimelineViewMouseEvent *mouse_pos)
-{
-  // Record where the drag started in timeline coordinates
-  drag_start_ = mouse_pos->GetCoordinates();
-
-  // Get the item that was clicked
-  TimelineViewBlockItem* clicked_item = GetItemAtScenePos(drag_start_);
-
-  // We only initiate a pointer drag if the user actually dragged an item, otherwise if they dragged on empty space
-  // QGraphicsView default behavior would initiate a rubberband drag
-  if (clicked_item != nullptr) {
-
-    // Clear snap points
-    snap_points_.clear();
-
-    // Record where the drag started in timeline coordinates
-    track_start_ = mouse_pos->GetTrack();
-
-    // Determine whether we're trimming or moving based on the position of the cursor
-    Timeline::MovementMode trim_mode = IsCursorInTrimHandle(clicked_item, mouse_pos->GetSceneX());
-
-    // Some derived classes don't allow movement
-    if (trim_mode == Timeline::kNone && movement_allowed_) {
-      trim_mode = Timeline::kMove;
-    }
-
-    // Gaps can't be moved, only trimmed
-    if (clicked_item->block()->type() == Block::kGap && trim_mode == Timeline::kMove) {
-      trim_mode = Timeline::kNone;
-    }
-
-    // Make sure we can actually perform an action here
-    if (trim_mode != Timeline::kNone) {
-      InitiateGhosts(clicked_item, trim_mode, false);
-    }
-  }
-}
-
 void TimelineWidget::PointerTool::ProcessDrag(const TimelineCoordinate &mouse_pos)
 {
-  // Determine track movement
-  const TrackReference& cursor_track = mouse_pos.GetTrack();
-  int track_movement = 0;
-
-  if (track_movement_allowed_) {
-    track_movement = cursor_track.index() - track_start_.index();
-  }
+  // Calculate track movement
+  int track_movement = track_movement_allowed_
+      ? mouse_pos.GetTrack().index() - drag_start_.GetTrack().index()
+      : 0;

  // Determine frame movement
  rational time_movement = mouse_pos.GetFrame() - drag_start_.GetFrame();
@@ -369,17 +315,22 @@ void TimelineWidget::PointerTool::ProcessDrag(const TimelineCoordinate &mouse_po
  }

  // Validate movement (enforce all ghosts moving in legal ways)
-  time_movement = FrameValidateInternal(time_movement, parent()->ghost_items_);
+  // NOTE: Always do this after snapping to ensure the snap hasn't made an illegal movement.
+  time_movement = ValidateTimeMovement(time_movement, parent()->ghost_items_);
+  time_movement = ValidateInTrimming(time_movement, parent()->ghost_items_, !trim_overwrite_allowed_);
+  time_movement = ValidateOutTrimming(time_movement, parent()->ghost_items_, !trim_overwrite_allowed_);

-  // Validate ghosts that are being moved (clips from other track types do NOT get validated or moved)
-  QVector<TimelineViewGhostItem*> validate_track_ghosts = parent()->ghost_items_;
-  for (int i=0;i<validate_track_ghosts.size();i++) {
-    if (validate_track_ghosts.at(i)->Track().type() != drag_track_type_) {
-      validate_track_ghosts.removeAt(i);
-      i--;
+  // Validate ghosts that are being moved (clips from other track types do NOT get moved)
+  {
+    QVector<TimelineViewGhostItem*> validate_track_ghosts = parent()->ghost_items_;
+    for (int i=0;i<validate_track_ghosts.size();i++) {
+      if (validate_track_ghosts.at(i)->Track().type() != drag_track_type_) {
+        validate_track_ghosts.removeAt(i);
+        i--;
+      }
    }
+    track_movement = ValidateTrackMovement(track_movement, validate_track_ghosts);
  }
-  track_movement = ValidateTrackMovement(track_movement, validate_track_ghosts);

  // Perform movement
  foreach (TimelineViewGhostItem* ghost, parent()->ghost_items_) {
@@ -401,28 +352,23 @@ void TimelineWidget::PointerTool::ProcessDrag(const TimelineCoordinate &mouse_po
      // Also, we only move the clips on the same track type that the drag started from
      if (ghost->Track().type() == drag_track_type_) {
        ghost->SetTrackAdjustment(track_movement);
-      }

-      const TrackReference& track = ghost->GetAdjustedTrack();
-      ghost->SetYCoords(parent()->GetTrackY(track), parent()->GetTrackHeight(track));
+        const TrackReference& track = ghost->GetAdjustedTrack();
+        ghost->SetYCoords(parent()->GetTrackY(track), parent()->GetTrackHeight(track));
+      }
      break;
    }
    }
  }

-  // Show tooltip
-  // Generate tooltip (showing earliest in point of imported clip)
-  int64_t earliest_timestamp = Timecode::time_to_timestamp(time_movement, parent()->GetToolTipTimebase());
-  QString tooltip_text = Timecode::timestamp_to_timecode(earliest_timestamp,
-                                                         parent()->GetToolTipTimebase(),
-                                                         Core::instance()->GetTimecodeDisplay(),
-                                                         true);
-
-  // Force tooltip to update (otherwise the tooltip won't move as written in the documentation, and could get in the way
-  // of the cursor)
+  // Regenerate tooltip and force it to update (otherwise the tooltip won't move as written in the
+  // documentation, and could get in the way of the cursor)
  QToolTip::hideText();
  QToolTip::showText(QCursor::pos(),
-                     tooltip_text,
+                     Timecode::timestamp_to_timecode(Timecode::time_to_timestamp(time_movement, parent()->GetToolTipTimebase()),
+                                                     parent()->GetToolTipTimebase(),
+                                                     Core::instance()->GetTimecodeDisplay(),
+                                                     true),
                     parent());
 }

@@ -444,89 +390,61 @@ Timeline::MovementMode TimelineWidget::PointerTool::IsCursorInTrimHandle(Timelin
  }
 }

-void TimelineWidget::PointerTool::InitiateGhosts(TimelineViewBlockItem* clicked_item,
-                                                 Timeline::MovementMode trim_mode,
-                                                 bool allow_gap_trimming)
+void TimelineWidget::PointerTool::InitiateDrag(TimelineViewBlockItem* clicked_item,
+                                               Timeline::MovementMode trim_mode,
+                                               bool allow_gap_trimming)
 {
-  // Convert selected items list to clips list
+  // Get list of selected blocks
  QList<TimelineViewBlockItem*> clips = parent()->GetSelectedBlocks();

-  // If trimming multiple clips, we only trim the earliest in each track (trimming in) or the latest in each track
-  // (trimming out). If the current clip is NOT one of these, we only trim it.
-  bool multitrim_enabled = true;
+  if (trim_mode == Timeline::kMove) {

-  // Determine if the clicked item is the earliest/latest in the track for in/out trimming respectively
-  if (Timeline::IsATrimMode(trim_mode)) {
-    multitrim_enabled = IsClipTrimmable(clicked_item, clips, trim_mode);
-  }
+    // Create ghosts for moving
+    foreach (TimelineViewBlockItem* clip_item, clips) {

-  // For each selected item, create a "ghost", a visual representation of the action before it gets performed
-  foreach (TimelineViewBlockItem* clip_item, clips) {
+      // Gaps are not allowed to move, so we ignore those here
+      if (clip_item->block()->type() == Block::kGap) {
+        continue;
+      }

-    // Determine correct mode for ghost
-    //
-    // Movement is indiscriminate, all the ghosts can be set to do this, however trimming is limited to one block
-    // PER TRACK
-
-    bool include_this_clip = true;
-
-    if (clip_item->block()->type() == Block::kGap
-        && !Timeline::IsATrimMode(trim_mode)) {
-      continue;
+      AddGhostFromBlock(clip_item->block(), clip_item->Track(), trim_mode);
    }

-    if (clip_item != clicked_item
-        && (Timeline::IsATrimMode(trim_mode))) {
-      include_this_clip = multitrim_enabled ? IsClipTrimmable(clip_item, clips, trim_mode) : false;
-    }
+  } else {
+
+    // "Multi-trim" is trimming a clip on more than one track. Only the earliest (for in trimming)
+    // or latest (for out trimming) clip on each track can be trimmed. Therefore, it's only enabled
+    // if the clicked item is the earliest/latest on its track.
+    bool multitrim_enabled = IsClipTrimmable(clicked_item, clips, trim_mode);
+
+    // Create ghosts for trimming
+    foreach (TimelineViewBlockItem* clip_item, clips) {
+      if (clip_item != clicked_item
+          && (!multitrim_enabled || !IsClipTrimmable(clip_item, clips, trim_mode))) {
+        // Either multitrim is disabled or this clip is NOT the earliest/latest in its track. We
+        // won't include it.
+        continue;
+      }

-    if (include_this_clip) {
      Block* block = clip_item->block();
      Timeline::MovementMode block_mode = trim_mode;

-      // If we don't allow gap trimming, we automatically switch to the next/previous block to trim
+      // Some tools interpret "gap trimming" as equivalent to resizing the adjacent block. In that
+      // scenario, we include the adjacent block instead.
      if (block->type() == Block::kGap && !allow_gap_trimming) {
-        if (trim_mode == Timeline::kTrimIn) {
-          // Trim the previous clip's out point instead
-          block = block->previous();
-        } else {
-          // Assume kTrimOut
-          block = block->next();
-        }
+        block = (trim_mode == Timeline::kTrimIn) ? block->previous() : block->next();
        block_mode = FlipTrimMode(trim_mode);
-      }

-      if (block) {
-        TimelineViewGhostItem* ghost = AddGhostFromBlock(block, clip_item->Track(), block_mode);
-
-        if (block->type() == Block::kTransition) {
-          TransitionBlock* transition = static_cast<TransitionBlock*>(block);
-
-          bool transition_can_move_tracks = false;
-
-          // Create a rolling effect with the attached block
-          if (transition->connected_in_block()) {
-            if (parent()->block_items_.value(transition->connected_in_block())->isSelected()) {
-              // We'll be moving this item too, no need to create a ghost for it here
-              transition_can_move_tracks = true;
-            } else if (block_mode == Timeline::kTrimOut || block_mode == Timeline::kMove) {
-              AddGhostFromBlock(transition->connected_in_block(), clip_item->Track(), Timeline::kTrimIn);
-            }
-          }
-
-          if (transition->connected_out_block()) {
-            if (parent()->block_items_.value(transition->connected_in_block())->isSelected()) {
-                // We'll be moving this item too, no need to create a ghost for it here
-              transition_can_move_tracks = true;
-            } else if (block_mode == Timeline::kTrimIn || block_mode == Timeline::kMove) {
-              AddGhostFromBlock(transition->connected_out_block(), clip_item->Track(), Timeline::kTrimOut);
-            }
-          }
-
-          ghost->SetCanMoveTracks(transition_can_move_tracks);
+        // If there's no adjacent block, do nothing here
+        if (!block) {
+          continue;
        }
      }
+
+      // Create ghost for this block
+      AddGhostFromBlock(block, clip_item->Track(), block_mode);
    }
+
  }
 }

@@ -29,74 +29,16 @@ TimelineWidget::RippleTool::RippleTool(TimelineWidget* parent) :
  PointerTool(parent)
 {
  SetMovementAllowed(false);
+  SetTrimOverwriteAllowed(true);
 }

-void TimelineWidget::RippleTool::MouseReleaseInternal(TimelineViewMouseEvent *event)
-{
-  Q_UNUSED(event)
-
-  // For ripple operations, all ghosts will be moving the same way
-  Timeline::MovementMode movement_mode = parent()->ghost_items_.first()->mode();
-
-  QUndoCommand* command = new QUndoCommand();
-
-  // Find earliest point to ripple around
-  foreach (TimelineViewGhostItem* ghost, parent()->ghost_items_) {
-    Block* b = Node::ValueToPtr<Block>(ghost->data(TimelineViewGhostItem::kAttachedBlock));
-
-    if (b == nullptr) {
-      // This is a gap we are creating
-
-      // Make sure there's actually a gap being created
-      if (ghost->AdjustedLength() > 0) {
-        GapBlock* gap = new GapBlock();
-        gap->set_length_and_media_out(ghost->AdjustedLength());
-        new NodeAddCommand(static_cast<NodeGraph*>(parent()->GetConnectedNode()->parent()), gap, command);
-
-        Block* block_to_append_gap_to = Node::ValueToPtr<Block>(ghost->data(TimelineViewGhostItem::kReferenceBlock));
-
-        new TrackInsertBlockAfterCommand(parent()->GetTrackFromReference(ghost->Track()),
-                                         gap,
-                                         block_to_append_gap_to,
-                                         command);
-      }
-    } else {
-      // This was a Block that already existed
-      if (ghost->AdjustedLength() > 0) {
-        if (movement_mode == Timeline::kTrimIn) {
-          // We'll need to shift the media in point too
-          new BlockResizeWithMediaInCommand(b, ghost->AdjustedLength(), command);
-        } else {
-          new BlockResizeCommand(b, ghost->AdjustedLength(), command);
-        }
-      } else {
-        // Assumed the Block was a Gap and it was reduced to zero length, remove it here
-        new TrackRippleRemoveBlockCommand(parent()->GetTrackFromReference(ghost->Track()), b, command);
-
-        new NodeRemoveWithExclusiveDeps(static_cast<NodeGraph*>(b->parent()), b, command);
-      }
-    }
-  }
-
-  Core::instance()->undo_stack()->pushIfHasChildren(command);
-}
-
-rational TimelineWidget::RippleTool::FrameValidateInternal(rational time_movement, const QVector<TimelineViewGhostItem *> &ghosts)
-{
-  // Only validate trimming, and we don't care about "overwriting" since the ripple tool is nondestructive
-  time_movement = ValidateInTrimming(time_movement, ghosts, false);
-  time_movement = ValidateOutTrimming(time_movement, ghosts, false);
-
-  return time_movement;
-}
-
-void TimelineWidget::RippleTool::InitiateGhosts(TimelineViewBlockItem *clicked_item,
-                                                Timeline::MovementMode trim_mode,
-                                                bool allow_gap_trimming)
+void TimelineWidget::RippleTool::InitiateDrag(TimelineViewBlockItem *clicked_item,
+                                              Timeline::MovementMode trim_mode,
+                                              bool allow_gap_trimming)
 {
  Q_UNUSED(allow_gap_trimming)

-  PointerTool::InitiateGhosts(clicked_item, trim_mode, true);
+  PointerTool::InitiateDrag(clicked_item, trim_mode, true);

  if (parent()->ghost_items_.isEmpty()) {
    return;
@@ -155,4 +97,54 @@ void TimelineWidget::RippleTool::InitiateGhosts(TimelineViewBlockItem *clicked_i
  }
 }

+void TimelineWidget::RippleTool::FinishDrag(TimelineViewMouseEvent *event)
+{
+  Q_UNUSED(event)
+
+  // For ripple operations, all ghosts will be moving the same way
+  Timeline::MovementMode movement_mode = parent()->ghost_items_.first()->mode();
+
+  QUndoCommand* command = new QUndoCommand();
+
+  // Find earliest point to ripple around
+  foreach (TimelineViewGhostItem* ghost, parent()->ghost_items_) {
+    Block* b = Node::ValueToPtr<Block>(ghost->data(TimelineViewGhostItem::kAttachedBlock));
+
+    if (b == nullptr) {
+      // This is a gap we are creating
+
+      // Make sure there's actually a gap being created
+      if (ghost->AdjustedLength() > 0) {
+        GapBlock* gap = new GapBlock();
+        gap->set_length_and_media_out(ghost->AdjustedLength());
+        new NodeAddCommand(static_cast<NodeGraph*>(parent()->GetConnectedNode()->parent()), gap, command);
+
+        Block* block_to_append_gap_to = Node::ValueToPtr<Block>(ghost->data(TimelineViewGhostItem::kReferenceBlock));
+
+        new TrackInsertBlockAfterCommand(parent()->GetTrackFromReference(ghost->Track()),
+                                         gap,
+                                         block_to_append_gap_to,
+                                         command);
+      }
+    } else {
+      // This was a Block that already existed
+      if (ghost->AdjustedLength() > 0) {
+        if (movement_mode == Timeline::kTrimIn) {
+          // We'll need to shift the media in point too
+          new BlockResizeWithMediaInCommand(b, ghost->AdjustedLength(), command);
+        } else {
+          new BlockResizeCommand(b, ghost->AdjustedLength(), command);
+        }
+      } else {
+        // Assumed the Block was a Gap and it was reduced to zero length, remove it here
+        new TrackRippleRemoveBlockCommand(parent()->GetTrackFromReference(ghost->Track()), b, command);
+
+        new NodeRemoveWithExclusiveDeps(static_cast<NodeGraph*>(b->parent()), b, command);
+      }
+    }
+  }
+
+  Core::instance()->undo_stack()->pushIfHasChildren(command);
+}
+
 OLIVE_NAMESPACE_EXIT
@@ -29,77 +29,47 @@ TimelineWidget::RollingTool::RollingTool(TimelineWidget* parent) :
  PointerTool(parent)
 {
  SetMovementAllowed(false);
+  SetTrimOverwriteAllowed(true);
 }

-void TimelineWidget::RollingTool::MouseReleaseInternal(TimelineViewMouseEvent *event)
+void TimelineWidget::RollingTool::InitiateDrag(TimelineViewBlockItem *clicked_item,
+                                               Timeline::MovementMode trim_mode,
+                                               bool allow_gap_trimming)
 {
-  Q_UNUSED(event)
+  PointerTool::InitiateDrag(clicked_item, trim_mode, true);

+  // For each ghost, we make an equivalent Ghost on the next/previous block
+  foreach (TimelineViewGhostItem* ghost, parent()->ghost_items_) {
+    Block* ghost_block = Node::ValueToPtr<Block>(ghost->data(TimelineViewGhostItem::kAttachedBlock));
+
+    if (ghost->mode() == Timeline::kTrimIn && ghost_block->previous()) {
+      // Add an extra Ghost for the previous block
+      AddGhostFromBlock(ghost_block->previous(), ghost->Track(), Timeline::kTrimOut);
+    } else if (ghost->mode() == Timeline::kTrimOut && ghost_block->next()) {
+      AddGhostFromBlock(ghost_block->next(), ghost->Track(), Timeline::kTrimIn);
+    }
+  }
+}
+
+void TimelineWidget::RollingTool::FinishDrag(TimelineViewMouseEvent *event)
+{
  QUndoCommand* command = new QUndoCommand();

  // Find earliest point to ripple around
  foreach (TimelineViewGhostItem* ghost, parent()->ghost_items_) {
-    Block* b = Node::ValueToPtr<Block>(ghost->data(TimelineViewGhostItem::kAttachedBlock));
+    if (ghost->mode() == drag_movement_mode()) {
+      Block* b = Node::ValueToPtr<Block>(ghost->data(TimelineViewGhostItem::kAttachedBlock));

-    if (ghost->mode() == Timeline::kTrimIn) {
-      if (b->previous() == nullptr) {
-        // We'll need to insert a gap here, so we'll do a Place command instead
-        GapBlock* gap = new GapBlock();
-        gap->set_length_and_media_out(ghost->Length());
-        new NodeAddCommand(static_cast<NodeGraph*>(b->parent()),
-                           gap,
-                           command);
-
-        new TrackReplaceBlockCommand(parent()->GetTrackFromReference(ghost->Track()), b, gap, command);
-      }
-
-      new BlockResizeWithMediaInCommand(b, ghost->AdjustedLength(), command);
-
-      if (b->previous() == nullptr) {
-        const TrackReference& track_ref = ghost->Track();
-
-        new TrackPlaceBlockCommand(parent()->GetConnectedNode()->track_list(track_ref.type()),
-                                   track_ref.index(),
-                                   b,
-                                   ghost->GetAdjustedIn(),
-                                   command);
-      }
-    } else if (ghost->mode() == Timeline::kTrimOut) {
-      new BlockResizeCommand(b, ghost->AdjustedLength(), command);
+      BlockTrimCommand* c = new BlockTrimCommand(parent()->GetTrackFromReference(ghost->Track()),
+                                                 b,
+                                                 ghost->AdjustedLength(),
+                                                 drag_movement_mode(),
+                                                 command);
+      c->SetAllowNonGapTrimming(true);
    }
  }

  Core::instance()->undo_stack()->pushIfHasChildren(command);
 }

-rational TimelineWidget::RollingTool::FrameValidateInternal(rational time_movement, const QVector<TimelineViewGhostItem *> &ghosts)
-{
-  // Only validate trimming, and we don't care about "overwriting" since the rolling tool is designed to trim at collisions
-  time_movement = ValidateInTrimming(time_movement, ghosts, false);
-  time_movement = ValidateOutTrimming(time_movement, ghosts, false);
-
-  return time_movement;
-}
-
-void TimelineWidget::RollingTool::InitiateGhosts(TimelineViewBlockItem *clicked_item,
-                                               Timeline::MovementMode trim_mode,
-                                               bool allow_gap_trimming)
-{
-  Q_UNUSED(allow_gap_trimming)
-
-  PointerTool::InitiateGhosts(clicked_item, trim_mode, true);
-
-  // For each ghost, we make an equivalent Ghost on the next/previous block
-  foreach (TimelineViewGhostItem* ghost, parent()->ghost_items_) {
-    Block* ghost_block = Node::ValueToPtr<Block>(ghost->data(TimelineViewGhostItem::kAttachedBlock));
-
-    if (ghost->mode() == Timeline::kTrimIn && ghost_block->previous() != nullptr) {
-      // Add an extra Ghost for the previous block
-      AddGhostFromBlock(ghost_block->previous(), ghost->Track(), Timeline::kTrimOut);
-    } else if (ghost->mode() == Timeline::kTrimOut && ghost_block->next() != nullptr) {
-      AddGhostFromBlock(ghost_block->next(), ghost->Track(), Timeline::kTrimIn);
-    }
-  }
-}
-
 OLIVE_NAMESPACE_EXIT
@@ -30,65 +30,107 @@ TimelineWidget::SlideTool::SlideTool(TimelineWidget* parent) :
 {
  SetTrimmingAllowed(false);
  SetTrackMovementAllowed(false);
+  SetTrimOverwriteAllowed(true);
 }

-void TimelineWidget::SlideTool::MouseReleaseInternal(TimelineViewMouseEvent *event)
-{
-  Q_UNUSED(event)
+struct TrackBlockListPair {
+  TrackReference track;
+  QList<Block*> blocks;
+};

-  QUndoCommand* command = new QUndoCommand();
-
-  // Find earliest point to ripple around
-  foreach (TimelineViewGhostItem* ghost, parent()->ghost_items_) {
-    Block* b = Node::ValueToPtr<Block>(ghost->data(TimelineViewGhostItem::kAttachedBlock));
-
-    if (ghost->mode() == Timeline::kTrimIn) {
-      new BlockResizeWithMediaInCommand(b, ghost->AdjustedLength(), command);
-    } else if (ghost->mode() == Timeline::kTrimOut) {
-      new BlockResizeCommand(b, ghost->AdjustedLength(), command);
-    } else if (ghost->mode() == Timeline::kMove && b->previous() == nullptr) {
-      GapBlock* gap = new GapBlock();
-      gap->set_length_and_media_out(ghost->InAdjustment());
-      new NodeAddCommand(static_cast<NodeGraph*>(b->parent()), gap, command);
-      new TrackPrependBlockCommand(parent()->GetTrackFromReference(ghost->Track()), gap, command);
-    }
-  }
-
-  Core::instance()->undo_stack()->pushIfHasChildren(command);
-}
-
-rational TimelineWidget::SlideTool::FrameValidateInternal(rational time_movement, const QVector<TimelineViewGhostItem *> &ghosts)
-{
-  // Only validate trimming, and we don't care about "overwriting" since the rolling tool is designed to trim at collisions
-  time_movement = ValidateInTrimming(time_movement, ghosts, false);
-  time_movement = ValidateOutTrimming(time_movement, ghosts, false);
-
-  return time_movement;
-}
-
-void TimelineWidget::SlideTool::InitiateGhosts(TimelineViewBlockItem *clicked_item,
-                                               Timeline::MovementMode trim_mode,
-                                               bool allow_gap_trimming)
+void TimelineWidget::SlideTool::InitiateDrag(TimelineViewBlockItem *clicked_item,
+                                             Timeline::MovementMode trim_mode,
+                                             bool allow_gap_trimming)
 {
  Q_UNUSED(allow_gap_trimming)

-  PointerTool::InitiateGhosts(clicked_item, trim_mode, true);
+  PointerTool::InitiateDrag(clicked_item, trim_mode, true);

-  // For each ghost, we make an equivalent Ghost on the next/previous block
+  // Sort blocks into tracks
+  QList<TrackBlockListPair> blocks_per_track;
  foreach (TimelineViewGhostItem* ghost, parent()->ghost_items_) {
-    Block* ghost_block = Node::ValueToPtr<Block>(ghost->data(TimelineViewGhostItem::kAttachedBlock));
+    Block* b = Node::ValueToPtr<Block>(ghost->data(TimelineViewGhostItem::kAttachedBlock));
+    bool found = false;

-    // Add trimming ghosts for each side of the Block
-
-    if (ghost_block->previous() != nullptr) {
-      // Add an extra Ghost for the previous block
-      AddGhostFromBlock(ghost_block->previous(), ghost->Track(), Timeline::kTrimOut);
+    for (int i=0;i<blocks_per_track.size();i++) {
+      if (blocks_per_track.at(i).track == ghost->Track()) {
+        blocks_per_track[i].blocks.append(b);
+        found = true;
+        break;
+      }
    }

-    if (ghost_block->next() != nullptr) {
-      AddGhostFromBlock(ghost_block->next(), ghost->Track(), Timeline::kTrimIn);
+    if (!found) {
+      blocks_per_track.append({ghost->Track(), {b}});
    }
  }
+
+  // Make contiguous runs of blocks per each track
+  foreach (const TrackBlockListPair& p, blocks_per_track) {
+    // Blocks must be merged if any are non-adjacent
+    const TrackReference& track = p.track;
+    const QList<Block*>& blocks = p.blocks;
+
+    Block* earliest_block = blocks.first();
+    Block* latest_block = blocks.first();
+
+    // Find the earliest and latest selected blocks
+    for (int j=1;j<blocks.size();j++) {
+      Block* compare = blocks.at(j);
+
+      if (compare->in() < earliest_block->in()) {
+        earliest_block = compare;
+      }
+
+      if (compare->in() > latest_block->in()) {
+        latest_block = compare;
+      }
+    }
+
+    // Add any blocks between these blocks that aren't already in the list
+    if (earliest_block != latest_block) {
+      Block* b = earliest_block;
+      while ((b = b->next()) != latest_block) {
+        if (!blocks.contains(b)) {
+          AddGhostFromBlock(b, track, Timeline::kMove);
+        }
+      }
+    }
+
+    // Add surrounding blocks that will be trimming instead of moving
+    if (earliest_block->previous()) {
+      AddGhostFromBlock(earliest_block->previous(), track, Timeline::kTrimOut);
+    }
+
+    if (latest_block->next()) {
+      AddGhostFromBlock(latest_block->next(), track, Timeline::kTrimIn);
+    }
+  }
+}
+
+void TimelineWidget::SlideTool::FinishDrag(TimelineViewMouseEvent *event)
+{
+  Q_UNUSED(event)
+
+  QVector<TrackSlideCommand::BlockSlideInfo> info;
+
+  foreach (TimelineViewGhostItem* ghost, parent()->ghost_items_) {
+    if (!ghost->HasBeenAdjusted()) {
+      continue;
+    }
+
+    Block* b = Node::ValueToPtr<Block>(ghost->data(TimelineViewGhostItem::kAttachedBlock));
+
+    info.append({parent()->GetTrackFromReference(ghost->Track()),
+                 b,
+                 ghost->mode(),
+                 ghost->mode() == Timeline::kMove ? ghost->GetAdjustedIn() : ghost->AdjustedLength(),
+                 ghost->mode() == Timeline::kMove ? ghost->In() : ghost->Length()});
+  }
+
+  if (!info.isEmpty()) {
+    Core::instance()->undo_stack()->push(new TrackSlideCommand(info));
+  }
 }

 OLIVE_NAMESPACE_EXIT
@@ -51,22 +51,18 @@ void TimelineWidget::SlipTool::ProcessDrag(const TimelineCoordinate &mouse_pos)
    ghost->SetMediaInAdjustment(time_movement);
  }

-  // Show tooltip
-  // Generate tooltip (showing earliest in point of imported clip)
-  int64_t earliest_timestamp = Timecode::time_to_timestamp(time_movement, parent()->GetToolTipTimebase());
-  QString tooltip_text = Timecode::timestamp_to_timecode(earliest_timestamp,
-                                                         parent()->GetToolTipTimebase(),
-                                                         Core::instance()->GetTimecodeDisplay(),
-                                                         true);
-  // Force tooltip to update (otherwise the tooltip won't move as written in the documentation, and could get in the way
-  // of the cursor)
+  // Generate tooltip and force it to to update (otherwise the tooltip won't move as written in the
+  // documentation, and could get in the way of the cursor)
  QToolTip::hideText();
  QToolTip::showText(QCursor::pos(),
-                     tooltip_text,
+                     Timecode::timestamp_to_timecode(Timecode::time_to_timestamp(time_movement, parent()->GetToolTipTimebase()),
+                                                                              parent()->GetToolTipTimebase(),
+                                                                              Core::instance()->GetTimecodeDisplay(),
+                                                                              true),
                     parent());
 }

-void TimelineWidget::SlipTool::MouseReleaseInternal(TimelineViewMouseEvent *event)
+void TimelineWidget::SlipTool::FinishDrag(TimelineViewMouseEvent *event)
 {
  Q_UNUSED(event)

@@ -98,7 +98,7 @@ void AttemptSnap(const QList<double>& proposed_pts,
  }
 }

-rational TimelineWidget::Tool::ValidateFrameMovement(rational movement, const QVector<TimelineViewGhostItem *> ghosts)
+rational TimelineWidget::Tool::ValidateTimeMovement(rational movement, const QVector<TimelineViewGhostItem *> ghosts)
 {
  foreach (TimelineViewGhostItem* ghost, ghosts) {
    if (ghost->mode() != Timeline::kMove) {
@@ -21,8 +21,9 @@
 #include "undo.h"

 #include "core.h"
-#include "node/graph.h"
+#include "node/block/clip/clip.h"
 #include "node/block/transition/transition.h"
+#include "node/graph.h"
 #include "widget/nodeview/nodeviewundo.h"

 OLIVE_NAMESPACE_ENTER
@@ -342,6 +343,11 @@ TrackPlaceBlockCommand::TrackPlaceBlockCommand(TrackList *timeline, int track, B
  insert_ = block;
 }

+Project *TrackPlaceBlockCommand::GetRelevantProject() const
+{
+  return static_cast<Sequence*>(static_cast<ViewerOutput*>(timeline_->parent())->parent())->project();
+}
+
 void TrackPlaceBlockCommand::redo_internal()
 {
  added_track_count_ = 0;
@@ -425,8 +431,7 @@ Project *BlockSplitCommand::GetRelevantProject() const

 void BlockSplitCommand::redo_internal()
 {
-  // FIXME: Reintroduce this optimization when block waveforms update automatically
-  //  track_->BlockInvalidateCache();
+  track_->BlockInvalidateCache();

  static_cast<NodeGraph*>(block_->parent())->AddNode(new_block_);
  Node::CopyInputs(block_, new_block_);
@@ -444,12 +449,16 @@ void BlockSplitCommand::redo_internal()
    NodeParam::ConnectEdge(new_block_->output(), transition);
  }

-  //  track_->UnblockInvalidateCache();
+  if (block_->type() == Block::kClip) {
+    static_cast<ClipBlock*>(new_block_)->set_waveform(static_cast<ClipBlock*>(block_)->waveform().Cut(new_length_));
+  }
+
+  track_->UnblockInvalidateCache();
 }

 void BlockSplitCommand::undo_internal()
 {
-  //  track_->BlockInvalidateCache();
+  track_->BlockInvalidateCache();

  block_->set_length_and_media_out(old_length_);
  track_->RippleRemoveBlock(new_block_);
@@ -461,7 +470,11 @@ void BlockSplitCommand::undo_internal()
    NodeParam::ConnectEdge(block_->output(), transition);
  }

-  //  track_->UnblockInvalidateCache();
+  if (block_->type() == Block::kClip) {
+    static_cast<ClipBlock*>(block_)->waveform().Append(static_cast<ClipBlock*>(new_block_)->waveform());
+  }
+
+  track_->UnblockInvalidateCache();
 }

 Block *BlockSplitCommand::new_block()
@@ -593,6 +606,7 @@ Project *BlockSplitPreservingLinksCommand::GetRelevantProject() const
  return static_cast<Sequence*>(blocks_.first()->parent())->project();
 }

+/*
 TrackCleanGapsCommand::TrackCleanGapsCommand(TrackList *track_list, int index, QUndoCommand *parent) :
  UndoCommand(parent),
  track_list_(track_list),
@@ -686,6 +700,7 @@ void TrackCleanGapsCommand::undo_internal()

  merged_gaps_.clear();
 }
+*/

 BlockSetSpeedCommand::BlockSetSpeedCommand(Block *block, const rational &new_speed, QUndoCommand *parent) :
  UndoCommand(parent),
@@ -923,4 +938,413 @@ void BlockEnableDisableCommand::undo_internal()
  block_->set_enabled(old_enabled_);
 }

+BlockTrimCommand::BlockTrimCommand(TrackOutput* track, Block *block, rational new_length, Timeline::MovementMode mode, QUndoCommand *command) :
+  UndoCommand(command),
+  track_(track),
+  block_(block),
+  old_length_(block->length()),
+  new_length_(new_length),
+  mode_(mode),
+  adjacent_(nullptr),
+  we_created_adjacent_(false),
+  allow_nongap_trimming_(false)
+{
+}
+
+Project *BlockTrimCommand::GetRelevantProject() const
+{
+  return static_cast<Sequence*>(block_->parent())->project();
+}
+
+void BlockTrimCommand::redo_internal()
+{
+  track_->BlockInvalidateCache();
+
+  // Will be POSITIVE if trimming shorter and NEGATIVE if trimming longer
+  rational trim_diff = old_length_ - new_length_;
+
+  TimeRange invalidate_range;
+
+  if (mode_ == Timeline::kTrimIn) {
+    invalidate_range = TimeRange(block_->in(), block_->in() + trim_diff);
+    block_->set_length_and_media_in(new_length_);
+    adjacent_ = block_->previous();
+  } else {
+    invalidate_range = TimeRange(block_->out(), block_->out() - trim_diff);
+    block_->set_length_and_media_out(new_length_);
+    adjacent_ = block_->next();
+  }
+
+  if (trim_diff > rational()) {
+    // If trimming SHORTER, we'll need to create/modify a gap
+    if (adjacent_ && (adjacent_->type() == Block::kGap || allow_nongap_trimming_)) {
+
+      // A gap (or equivalent) exists, simply increase the size of it
+      if (mode_ == Timeline::kTrimIn) {
+        adjacent_->set_length_and_media_out(adjacent_->length() + trim_diff);
+      } else {
+        adjacent_->set_length_and_media_in(adjacent_->length() + trim_diff);
+      }
+
+    } else {
+
+      // Don't create a gap if the trim was at the end of the sequence (which would be indicated by
+      // the mode being "trim out" and "block_->next()" being null.
+      if (mode_ == Timeline::kTrimIn || block_->next()) {
+        // We must create a gap
+        we_created_adjacent_ = true;
+
+        adjacent_ = new GapBlock();
+        adjacent_->set_length_and_media_out(trim_diff);
+        static_cast<NodeGraph*>(track_->parent())->AddNode(adjacent_);
+
+        if (mode_ == Timeline::kTrimIn) {
+          track_->InsertBlockBefore(adjacent_, block_);
+        } else {
+          track_->InsertBlockAfter(adjacent_, block_);
+        }
+      }
+
+    }
+
+    if (block_->type() == Block::kClip) {
+      if (mode_ == Timeline::kTrimIn) {
+        static_cast<ClipBlock*>(block_)->waveform().TrimIn(trim_diff);
+      } else {
+        static_cast<ClipBlock*>(block_)->waveform().TrimOut(trim_diff);
+      }
+    }
+  } else {
+    if (adjacent_) {
+      // If trimming LONGER, we'll need to trim the adjacent
+      // (assume if there's no adjacent, we're at the end of the timeline and do nothing)
+      if (mode_ == Timeline::kTrimIn) {
+        adjacent_->set_length_and_media_out(adjacent_->length() + trim_diff);
+      } else {
+        adjacent_->set_length_and_media_in(adjacent_->length() + trim_diff);
+      }
+    }
+
+    if (block_->type() == Block::kClip) {
+      if (mode_ == Timeline::kTrimIn) {
+        static_cast<ClipBlock*>(block_)->waveform().PrependSilence(-trim_diff);
+      } else {
+        static_cast<ClipBlock*>(block_)->waveform().AppendSilence(-trim_diff);
+      }
+    }
+  }
+
+  track_->UnblockInvalidateCache();
+
+  track_->InvalidateCache(invalidate_range, track_->block_input(), track_->block_input());
+}
+
+void BlockTrimCommand::undo_internal()
+{
+  track_->BlockInvalidateCache();
+
+  // Will be POSITIVE if trimming shorter and NEGATIVE if trimming longer
+  rational trim_diff = old_length_ - new_length_;
+
+  if (trim_diff > rational()) {
+    // If trimmed SHORTER, we need to unadjust the gap
+    if (we_created_adjacent_) {
+      // If we created a gap, just remove it straight up
+      track_->RippleRemoveBlock(adjacent_);
+      TakeNodeFromParentGraph(adjacent_);
+      delete adjacent_;
+      adjacent_ = nullptr;
+      we_created_adjacent_ = false;
+    } else if (adjacent_) {
+      // If we adjusted an existing gap, unadjust here
+      adjacent_->set_length_and_media_out(adjacent_->length() - trim_diff);
+    }
+
+    if (block_->type() == Block::kClip) {
+      if (mode_ == Timeline::kTrimIn) {
+        static_cast<ClipBlock*>(block_)->waveform().PrependSilence(trim_diff);
+      } else {
+        static_cast<ClipBlock*>(block_)->waveform().AppendSilence(trim_diff);
+      }
+    }
+  } else {
+    if (adjacent_) {
+      // If trimmed LONGER, we adjusted an existing block
+      // (assume if there's no adjacent, we're at the end of the timeline and do nothing)
+      if (mode_ == Timeline::kTrimIn) {
+        adjacent_->set_length_and_media_out(adjacent_->length() - trim_diff);
+      }
+    }
+
+    if (block_->type() == Block::kClip) {
+      if (mode_ == Timeline::kTrimIn) {
+        static_cast<ClipBlock*>(block_)->waveform().TrimIn(-trim_diff);
+      } else {
+        static_cast<ClipBlock*>(block_)->waveform().TrimOut(-trim_diff);
+      }
+    }
+  }
+
+  TimeRange invalidate_range;
+
+  if (mode_ == Timeline::kTrimIn) {
+    block_->set_length_and_media_in(old_length_);
+    invalidate_range = TimeRange(block_->in(), block_->in() + trim_diff);
+  } else {
+    block_->set_length_and_media_out(old_length_);
+    invalidate_range = TimeRange(block_->out(), block_->out() - trim_diff);
+  }
+
+  track_->UnblockInvalidateCache();
+
+  track_->InvalidateCache(invalidate_range, track_->block_input(), track_->block_input());
+}
+
+TrackReplaceBlockWithGapCommand::TrackReplaceBlockWithGapCommand(TrackOutput *track, Block *block, QUndoCommand *command) :
+  UndoCommand(command),
+  track_(track),
+  block_(block),
+  we_created_gap_(false),
+  gap_(nullptr),
+  merged_gap_(nullptr)
+{
+}
+
+Project *TrackReplaceBlockWithGapCommand::GetRelevantProject() const
+{
+  return static_cast<Sequence*>(block_->parent())->project();
+}
+
+void TrackReplaceBlockWithGapCommand::redo_internal()
+{
+  TimeRange invalidate_range;
+
+  track_->BlockInvalidateCache();
+
+  // If the block has no next, it's at the end of the track and there's no need to create a gap
+  if (block_->next()) {
+    invalidate_range = TimeRange(block_->in(), block_->out());
+
+    rational new_gap_length = block_->length();
+
+    bool previous_is_a_gap = (block_->previous() && block_->previous()->type() == Block::kGap);
+    bool next_is_a_gap = (block_->next() && block_->next()->type() == Block::kGap);
+
+    if (previous_is_a_gap) {
+      // Extend gap before this block
+      gap_ = static_cast<GapBlock*>(block_->previous());
+
+      // If the next is also a gap, we'll merge the two
+      if (next_is_a_gap) {
+        merged_gap_ = static_cast<GapBlock*>(block_->next());
+
+        new_gap_length += merged_gap_->length();
+        track_->RippleRemoveBlock(merged_gap_);
+        TakeNodeFromParentGraph(merged_gap_, &memory_manager_);
+      }
+    } else if (next_is_a_gap) {
+      // Extend gap after this block
+      gap_ = static_cast<GapBlock*>(block_->next());
+    }
+
+    if (gap_) {
+      // Extend an existing gap
+      new_gap_length += gap_->length();
+      gap_->set_length_and_media_out(new_gap_length);
+      track_->RippleRemoveBlock(block_);
+    } else {
+      // No gap exists, create one
+      gap_ = new GapBlock();
+      gap_->set_length_and_media_out(new_gap_length);
+      static_cast<NodeGraph*>(track_->parent())->AddNode(gap_);
+      track_->ReplaceBlock(block_, gap_);
+      we_created_gap_ = true;
+    }
+
+  } else {
+    rational earliest_change = block_->in();
+
+    // Handle the gap being at the end where no gap is necessary
+    track_->RippleRemoveBlock(block_);
+
+    // If there were also gaps leading up to this block, clean them up here
+    if (!track_->Blocks().isEmpty() && track_->Blocks().last()->type() == Block::kGap) {
+      merged_gap_ = static_cast<GapBlock*>(track_->Blocks().last());
+      earliest_change = merged_gap_->in();
+      track_->RippleRemoveBlock(merged_gap_);
+      TakeNodeFromParentGraph(merged_gap_, &memory_manager_);
+    }
+
+    invalidate_range = TimeRange(earliest_change, RATIONAL_MAX);
+  }
+
+  track_->UnblockInvalidateCache();
+
+  track_->InvalidateCache(invalidate_range, track_->block_input(), track_->block_input());
+}
+
+void TrackReplaceBlockWithGapCommand::undo_internal()
+{
+  TimeRange invalidate_range;
+
+  track_->BlockInvalidateCache();
+
+  if (gap_) {
+
+    if (we_created_gap_) {
+      // We made this gap, simply swap our gap back
+      track_->ReplaceBlock(gap_, block_);
+      TakeNodeFromParentGraph(gap_);
+      delete gap_;
+      gap_ = nullptr;
+    } else {
+      // We must have extended an existing gap
+      rational original_gap_length = gap_->length() - block_->length();
+
+      // If we merged two gaps together, restore it now
+      if (merged_gap_) {
+        original_gap_length -= merged_gap_->length();
+        static_cast<NodeGraph*>(track_->parent())->AddNode(merged_gap_);
+        track_->InsertBlockAfter(merged_gap_, gap_);
+      }
+
+      // Restore original block
+      track_->InsertBlockAfter(block_, gap_);
+
+      // Restore gap's original length
+      gap_->set_length_and_media_out(original_gap_length);
+    }
+
+    invalidate_range = TimeRange(block_->in(), block_->out());
+
+  } else {
+
+    // If there's no `gap_`, we must have removed the block at the end
+    invalidate_range = TimeRange(track_->length(), RATIONAL_MAX);
+
+    if (merged_gap_) {
+      static_cast<NodeGraph*>(track_->parent())->AddNode(merged_gap_);
+      track_->AppendBlock(merged_gap_);
+    }
+
+    track_->AppendBlock(block_);
+
+  }
+
+  merged_gap_ = nullptr;
+
+  track_->UnblockInvalidateCache();
+
+  track_->InvalidateCache(invalidate_range, track_->block_input(), track_->block_input());
+}
+
+TrackSlideCommand::TrackSlideCommand(const QVector<TrackSlideCommand::BlockSlideInfo> &blocks, QUndoCommand *parent) :
+  UndoCommand(parent),
+  blocks_(blocks)
+{
+}
+
+Project *TrackSlideCommand::GetRelevantProject() const
+{
+  return static_cast<Sequence*>(blocks_.first().track->parent())->project();
+}
+
+void TrackSlideCommand::redo_internal()
+{
+  slide_internal(false);
+}
+
+void TrackSlideCommand::undo_internal()
+{
+  slide_internal(true);
+}
+
+void TrackSlideCommand::slide_internal(bool undo)
+{
+  QMap<TrackOutput*, TimeRangeList> invalidate_ranges;
+
+  // Make sure all movement blocks' old positions are invalidated
+  foreach (const BlockSlideInfo& info, blocks_) {
+    if (info.mode == Timeline::kMove) {
+      invalidate_ranges[info.track].InsertTimeRange(TimeRange(info.block->in(),
+                                                              info.block->out()));
+    }
+  }
+
+  // Perform trims
+  foreach (const BlockSlideInfo& info, blocks_) {
+    info.track->BlockInvalidateCache();
+
+    if (info.mode == Timeline::kTrimIn || info.mode == Timeline::kTrimOut) {
+      rational new_len = undo ? info.old_time : info.new_time;
+
+      if (info.block->type() == Block::kClip) {
+        AudioVisualWaveform& waveform = static_cast<ClipBlock*>(info.block)->waveform();
+
+        if (new_len < info.block->length()) {
+          if (info.mode == Timeline::kTrimIn) {
+            waveform.TrimIn(info.block->length() - new_len);
+          } else {
+            waveform.TrimOut(info.block->length() - new_len);
+          }
+        } else {
+          if (info.mode == Timeline::kTrimIn) {
+            waveform.PrependSilence(new_len - info.block->length());
+          } else {
+            waveform.AppendSilence(new_len - info.block->length());
+          }
+        }
+      }
+
+      if (info.mode == Timeline::kTrimIn) {
+        info.block->set_length_and_media_in(new_len);
+      } else {
+        info.block->set_length_and_media_out(new_len);
+      }
+    } else if (!undo && info.mode == Timeline::kMove && !info.block->previous()) {
+      // If this is a moving block and there was nothing before it to offset its time correctly,
+      // insert a gap here
+      GapBlock* gap = new GapBlock();
+      gap->set_length_and_media_out(info.new_time);
+      static_cast<NodeGraph*>(info.block->parent())->AddNode(gap);
+      info.track->PrependBlock(gap);
+      added_gaps_.append(gap);
+    }
+
+    info.track->UnblockInvalidateCache();
+  }
+
+  if (undo) {
+    // If undoing, remove added gaps
+    foreach (GapBlock* gap, added_gaps_) {
+      TrackOutput* track = TrackOutput::TrackFromBlock(gap);
+
+      track->BlockInvalidateCache();
+
+      track->RippleRemoveBlock(gap);
+      TakeNodeFromParentGraph(gap);
+      delete gap;
+
+      track->UnblockInvalidateCache();
+    }
+
+    added_gaps_.clear();
+  }
+
+  // Make sure all movement blocks' new positions are invalidated
+  foreach (const BlockSlideInfo& info, blocks_) {
+    if (info.mode == Timeline::kMove) {
+      invalidate_ranges[info.track].InsertTimeRange(TimeRange(info.block->in(),
+                                                              info.block->out()));
+    }
+  }
+
+  QMap<TrackOutput*, TimeRangeList>::const_iterator i;
+  for (i=invalidate_ranges.constBegin(); i!=invalidate_ranges.constEnd(); i++) {
+    foreach (const TimeRange& r, i.value()) {
+      i.key()->InvalidateCache(r, i.key()->block_input(), i.key()->block_input());
+    }
+  }
+}
+
 OLIVE_NAMESPACE_EXIT
@@ -64,6 +64,35 @@ private:
  rational new_length_;
 };

+class BlockTrimCommand : public UndoCommand {
+public:
+  BlockTrimCommand(TrackOutput *track, Block* block, rational new_length, Timeline::MovementMode mode, QUndoCommand* command = nullptr);
+
+  virtual Project* GetRelevantProject() const override;
+
+  void SetAllowNonGapTrimming(bool e)
+  {
+    allow_nongap_trimming_ = e;
+  }
+
+protected:
+  virtual void redo_internal() override;
+  virtual void undo_internal() override;
+
+private:
+  TrackOutput* track_;
+  Block* block_;
+  rational old_length_;
+  rational new_length_;
+  Timeline::MovementMode mode_;
+
+  Block* adjacent_;
+  bool we_created_adjacent_;
+
+  bool allow_nongap_trimming_;
+
+};
+
 class BlockSetMediaInCommand : public UndoCommand {
 public:
  BlockSetMediaInCommand(Block* block, rational new_media_in, QUndoCommand* parent = nullptr);
@@ -168,6 +197,8 @@ protected:
  virtual void undo_internal() override;

 protected:
+  Project* project_;
+
  TrackOutput* track_;
  rational in_;
  rational out_;
@@ -203,6 +234,8 @@ class TrackPlaceBlockCommand : public TrackRippleRemoveAreaCommand {
 public:
  TrackPlaceBlockCommand(TrackList *timeline, int track, Block* block, rational in, QUndoCommand* parent = nullptr);

+  virtual Project* GetRelevantProject() const override;
+
 protected:
  virtual void redo_internal() override;
  virtual void undo_internal() override;
@@ -287,6 +320,29 @@ private:
  Block* replace_;
 };

+class TrackReplaceBlockWithGapCommand : public UndoCommand {
+public:
+  TrackReplaceBlockWithGapCommand(TrackOutput* track, Block* block, QUndoCommand* command = nullptr);
+
+  virtual Project* GetRelevantProject() const override;
+
+protected:
+  virtual void redo_internal() override;
+  virtual void undo_internal() override;
+
+private:
+  TrackOutput* track_;
+  Block* block_;
+
+  bool we_created_gap_;
+  GapBlock* gap_;
+  GapBlock* merged_gap_;
+
+  QObject memory_manager_;
+
+};
+
+/*
 class TrackCleanGapsCommand : public UndoCommand {
 public:
  TrackCleanGapsCommand(TrackList* track_list, int index, QUndoCommand* parent = nullptr);
@@ -315,6 +371,7 @@ private:
  QList<GapBlock*> removed_end_gaps_;

 };
+*/

 class TimelineRippleDeleteGapsAtRegionsCommand : public UndoCommand {
 public:
@@ -444,6 +501,32 @@ private:

 };

+class TrackSlideCommand : public UndoCommand {
+public:
+  struct BlockSlideInfo {
+    TrackOutput* track;
+    Block* block;
+    Timeline::MovementMode mode;
+    rational new_time;
+    rational old_time;
+  };
+
+  TrackSlideCommand(const QVector<BlockSlideInfo>& blocks, QUndoCommand* parent = nullptr);
+
+  virtual Project* GetRelevantProject() const override;
+
+protected:
+  virtual void redo_internal() override;
+  virtual void undo_internal() override;
+
+private:
+  void slide_internal(bool undo);
+
+  QVector<BlockSlideInfo> blocks_;
+  QList<GapBlock*> added_gaps_;
+
+};
+
 OLIVE_NAMESPACE_EXIT

 #endif // TIMELINEUNDOABLE_H
@@ -96,29 +96,11 @@ void TimelineViewBlockItem::paint(QPainter *painter, const QStyleOptionGraphicsI
    }

    // Draw waveform if one is available
-    QString wave_fn = QDir(QDir(Config::Current()["DiskCachePath"].toString()).filePath("waveform")).filePath(QString::number(reinterpret_cast<quintptr>(block_)));
-    QFile wave_file(wave_fn);
-    if (wave_file.open(QFile::ReadOnly)){
-      painter->setPen(QColor(64, 64, 64));
-
-      QByteArray w = wave_file.readAll();
-
-      wave_file.close();
-
-      // Read metadata
-      SampleSummer::Info info;
-      memcpy(&info, w.data(), sizeof(SampleSummer::Info));
-
-      // Prevent divide by zero
-      if (info.channels) {
-        AudioWaveformView::DrawWaveform(painter,
-                                        rect().toRect(),
-                                        this->GetScale(),
-                                        reinterpret_cast<const SampleSummer::Sum*>(w.constData() + sizeof(SampleSummer::Info)),
-                                        (w.size() - sizeof(SampleSummer::Info)) / sizeof(SampleSummer::Sum),
-                                        info.channels);
-      }
-    }
+    painter->setPen(QColor(64, 64, 64));
+    AudioVisualWaveform::DrawWaveform(painter,
+                                      rect().toRect(),
+                                      this->GetScale(),
+                                      static_cast<ClipBlock*>(block_)->waveform());

    painter->setPen(Qt::white);
    painter->drawLine(rect().topLeft(), QPointF(rect().right(), rect().top()));
@@ -23,8 +23,8 @@

 #include <QVariant>

-#include "common/timelinecommon.h"
 #include "project/item/footage/footage.h"
+#include "timeline/timelinecommon.h"
 #include "timelineviewblockitem.h"
 #include "timelineviewrect.h"

@@ -58,67 +58,6 @@ void AudioWaveformView::SetViewer(AudioPlaybackCache *playback)
  ForceUpdate();
 }

-void AudioWaveformView::DrawWaveform(QPainter *painter, const QRect& rect, const double& scale, const SampleSummer::Sum* samples, int nb_samples, int channels)
-{
-  int sample_index, next_sample_index = 0;
-
-  QVector<SampleSummer::Sum> summary;
-  int summary_index = -1;
-
-  int channel_height = rect.height() / channels;
-  int channel_half_height = channel_height / 2;
-
-  const QRect& viewport = painter->viewport();
-  QPoint top_left = painter->transform().map(viewport.topLeft());
-
-  int start = qMax(rect.x(), -top_left.x());
-  int end = qMin(rect.right(), -top_left.x() + viewport.width());
-
-  QVector<QLine> lines;
-
-  for (int i=start;i<end;i++) {
-    sample_index = next_sample_index;
-
-    if (sample_index == nb_samples) {
-      break;
-    }
-
-    next_sample_index = qMin(nb_samples,
-                             qFloor(static_cast<double>(SampleSummer::kSumSampleRate) * static_cast<double>(i - rect.x() + 1) / scale) * channels);
-
-    if (summary_index != sample_index) {
-      summary = SampleSummer::ReSumSamples(&samples[sample_index],
-                                           qMax(channels, next_sample_index - sample_index),
-                                           channels);
-      summary_index = sample_index;
-    }
-
-    int line_x = i;
-
-    for (int j=0;j<summary.size();j++) {
-      if (Config::Current()[QStringLiteral("RectifiedWaveforms")].toBool()) {
-        int channel_bottom = rect.y() + channel_height * (j + 1);
-
-        int diff = qRound((summary.at(j).max - summary.at(j).min) * channel_half_height);
-
-        lines.append(QLine(line_x,
-                           channel_bottom - diff,
-                           line_x,
-                           channel_bottom));
-      } else{
-        int channel_mid = rect.y() + channel_height * j + channel_half_height;
-
-        lines.append(QLine(line_x,
-                           channel_mid + clamp(qRound(summary.at(j).min * channel_half_height), -channel_half_height, channel_half_height),
-                           line_x,
-                           channel_mid + clamp(qRound(summary.at(j).max * channel_half_height), -channel_half_height, channel_half_height)));
-      }
-    }
-  }
-
-  painter->drawLines(lines);
-}
-
 void AudioWaveformView::paintEvent(QPaintEvent *event)
 {
  QWidget::paintEvent(event);
@@ -147,15 +86,11 @@ void AudioWaveformView::paintEvent(QPaintEvent *event)
      // FIXME: Hardcoded color
      wave_painter.setPen(QColor(64, 255, 160));

-      int channel_height = height() / params.channel_count();
-      int channel_half_height = channel_height / 2;
-
      int drew = 0;

      fs.seek(params.samples_to_bytes(ScreenToUnitRounded(0)));

      for (int x=0; x<width() && !fs.atEnd(); x++) {
-
        int samples_len = ScreenToUnitRounded(x+1) - ScreenToUnitRounded(x);
        int max_read_size = params.samples_to_bytes(samples_len);

@@ -166,28 +101,12 @@ void AudioWaveformView::paintEvent(QPaintEvent *event)
          samples_len = params.bytes_to_samples(read_buffer.size());
        }

-        QVector<SampleSummer::Sum> samples = SampleSummer::SumSamples(reinterpret_cast<const float*>(read_buffer.constData()),
-                                                                      samples_len,
-                                                                      params.channel_count());
+        QVector<AudioVisualWaveform::SamplePerChannel> samples = AudioVisualWaveform::SumSamples(reinterpret_cast<const float*>(read_buffer.constData()),
+                                                                                       samples_len,
+                                                                                       params.channel_count());

        for (int i=0;i<params.channel_count();i++) {
-          if (Config::Current()[QStringLiteral("RectifiedWaveforms")].toBool()) {
-            int channel_bottom = channel_height * (i + 1);
-
-            int diff = qRound((samples.at(i).max - samples.at(i).min) * channel_half_height);
-
-            wave_painter.drawLine(x,
-                                  channel_bottom - diff,
-                                  x,
-                                  channel_bottom);
-          } else {
-            int channel_mid = channel_height * i + channel_half_height;
-
-            wave_painter.drawLine(x,
-                                  channel_mid + qRound(samples.at(i).min * static_cast<float>(channel_half_height)),
-                                  x,
-                                  channel_mid + qRound(samples.at(i).max * static_cast<float>(channel_half_height)));
-          }
+          AudioVisualWaveform::DrawSample(&wave_painter, samples, x, 0, height());

          drew++;
        }
@@ -23,7 +23,7 @@

 #include <QWidget>

-#include "audio/sumsamples.h"
+#include "audio/audiovisualwaveform.h"
 #include "render/audioparams.h"
 #include "render/audioplaybackcache.h"
 #include "widget/timeruler/seekablewidget.h"
@@ -40,8 +40,6 @@ public:

  void SetViewer(AudioPlaybackCache *playback);

-  static void DrawWaveform(QPainter* painter, const QRect &rect, const double &scale, const SampleSummer::Sum *samples, int nb_samples, int channels);
-
 protected:
  virtual void paintEvent(QPaintEvent* event) override;