global: made every user action set a project "modified" state that will prevent

the main window from closing instantly

app/widget/keyframeview/keyframeviewundo.cpp

@@ -1,25 +1,25 @@
 #include "keyframeviewundo.h"
 
 KeyframeSetTypeCommand::KeyframeSetTypeCommand(NodeKeyframePtr key, NodeKeyframe::Type type, QUndoCommand *parent) :
-  QUndoCommand(parent),
+  UndoCommand(parent),
   key_(key),
   old_type_(key->type()),
   new_type_(type)
 {
 }
 
-void KeyframeSetTypeCommand::redo()
+void KeyframeSetTypeCommand::redo_internal()
 {
   key_->set_type(new_type_);
 }
 
-void KeyframeSetTypeCommand::undo()
+void KeyframeSetTypeCommand::undo_internal()
 {
   key_->set_type(old_type_);
 }
 
 KeyframeSetBezierControlPoint::KeyframeSetBezierControlPoint(NodeKeyframePtr key, NodeKeyframe::BezierType mode, const QPointF& point, QUndoCommand *parent) :
-  QUndoCommand(parent),
+  UndoCommand(parent),
   key_(key),
   mode_(mode),
   old_point_(key->bezier_control(mode_)),
@@ -28,7 +28,7 @@ KeyframeSetBezierControlPoint::KeyframeSetBezierControlPoint(NodeKeyframePtr key
 }
 
 KeyframeSetBezierControlPoint::KeyframeSetBezierControlPoint(NodeKeyframePtr key, NodeKeyframe::BezierType mode, const QPointF &new_point, const QPointF &old_point, QUndoCommand *parent) :
-  QUndoCommand(parent),
+  UndoCommand(parent),
   key_(key),
   mode_(mode),
   old_point_(old_point),
@@ -36,12 +36,12 @@ KeyframeSetBezierControlPoint::KeyframeSetBezierControlPoint(NodeKeyframePtr key
 {
 }
 
-void KeyframeSetBezierControlPoint::redo()
+void KeyframeSetBezierControlPoint::redo_internal()
 {
   key_->set_bezier_control(mode_, new_point_);
 }
 
-void KeyframeSetBezierControlPoint::undo()
+void KeyframeSetBezierControlPoint::undo_internal()
 {
   key_->set_bezier_control(mode_, old_point_);
 }

app/widget/keyframeview/keyframeviewundo.h

@@ -1,16 +1,16 @@
 #ifndef KEYFRAMEVIEWUNDO_H
 #define KEYFRAMEVIEWUNDO_H
 
-#include <QUndoCommand>
-
 #include "node/keyframe.h"
+#include "undo/undocommand.h"
 
-class KeyframeSetTypeCommand : public QUndoCommand {
+class KeyframeSetTypeCommand : public UndoCommand {
 public:
   KeyframeSetTypeCommand(NodeKeyframePtr key, NodeKeyframe::Type type, QUndoCommand* parent = nullptr);
 
-  virtual void redo() override;
-  virtual void undo() override;
+protected:
+  virtual void redo_internal() override;
+  virtual void undo_internal() override;
 
 private:
   NodeKeyframePtr key_;
@@ -21,13 +21,14 @@ private:
 
 };
 
-class KeyframeSetBezierControlPoint : public QUndoCommand {
+class KeyframeSetBezierControlPoint : public UndoCommand {
 public:
   KeyframeSetBezierControlPoint(NodeKeyframePtr key, NodeKeyframe::BezierType mode, const QPointF& point, QUndoCommand* parent = nullptr);
   KeyframeSetBezierControlPoint(NodeKeyframePtr key, NodeKeyframe::BezierType mode, const QPointF& new_point, const QPointF& old_point, QUndoCommand* parent = nullptr);
 
-  virtual void redo() override;
-  virtual void undo() override;
+protected:
+  virtual void redo_internal() override;
+  virtual void undo_internal() override;
 
 private:
   NodeKeyframePtr key_;

app/widget/nodeparamview/nodeparamviewundo.cpp

@@ -1,25 +1,25 @@
 #include "nodeparamviewundo.h"
 
 NodeParamSetKeyframingCommand::NodeParamSetKeyframingCommand(NodeInput *input, bool setting, QUndoCommand *parent) :
-  QUndoCommand(parent),
+  UndoCommand(parent),
   input_(input),
   setting_(setting)
 {
   Q_ASSERT(setting != input_->is_keyframing());
 }
 
-void NodeParamSetKeyframingCommand::redo()
+void NodeParamSetKeyframingCommand::redo_internal()
 {
   input_->set_is_keyframing(setting_);
 }
 
-void NodeParamSetKeyframingCommand::undo()
+void NodeParamSetKeyframingCommand::undo_internal()
 {
   input_->set_is_keyframing(!setting_);
 }
 
 NodeParamSetKeyframeValueCommand::NodeParamSetKeyframeValueCommand(NodeKeyframePtr key, const QVariant& value, QUndoCommand* parent) :
-  QUndoCommand(parent),
+  UndoCommand(parent),
   key_(key),
   old_value_(key_->value()),
   new_value_(value)
@@ -27,7 +27,7 @@ NodeParamSetKeyframeValueCommand::NodeParamSetKeyframeValueCommand(NodeKeyframeP
 }
 
 NodeParamSetKeyframeValueCommand::NodeParamSetKeyframeValueCommand(NodeKeyframePtr key, const QVariant &new_value, const QVariant &old_value, QUndoCommand *parent) :
-  QUndoCommand(parent),
+  UndoCommand(parent),
   key_(key),
   old_value_(old_value),
   new_value_(new_value)
@@ -35,18 +35,18 @@ NodeParamSetKeyframeValueCommand::NodeParamSetKeyframeValueCommand(NodeKeyframeP
 
 }
 
-void NodeParamSetKeyframeValueCommand::redo()
+void NodeParamSetKeyframeValueCommand::redo_internal()
 {
   key_->set_value(new_value_);
 }
 
-void NodeParamSetKeyframeValueCommand::undo()
+void NodeParamSetKeyframeValueCommand::undo_internal()
 {
   key_->set_value(old_value_);
 }
 
 NodeParamInsertKeyframeCommand::NodeParamInsertKeyframeCommand(NodeInput *input, NodeKeyframePtr keyframe, QUndoCommand* parent) :
-  QUndoCommand(parent),
+  UndoCommand(parent),
   input_(input),
   keyframe_(keyframe),
   done_(false)
@@ -54,45 +54,45 @@ NodeParamInsertKeyframeCommand::NodeParamInsertKeyframeCommand(NodeInput *input,
 }
 
 NodeParamInsertKeyframeCommand::NodeParamInsertKeyframeCommand(NodeInput *input, NodeKeyframePtr keyframe, bool already_done, QUndoCommand *parent) :
-  QUndoCommand(parent),
+  UndoCommand(parent),
   input_(input),
   keyframe_(keyframe),
   done_(already_done)
 {
 }
 
-void NodeParamInsertKeyframeCommand::redo()
+void NodeParamInsertKeyframeCommand::redo_internal()
 {
   if (!done_) {
     input_->insert_keyframe(keyframe_);
   }
 }
 
-void NodeParamInsertKeyframeCommand::undo()
+void NodeParamInsertKeyframeCommand::undo_internal()
 {
   input_->remove_keyframe(keyframe_);
   done_ = false;
 }
 
 NodeParamRemoveKeyframeCommand::NodeParamRemoveKeyframeCommand(NodeInput *input, NodeKeyframePtr keyframe, QUndoCommand *parent) :
-  QUndoCommand(parent),
+  UndoCommand(parent),
   input_(input),
   keyframe_(keyframe)
 {
 }
 
-void NodeParamRemoveKeyframeCommand::redo()
+void NodeParamRemoveKeyframeCommand::redo_internal()
 {
   input_->remove_keyframe(keyframe_);
 }
 
-void NodeParamRemoveKeyframeCommand::undo()
+void NodeParamRemoveKeyframeCommand::undo_internal()
 {
   input_->insert_keyframe(keyframe_);
 }
 
 NodeParamSetKeyframeTimeCommand::NodeParamSetKeyframeTimeCommand(NodeKeyframePtr key, const rational &time, QUndoCommand *parent) :
-  QUndoCommand(parent),
+  UndoCommand(parent),
   key_(key),
   old_time_(key->time()),
   new_time_(time)
@@ -100,25 +100,25 @@ NodeParamSetKeyframeTimeCommand::NodeParamSetKeyframeTimeCommand(NodeKeyframePtr
 }
 
 NodeParamSetKeyframeTimeCommand::NodeParamSetKeyframeTimeCommand(NodeKeyframePtr key, const rational &new_time, const rational &old_time, QUndoCommand *parent) :
-  QUndoCommand(parent),
+  UndoCommand(parent),
   key_(key),
   old_time_(old_time),
   new_time_(new_time)
 {
 }
 
-void NodeParamSetKeyframeTimeCommand::redo()
+void NodeParamSetKeyframeTimeCommand::redo_internal()
 {
   key_->set_time(new_time_);
 }
 
-void NodeParamSetKeyframeTimeCommand::undo()
+void NodeParamSetKeyframeTimeCommand::undo_internal()
 {
   key_->set_time(old_time_);
 }
 
 NodeParamSetStandardValueCommand::NodeParamSetStandardValueCommand(NodeInput *input, int track, const QVariant &value, QUndoCommand *parent) :
-  QUndoCommand(parent),
+  UndoCommand(parent),
   input_(input),
   track_(track),
   old_value_(input_->get_standard_value()),
@@ -127,7 +127,7 @@ NodeParamSetStandardValueCommand::NodeParamSetStandardValueCommand(NodeInput *in
 }
 
 NodeParamSetStandardValueCommand::NodeParamSetStandardValueCommand(NodeInput *input, int track, const QVariant &new_value, const QVariant &old_value, QUndoCommand *parent) :
-  QUndoCommand(parent),
+  UndoCommand(parent),
   input_(input),
   track_(track),
   old_value_(old_value),
@@ -135,12 +135,12 @@ NodeParamSetStandardValueCommand::NodeParamSetStandardValueCommand(NodeInput *in
 {
 }
 
-void NodeParamSetStandardValueCommand::redo()
+void NodeParamSetStandardValueCommand::redo_internal()
 {
   input_->set_standard_value(new_value_, track_);
 }
 
-void NodeParamSetStandardValueCommand::undo()
+void NodeParamSetStandardValueCommand::undo_internal()
 {
   input_->set_standard_value(old_value_, track_);
 }

app/widget/nodeparamview/nodeparamviewundo.h

@@ -1,29 +1,30 @@
 #ifndef NODEPARAMVIEWUNDO_H
 #define NODEPARAMVIEWUNDO_H
 
-#include <QUndoCommand>
-
 #include "node/input.h"
+#include "undo/undocommand.h"
 
-class NodeParamSetKeyframingCommand : public QUndoCommand {
+class NodeParamSetKeyframingCommand : public UndoCommand {
 public:
   NodeParamSetKeyframingCommand(NodeInput* input, bool setting, QUndoCommand* parent = nullptr);
 
-  virtual void redo() override;
-  virtual void undo() override;
+protected:
+  virtual void redo_internal() override;
+  virtual void undo_internal() override;
 
 private:
   NodeInput* input_;
   bool setting_;
 };
 
-class NodeParamInsertKeyframeCommand : public QUndoCommand {
+class NodeParamInsertKeyframeCommand : public UndoCommand {
 public:
   NodeParamInsertKeyframeCommand(NodeInput* input, NodeKeyframePtr keyframe, QUndoCommand *parent = nullptr);
   NodeParamInsertKeyframeCommand(NodeInput* input, NodeKeyframePtr keyframe, bool already_done, QUndoCommand *parent = nullptr);
 
-  virtual void redo() override;
-  virtual void undo() override;
+protected:
+  virtual void redo_internal() override;
+  virtual void undo_internal() override;
 
 private:
   NodeInput* input_;
@@ -34,12 +35,13 @@ private:
 
 };
 
-class NodeParamRemoveKeyframeCommand : public QUndoCommand {
+class NodeParamRemoveKeyframeCommand : public UndoCommand {
 public:
   NodeParamRemoveKeyframeCommand(NodeInput* input, NodeKeyframePtr keyframe, QUndoCommand *parent = nullptr);
 
-  virtual void redo() override;
-  virtual void undo() override;
+protected:
+  virtual void redo_internal() override;
+  virtual void undo_internal() override;
 
 private:
   NodeInput* input_;
@@ -48,13 +50,14 @@ private:
 
 };
 
-class NodeParamSetKeyframeTimeCommand : public QUndoCommand {
+class NodeParamSetKeyframeTimeCommand : public UndoCommand {
 public:
   NodeParamSetKeyframeTimeCommand(NodeKeyframePtr key, const rational& time, QUndoCommand* parent = nullptr);
   NodeParamSetKeyframeTimeCommand(NodeKeyframePtr key, const rational& new_time, const rational& old_time, QUndoCommand* parent = nullptr);
 
-  virtual void redo() override;
-  virtual void undo() override;
+protected:
+  virtual void redo_internal() override;
+  virtual void undo_internal() override;
 
 private:
   NodeKeyframePtr key_;
@@ -64,13 +67,14 @@ private:
 
 };
 
-class NodeParamSetKeyframeValueCommand : public QUndoCommand {
+class NodeParamSetKeyframeValueCommand : public UndoCommand {
 public:
   NodeParamSetKeyframeValueCommand(NodeKeyframePtr key, const QVariant& value, QUndoCommand* parent = nullptr);
   NodeParamSetKeyframeValueCommand(NodeKeyframePtr key, const QVariant& new_value, const QVariant& old_value, QUndoCommand* parent = nullptr);
 
-  virtual void redo() override;
-  virtual void undo() override;
+protected:
+  virtual void redo_internal() override;
+  virtual void undo_internal() override;
 
 private:
   NodeKeyframePtr key_;
@@ -80,13 +84,14 @@ private:
 
 };
 
-class NodeParamSetStandardValueCommand : public QUndoCommand {
+class NodeParamSetStandardValueCommand : public UndoCommand {
 public:
   NodeParamSetStandardValueCommand(NodeInput* input, int track, const QVariant& value, QUndoCommand* parent = nullptr);
   NodeParamSetStandardValueCommand(NodeInput* input, int track, const QVariant& new_value, const QVariant& old_value, QUndoCommand* parent = nullptr);
 
-  virtual void redo() override;
-  virtual void undo() override;
+protected:
+  virtual void redo_internal() override;
+  virtual void undo_internal() override;
 
 private:
   NodeInput* input_;

app/widget/nodeview/nodeviewundo.cpp

@@ -1,7 +1,7 @@
 #include "nodeviewundo.h"
 
 NodeEdgeAddCommand::NodeEdgeAddCommand(NodeOutput *output, NodeInput *input, QUndoCommand *parent) :
-  QUndoCommand(parent),
+  UndoCommand(parent),
   output_(output),
   input_(input),
   old_edge_(nullptr),
@@ -9,7 +9,7 @@ NodeEdgeAddCommand::NodeEdgeAddCommand(NodeOutput *output, NodeInput *input, QUn
 {
 }
 
-void NodeEdgeAddCommand::redo()
+void NodeEdgeAddCommand::redo_internal()
 {
   if (done_) {
     return;
@@ -22,7 +22,7 @@ void NodeEdgeAddCommand::redo()
   done_ = true;
 }
 
-void NodeEdgeAddCommand::undo()
+void NodeEdgeAddCommand::undo_internal()
 {
   if (!done_) {
     return;
@@ -38,7 +38,7 @@ void NodeEdgeAddCommand::undo()
 }
 
 NodeEdgeRemoveCommand::NodeEdgeRemoveCommand(NodeOutput *output, NodeInput *input, QUndoCommand *parent) :
-  QUndoCommand(parent),
+  UndoCommand(parent),
   output_(output),
   input_(input),
   done_(false)
@@ -46,14 +46,14 @@ NodeEdgeRemoveCommand::NodeEdgeRemoveCommand(NodeOutput *output, NodeInput *inpu
 }
 
 NodeEdgeRemoveCommand::NodeEdgeRemoveCommand(NodeEdgePtr edge, QUndoCommand *parent) :
-  QUndoCommand(parent),
+  UndoCommand(parent),
   output_(edge->output()),
   input_(edge->input()),
   done_(false)
 {
 }
 
-void NodeEdgeRemoveCommand::redo()
+void NodeEdgeRemoveCommand::redo_internal()
 {
   if (done_) {
     return;
@@ -63,7 +63,7 @@ void NodeEdgeRemoveCommand::redo()
   done_ = true;
 }
 
-void NodeEdgeRemoveCommand::undo()
+void NodeEdgeRemoveCommand::undo_internal()
 {
   if (!done_) {
     return;
@@ -74,7 +74,7 @@ void NodeEdgeRemoveCommand::undo()
 }
 
 NodeAddCommand::NodeAddCommand(NodeGraph *graph, Node *node, QUndoCommand *parent) :
-  QUndoCommand(parent),
+  UndoCommand(parent),
   graph_(graph),
   node_(node)
 {
@@ -82,24 +82,24 @@ NodeAddCommand::NodeAddCommand(NodeGraph *graph, Node *node, QUndoCommand *paren
   node_->setParent(&memory_manager_);
 }
 
-void NodeAddCommand::redo()
+void NodeAddCommand::redo_internal()
 {
   graph_->AddNode(node_);
 }
 
-void NodeAddCommand::undo()
+void NodeAddCommand::undo_internal()
 {
   graph_->TakeNode(node_, &memory_manager_);
 }
 
 NodeRemoveCommand::NodeRemoveCommand(NodeGraph *graph, const QList<Node *> &nodes, QUndoCommand *parent) :
-  QUndoCommand(parent),
+  UndoCommand(parent),
   graph_(graph),
   nodes_(nodes)
 {
 }
 
-void NodeRemoveCommand::redo()
+void NodeRemoveCommand::redo_internal()
 {
   // Cache edges for undoing
   foreach (Node* n, nodes_) {
@@ -119,7 +119,7 @@ void NodeRemoveCommand::redo()
   }
 }
 
-void NodeRemoveCommand::undo()
+void NodeRemoveCommand::undo_internal()
 {
   // Re-add nodes to graph
   foreach (Node* n, nodes_) {
@@ -135,7 +135,7 @@ void NodeRemoveCommand::undo()
 }
 
 NodeRemoveWithExclusiveDeps::NodeRemoveWithExclusiveDeps(NodeGraph *graph, Node *node, QUndoCommand *parent) :
-  QUndoCommand(parent)
+  UndoCommand(parent)
 {
   QList<Node*> node_and_its_deps;
   node_and_its_deps.append(node);
@@ -145,7 +145,7 @@ NodeRemoveWithExclusiveDeps::NodeRemoveWithExclusiveDeps(NodeGraph *graph, Node
 }
 
 NodeCopyInputsCommand::NodeCopyInputsCommand(Node *src, Node *dest, bool include_connections, QUndoCommand *parent) :
-  QUndoCommand(parent),
+  UndoCommand(parent),
   src_(src),
   dest_(dest),
   include_connections_(include_connections)
@@ -153,14 +153,14 @@ NodeCopyInputsCommand::NodeCopyInputsCommand(Node *src, Node *dest, bool include
 }
 
 NodeCopyInputsCommand::NodeCopyInputsCommand(Node *src, Node *dest, QUndoCommand *parent) :
-  QUndoCommand(parent),
+  UndoCommand(parent),
   src_(src),
   dest_(dest),
   include_connections_(true)
 {
 }
 
-void NodeCopyInputsCommand::redo()
+void NodeCopyInputsCommand::redo_internal()
 {
   Node::CopyInputs(src_, dest_, include_connections_);
 }

app/widget/nodeview/nodeviewundo.h

@@ -6,18 +6,20 @@
 #include "node/graph.h"
 #include "node/node.h"
 #include "nodeviewitem.h"
+#include "undo/undocommand.h"
 
 /**
  * @brief An undoable commnd for connecting two NodeParams together
  *
  * Can be considered a QUndoCommand wrapper for NodeParam::ConnectEdge()/
  */
-class NodeEdgeAddCommand : public QUndoCommand {
+class NodeEdgeAddCommand : public UndoCommand {
 public:
   NodeEdgeAddCommand(NodeOutput* output, NodeInput* input, QUndoCommand* parent = nullptr);
 
-  virtual void redo() override;
-  virtual void undo() override;
+protected:
+  virtual void redo_internal() override;
+  virtual void undo_internal() override;
 
 private:
   NodeOutput* output_;
@@ -33,13 +35,14 @@ private:
  *
  * Can be considered a QUndoCommand wrapper for NodeParam::DisonnectEdge()/
  */
-class NodeEdgeRemoveCommand : public QUndoCommand {
+class NodeEdgeRemoveCommand : public UndoCommand {
 public:
   NodeEdgeRemoveCommand(NodeOutput* output, NodeInput* input, QUndoCommand* parent = nullptr);
   NodeEdgeRemoveCommand(NodeEdgePtr edge, QUndoCommand* parent = nullptr);
 
-  virtual void redo() override;
-  virtual void undo() override;
+protected:
+  virtual void redo_internal() override;
+  virtual void undo_internal() override;
 
 private:
   NodeOutput* output_;
@@ -48,12 +51,13 @@ private:
   bool done_;
 };
 
-class NodeAddCommand : public QUndoCommand {
+class NodeAddCommand : public UndoCommand {
 public:
   NodeAddCommand(NodeGraph* graph, Node* node, QUndoCommand* parent = nullptr);
 
-  virtual void redo() override;
-  virtual void undo() override;
+protected:
+  virtual void redo_internal() override;
+  virtual void undo_internal() override;
 
 private:
   QObject memory_manager_;
@@ -62,14 +66,15 @@ private:
   Node* node_;
 };
 
-class NodeRemoveCommand : public QUndoCommand {
+class NodeRemoveCommand : public UndoCommand {
 public:
   NodeRemoveCommand(NodeGraph* graph,
                     const QList<Node*>& nodes,
                     QUndoCommand* parent = nullptr);
 
-  virtual void redo() override;
-  virtual void undo() override;
+protected:
+  virtual void redo_internal() override;
+  virtual void undo_internal() override;
 
 private:
   QObject memory_manager_;
@@ -79,7 +84,7 @@ private:
   QList<NodeEdgePtr> edges_;
 };
 
-class NodeRemoveWithExclusiveDeps : public QUndoCommand {
+class NodeRemoveWithExclusiveDeps : public UndoCommand {
 public:
   NodeRemoveWithExclusiveDeps(NodeGraph* graph,
                               Node* node,
@@ -89,7 +94,7 @@ private:
   NodeRemoveCommand* remove_command_;
 };
 
-class NodeCopyInputsCommand : public QUndoCommand {
+class NodeCopyInputsCommand : public UndoCommand {
 public:
   NodeCopyInputsCommand(Node* src,
                         Node* dest,
@@ -100,7 +105,8 @@ public:
                         Node* dest,
                         QUndoCommand* parent = nullptr);
 
-  virtual void redo() override;
+protected:
+  virtual void redo_internal() override;
 
 private:
   Node* src_;

app/widget/timelinewidget/tool/import.cpp

@@ -198,6 +198,7 @@ void TimelineWidget::ImportTool::DragDrop(TimelineViewMouseEvent *event)
 
         QMessageBox mbox(parent());
 
+        mbox.setIcon(QMessageBox::Question);
         mbox.setWindowTitle(tr("No Active Sequence"));
         mbox.setText(tr("No sequence is currently open. Would you like to create one?"));
         mbox.setCheckBox(dont_ask_again_box);

app/widget/timelinewidget/undo/undo.cpp

@@ -20,6 +20,7 @@
 
 #include "undo.h"
 
+#include "core.h"
 #include "node/graph.h"
 #include "node/block/transition/transition.h"
 
@@ -31,73 +32,73 @@ Node* TakeNodeFromParentGraph(Node* n, QObject* new_parent = nullptr)
 }
 
 BlockResizeCommand::BlockResizeCommand(Block *block, rational new_length, QUndoCommand* parent) :
-  QUndoCommand(parent),
+  UndoCommand(parent),
   block_(block),
   old_length_(block->length()),
   new_length_(new_length)
 {
 }
 
-void BlockResizeCommand::redo()
+void BlockResizeCommand::redo_internal()
 {
   block_->set_length_and_media_out(new_length_);
 }
 
-void BlockResizeCommand::undo()
+void BlockResizeCommand::undo_internal()
 {
   block_->set_length_and_media_out(old_length_);
 }
 
 BlockResizeWithMediaInCommand::BlockResizeWithMediaInCommand(Block *block, rational new_length, QUndoCommand *parent) :
-  QUndoCommand(parent),
+  UndoCommand(parent),
   block_(block),
   old_length_(block->length()),
   new_length_(new_length)
 {
 }
 
-void BlockResizeWithMediaInCommand::redo()
+void BlockResizeWithMediaInCommand::redo_internal()
 {
   block_->set_length_and_media_in(new_length_);
 }
 
-void BlockResizeWithMediaInCommand::undo()
+void BlockResizeWithMediaInCommand::undo_internal()
 {
   block_->set_length_and_media_in(old_length_);
 }
 
 BlockSetMediaInCommand::BlockSetMediaInCommand(Block *block, rational new_media_in, QUndoCommand* parent) :
-  QUndoCommand(parent),
+  UndoCommand(parent),
   block_(block),
   old_media_in_(block->media_in()),
   new_media_in_(new_media_in)
 {
 }
 
-void BlockSetMediaInCommand::redo()
+void BlockSetMediaInCommand::redo_internal()
 {
   block_->set_media_in(new_media_in_);
 }
 
-void BlockSetMediaInCommand::undo()
+void BlockSetMediaInCommand::undo_internal()
 {
   block_->set_media_in(old_media_in_);
 }
 
 TrackRippleRemoveBlockCommand::TrackRippleRemoveBlockCommand(TrackOutput *track, Block *block, QUndoCommand *parent) :
-  QUndoCommand(parent),
+  UndoCommand(parent),
   track_(track),
   block_(block)
 {
 }
 
-void TrackRippleRemoveBlockCommand::redo()
+void TrackRippleRemoveBlockCommand::redo_internal()
 {
   before_ = block_->previous();
   track_->RippleRemoveBlock(block_);
 }
 
-void TrackRippleRemoveBlockCommand::undo()
+void TrackRippleRemoveBlockCommand::undo_internal()
 {
   if (before_) {
     track_->InsertBlockAfter(block_, before_);
@@ -110,25 +111,25 @@ TrackInsertBlockAfterCommand::TrackInsertBlockAfterCommand(TrackOutput *track,
                                                                            Block *block,
                                                                            Block *before,
                                                                            QUndoCommand *parent) :
-  QUndoCommand(parent),
+  UndoCommand(parent),
   track_(track),
   block_(block),
   before_(before)
 {
 }
 
-void TrackInsertBlockAfterCommand::redo()
+void TrackInsertBlockAfterCommand::redo_internal()
 {
   track_->InsertBlockAfter(block_, before_);
 }
 
-void TrackInsertBlockAfterCommand::undo()
+void TrackInsertBlockAfterCommand::undo_internal()
 {
   track_->RippleRemoveBlock(block_);
 }
 
 TrackRippleRemoveAreaCommand::TrackRippleRemoveAreaCommand(TrackOutput *track, rational in, rational out, QUndoCommand *parent) :
-  QUndoCommand(parent),
+  UndoCommand(parent),
   track_(track),
   in_(in),
   out_(out),
@@ -144,7 +145,7 @@ void TrackRippleRemoveAreaCommand::SetInsert(Block *insert)
   insert_ = insert;
 }
 
-void TrackRippleRemoveAreaCommand::redo()
+void TrackRippleRemoveAreaCommand::redo_internal()
 {
   // Iterate through blocks determining which need trimming/removing/splitting
   foreach (Block* block, track_->Blocks()) {
@@ -237,7 +238,7 @@ void TrackRippleRemoveAreaCommand::redo()
   track_->InvalidateCache(in_, insert_ ? out_ : RATIONAL_MAX);
 }
 
-void TrackRippleRemoveAreaCommand::undo()
+void TrackRippleRemoveAreaCommand::undo_internal()
 {
   track_->BlockInvalidateCache();
 
@@ -291,7 +292,7 @@ TrackPlaceBlockCommand::TrackPlaceBlockCommand(TrackList *timeline, int track, B
   insert_ = block;
 }
 
-void TrackPlaceBlockCommand::redo()
+void TrackPlaceBlockCommand::redo_internal()
 {
   added_track_count_ = 0;
 
@@ -321,11 +322,11 @@ void TrackPlaceBlockCommand::redo()
     out_ = in_ + insert_->length();
 
     // Place the Block at this point
-    TrackRippleRemoveAreaCommand::redo();
+    TrackRippleRemoveAreaCommand::redo_internal();
   }
 }
 
-void TrackPlaceBlockCommand::undo()
+void TrackPlaceBlockCommand::undo_internal()
 {
   if (append_) {
     track_->RippleRemoveBlock(insert_);
@@ -335,7 +336,7 @@ void TrackPlaceBlockCommand::undo()
       delete TakeNodeFromParentGraph(gap_);
     }
   } else {
-    TrackRippleRemoveAreaCommand::undo();
+    TrackRippleRemoveAreaCommand::undo_internal();
   }
 
   for (;added_track_count_>0;added_track_count_--) {
@@ -344,7 +345,7 @@ void TrackPlaceBlockCommand::undo()
 }
 
 BlockSplitCommand::BlockSplitCommand(TrackOutput* track, Block *block, rational point, QUndoCommand *parent) :
-  QUndoCommand(parent),
+  UndoCommand(parent),
   track_(track),
   block_(block),
   new_length_(point - block->in()),
@@ -367,7 +368,7 @@ BlockSplitCommand::BlockSplitCommand(TrackOutput* track, Block *block, rational
   }
 }
 
-void BlockSplitCommand::redo()
+void BlockSplitCommand::redo_internal()
 {
   track_->BlockInvalidateCache();
 
@@ -390,7 +391,7 @@ void BlockSplitCommand::redo()
   track_->UnblockInvalidateCache();
 }
 
-void BlockSplitCommand::undo()
+void BlockSplitCommand::undo_internal()
 {
   track_->BlockInvalidateCache();
 
@@ -413,7 +414,7 @@ Block *BlockSplitCommand::new_block()
 }
 
 TrackSplitAtTimeCommand::TrackSplitAtTimeCommand(TrackOutput *track, rational point, QUndoCommand *parent) :
-  QUndoCommand(parent)
+  UndoCommand(parent)
 {
   // Find Block that contains this time
   foreach (Block* b, track->Blocks()) {
@@ -429,42 +430,42 @@ TrackSplitAtTimeCommand::TrackSplitAtTimeCommand(TrackOutput *track, rational po
 }
 
 TrackReplaceBlockCommand::TrackReplaceBlockCommand(TrackOutput* track, Block *old, Block *replace, QUndoCommand *parent) :
-  QUndoCommand(parent),
+  UndoCommand(parent),
   track_(track),
   old_(old),
   replace_(replace)
 {
 }
 
-void TrackReplaceBlockCommand::redo()
+void TrackReplaceBlockCommand::redo_internal()
 {
   track_->ReplaceBlock(old_, replace_);
 }
 
-void TrackReplaceBlockCommand::undo()
+void TrackReplaceBlockCommand::undo_internal()
 {
   track_->ReplaceBlock(replace_, old_);
 }
 
 TrackPrependBlockCommand::TrackPrependBlockCommand(TrackOutput *track, Block *block, QUndoCommand *parent) :
-  QUndoCommand(parent),
+  UndoCommand(parent),
   track_(track),
   block_(block)
 {
 }
 
-void TrackPrependBlockCommand::redo()
+void TrackPrependBlockCommand::redo_internal()
 {
   track_->PrependBlock(block_);
 }
 
-void TrackPrependBlockCommand::undo()
+void TrackPrependBlockCommand::undo_internal()
 {
   track_->RippleRemoveBlock(block_);
 }
 
 BlockSplitPreservingLinksCommand::BlockSplitPreservingLinksCommand(const QVector<Block *> &blocks, const QList<rational> &times, QUndoCommand *parent) :
-  QUndoCommand(parent),
+  UndoCommand(parent),
   blocks_(blocks),
   times_(times)
 {
@@ -516,13 +517,13 @@ BlockSplitPreservingLinksCommand::BlockSplitPreservingLinksCommand(const QVector
 }
 
 TrackCleanGapsCommand::TrackCleanGapsCommand(TrackList *track_list, int index, QUndoCommand *parent) :
-  QUndoCommand(parent),
+  UndoCommand(parent),
   track_list_(track_list),
   track_index_(index)
 {
 }
 
-void TrackCleanGapsCommand::redo()
+void TrackCleanGapsCommand::redo_internal()
 {
   GapBlock* on_gap = nullptr;
   QList<GapBlock*> consecutive_gaps;
@@ -572,7 +573,7 @@ void TrackCleanGapsCommand::redo()
   }
 }
 
-void TrackCleanGapsCommand::undo()
+void TrackCleanGapsCommand::undo_internal()
 {
   TrackOutput* track = track_list_->TrackAt(track_index_);
 
@@ -605,19 +606,19 @@ void TrackCleanGapsCommand::undo()
 }
 
 BlockSetSpeedCommand::BlockSetSpeedCommand(Block *block, const rational &new_speed, QUndoCommand *parent) :
-  QUndoCommand(parent),
+  UndoCommand(parent),
   block_(block),
   old_speed_(block->speed()),
   new_speed_(new_speed)
 {
 }
 
-void BlockSetSpeedCommand::redo()
+void BlockSetSpeedCommand::redo_internal()
 {
   block_->set_speed(new_speed_);
 }
 
-void BlockSetSpeedCommand::undo()
+void BlockSetSpeedCommand::undo_internal()
 {
   block_->set_speed(old_speed_);
 }

app/widget/timelinewidget/undo/undo.h

@@ -27,13 +27,15 @@
 #include "node/block/gap/gap.h"
 #include "node/output/track/track.h"
 #include "node/output/track/tracklist.h"
+#include "undo/undocommand.h"
 
-class BlockResizeCommand : public QUndoCommand {
+class BlockResizeCommand : public UndoCommand {
 public:
   BlockResizeCommand(Block* block, rational new_length, QUndoCommand* parent = nullptr);
 
-  virtual void redo() override;
-  virtual void undo() override;
+protected:
+  virtual void redo_internal() override;
+  virtual void undo_internal() override;
 
 private:
   Block* block_;
@@ -41,12 +43,13 @@ private:
   rational new_length_;
 };
 
-class BlockResizeWithMediaInCommand : public QUndoCommand {
+class BlockResizeWithMediaInCommand : public UndoCommand {
 public:
   BlockResizeWithMediaInCommand(Block* block, rational new_length, QUndoCommand* parent = nullptr);
 
-  virtual void redo() override;
-  virtual void undo() override;
+protected:
+  virtual void redo_internal() override;
+  virtual void undo_internal() override;
 
 private:
   Block* block_;
@@ -54,12 +57,13 @@ private:
   rational new_length_;
 };
 
-class BlockSetMediaInCommand : public QUndoCommand {
+class BlockSetMediaInCommand : public UndoCommand {
 public:
   BlockSetMediaInCommand(Block* block, rational new_media_in, QUndoCommand* parent = nullptr);
 
-  virtual void redo() override;
-  virtual void undo() override;
+protected:
+  virtual void redo_internal() override;
+  virtual void undo_internal() override;
 
 private:
   Block* block_;
@@ -67,12 +71,13 @@ private:
   rational new_media_in_;
 };
 
-class BlockSetSpeedCommand : public QUndoCommand {
+class BlockSetSpeedCommand : public UndoCommand {
 public:
   BlockSetSpeedCommand(Block* block, const rational& new_speed, QUndoCommand* parent = nullptr);
 
-  virtual void redo() override;
-  virtual void undo() override;
+protected:
+  virtual void redo_internal() override;
+  virtual void undo_internal() override;
 
 private:
   Block* block_;
@@ -81,12 +86,13 @@ private:
   rational new_speed_;
 };
 
-class TrackRippleRemoveBlockCommand : public QUndoCommand {
+class TrackRippleRemoveBlockCommand : public UndoCommand {
 public:
   TrackRippleRemoveBlockCommand(TrackOutput* track, Block* block, QUndoCommand* parent = nullptr);
 
-  virtual void redo() override;
-  virtual void undo() override;
+protected:
+  virtual void redo_internal() override;
+  virtual void undo_internal() override;
 
 private:
   TrackOutput* track_;
@@ -96,24 +102,26 @@ private:
   Block* before_;
 };
 
-class TrackPrependBlockCommand : public QUndoCommand {
+class TrackPrependBlockCommand : public UndoCommand {
 public:
   TrackPrependBlockCommand(TrackOutput* track, Block* block, QUndoCommand* parent = nullptr);
 
-  virtual void redo() override;
-  virtual void undo() override;
+protected:
+  virtual void redo_internal() override;
+  virtual void undo_internal() override;
 
 private:
   TrackOutput* track_;
   Block* block_;
 };
 
-class TrackInsertBlockAfterCommand : public QUndoCommand {
+class TrackInsertBlockAfterCommand : public UndoCommand {
 public:
   TrackInsertBlockAfterCommand(TrackOutput* track, Block* block, Block* before, QUndoCommand* parent = nullptr);
 
-  virtual void redo() override;
-  virtual void undo() override;
+protected:
+  virtual void redo_internal() override;
+  virtual void undo_internal() override;
 
 private:
   TrackOutput* track_;
@@ -130,14 +138,15 @@ private:
  * By default, nothing takes this area meaning all subsequent clips are pushed backward, however you can specify
  * a block to insert at the `in` point. No checking is done to ensure `insert` is the same length as `in` to `out`.
  */
-class TrackRippleRemoveAreaCommand : public QUndoCommand {
+class TrackRippleRemoveAreaCommand : public UndoCommand {
 public:
   TrackRippleRemoveAreaCommand(TrackOutput* track, rational in, rational out, QUndoCommand* parent = nullptr);
 
   void SetInsert(Block* insert);
 
-  virtual void redo() override;
-  virtual void undo() override;
+protected:
+  virtual void redo_internal() override;
+  virtual void undo_internal() override;
 
 protected:
   TrackOutput* track_;
@@ -172,8 +181,9 @@ class TrackPlaceBlockCommand : public TrackRippleRemoveAreaCommand {
 public:
   TrackPlaceBlockCommand(TrackList *timeline, int track, Block* block, rational in, QUndoCommand* parent = nullptr);
 
-  virtual void redo() override;
-  virtual void undo() override;
+protected:
+  virtual void redo_internal() override;
+  virtual void undo_internal() override;
 
 private:
   TrackList* timeline_;
@@ -183,15 +193,16 @@ private:
   int added_track_count_;
 };
 
-class BlockSplitCommand : public QUndoCommand {
+class BlockSplitCommand : public UndoCommand {
 public:
   BlockSplitCommand(TrackOutput* track, Block* block, rational point, QUndoCommand* parent = nullptr);
 
-  virtual void redo() override;
-  virtual void undo() override;
-
   Block* new_block();
 
+protected:
+  virtual void redo_internal() override;
+  virtual void undo_internal() override;
+
 private:
   TrackOutput* track_;
   Block* block_;
@@ -208,12 +219,12 @@ private:
 
 };
 
-class TrackSplitAtTimeCommand : public QUndoCommand {
+class TrackSplitAtTimeCommand : public UndoCommand {
 public:
   TrackSplitAtTimeCommand(TrackOutput* track, rational point, QUndoCommand* parent = nullptr);
 };
 
-class BlockSplitPreservingLinksCommand : public QUndoCommand {
+class BlockSplitPreservingLinksCommand : public UndoCommand {
 public:
   BlockSplitPreservingLinksCommand(const QVector<Block *> &blocks, const QList<rational>& times, QUndoCommand* parent = nullptr);
 
@@ -228,12 +239,13 @@ private:
  *
  * Both blocks must have equal lengths.
  */
-class TrackReplaceBlockCommand : public QUndoCommand {
+class TrackReplaceBlockCommand : public UndoCommand {
 public:
   TrackReplaceBlockCommand(TrackOutput* track, Block* old, Block* replace, QUndoCommand* parent = nullptr);
 
-  virtual void redo() override;
-  virtual void undo() override;
+protected:
+  virtual void redo_internal() override;
+  virtual void undo_internal() override;
 
 private:
   TrackOutput* track_;
@@ -241,12 +253,13 @@ private:
   Block* replace_;
 };
 
-class TrackCleanGapsCommand : public QUndoCommand {
+class TrackCleanGapsCommand : public UndoCommand {
 public:
   TrackCleanGapsCommand(TrackList* track_list, int index, QUndoCommand* parent = nullptr);
 
-  virtual void redo() override;
-  virtual void undo() override;
+protected:
+  virtual void redo_internal() override;
+  virtual void undo_internal() override;
 
 private:
   struct MergedGap {