From baf3fbde0586904fba1d313ad1218342bae00cd1 Mon Sep 17 00:00:00 2001 From: itsmattkc Date: Tue, 3 Mar 2020 14:33:45 +1100 Subject: [PATCH] global: made every user action set a project "modified" state that will prevent the main window from closing instantly --- app/core.cpp | 36 ++++++-- app/core.h | 10 ++- .../footageproperties/footageproperties.cpp | 12 +-- .../footageproperties/footageproperties.h | 16 ++-- .../videostreamproperties.cpp | 6 +- .../streamproperties/videostreamproperties.h | 9 +- app/dialog/sequence/sequence.cpp | 6 +- app/dialog/sequence/sequence.h | 10 ++- app/dialog/speedduration/speedduration.cpp | 8 +- app/dialog/speedduration/speedduration.h | 9 +- app/project/projectviewmodel.cpp | 18 ++-- app/project/projectviewmodel.h | 23 ++--- app/undo/CMakeLists.txt | 2 + app/undo/undocommand.cpp | 33 +++++++ app/undo/undocommand.h | 23 +++++ app/widget/keyframeview/keyframeviewundo.cpp | 14 +-- app/widget/keyframeview/keyframeviewundo.h | 17 ++-- .../nodeparamview/nodeparamviewundo.cpp | 44 ++++----- app/widget/nodeparamview/nodeparamviewundo.h | 45 +++++----- app/widget/nodeview/nodeviewundo.cpp | 34 +++---- app/widget/nodeview/nodeviewundo.h | 36 ++++---- app/widget/timelinewidget/tool/import.cpp | 1 + app/widget/timelinewidget/undo/undo.cpp | 79 ++++++++-------- app/widget/timelinewidget/undo/undo.h | 89 +++++++++++-------- app/window/mainwindow/mainwindow.cpp | 35 ++++++-- 25 files changed, 377 insertions(+), 238 deletions(-) create mode 100644 app/undo/undocommand.cpp create mode 100644 app/undo/undocommand.h diff --git a/app/core.cpp b/app/core.cpp index f0c522406..e87e1d755 100644 --- a/app/core.cpp +++ b/app/core.cpp @@ -351,7 +351,7 @@ void Core::ImportTaskComplete(QUndoCommand *command) bool Core::ConfirmImageSequence(const QString& filename) { - QMessageBox mb; + QMessageBox mb(main_window_); mb.setIcon(QMessageBox::Question); mb.setWindowTitle(tr("Possible image sequence detected")); @@ -429,6 +429,8 @@ void Core::SaveProjectInternal(Project *project) // Create save manager ProjectSaveManager* psm = new ProjectSaveManager(project); + connect(psm, &Task::Succeeded, this, &Core::ProjectSaveSucceeded); + TaskDialog* task_dialog = new TaskDialog(psm, tr("Save Project"), main_window()); task_dialog->open(); } @@ -442,6 +444,11 @@ void Core::SaveAutorecovery() } } +void Core::ProjectSaveSucceeded() +{ + SetProjectModified(false); +} + Project *Core::GetActiveProject() { ProjectPanel* active_project_panel = PanelManager::instance()->MostRecentlyFocused(); @@ -475,10 +482,15 @@ Folder *Core::GetSelectedFolderInActiveProject() } } -void Core::SetProjectModified() +void Core::SetProjectModified(bool e) { - main_window()->setWindowModified(true); - queue_autorecovery_ = true; + main_window()->setWindowModified(e); + queue_autorecovery_ = e; +} + +bool Core::IsProjectModified() const +{ + return main_window_->isWindowModified(); } void Core::SetAutorecoveryInterval(int minutes) @@ -487,27 +499,29 @@ void Core::SetAutorecoveryInterval(int minutes) autorecovery_timer_.setInterval(minutes * 60000); } -void Core::SaveActiveProject() +bool Core::SaveActiveProject() { Project* active_project = GetActiveProject(); if (!active_project) { - return; + return false; } if (active_project->filename().isEmpty()) { - SaveActiveProjectAs(); + return SaveActiveProjectAs(); } else { SaveProjectInternal(active_project); + + return true; } } -void Core::SaveActiveProjectAs() +bool Core::SaveActiveProjectAs() { Project* active_project = GetActiveProject(); if (!active_project) { - return; + return false; } QString fn = QFileDialog::getSaveFileName(main_window_, @@ -519,7 +533,11 @@ void Core::SaveActiveProjectAs() active_project->set_filename(fn); SaveProjectInternal(active_project); + + return true; } + + return false; } QList Core::SupportedFrameRates() diff --git a/app/core.h b/app/core.h index a15f13200..9fdb85501 100644 --- a/app/core.h +++ b/app/core.h @@ -131,7 +131,9 @@ public: * Call this function whenever a change is made to a currently active project. Saving the project will automatically * unset this. */ - void SetProjectModified(); + void SetProjectModified(bool e); + + bool IsProjectModified() const; /** * @brief Set how frequently an autorecovery should be saved (if the project has changed, see SetProjectModified()) @@ -193,12 +195,12 @@ public slots: * * If the project hasn't been saved before, this will be equivalent to calling SaveActiveProjectAs(). */ - void SaveActiveProject(); + bool SaveActiveProject(); /** * @brief Save the currently active project with a new filename */ - void SaveActiveProjectAs(); + bool SaveActiveProjectAs(); /** * @brief Set the current application-wide tool @@ -353,6 +355,8 @@ private: private slots: void SaveAutorecovery(); + void ProjectSaveSucceeded(); + /** * @brief Adds a project to the "open projects" list */ diff --git a/app/dialog/footageproperties/footageproperties.cpp b/app/dialog/footageproperties/footageproperties.cpp index 8d03875eb..fa5063540 100644 --- a/app/dialog/footageproperties/footageproperties.cpp +++ b/app/dialog/footageproperties/footageproperties.cpp @@ -124,38 +124,38 @@ void FootagePropertiesDialog::accept() { } FootagePropertiesDialog::FootageChangeCommand::FootageChangeCommand(Footage *footage, const QString &name, QUndoCommand* command) : - QUndoCommand(command), + UndoCommand(command), footage_(footage), new_name_(name) { } -void FootagePropertiesDialog::FootageChangeCommand::redo() +void FootagePropertiesDialog::FootageChangeCommand::redo_internal() { old_name_ = footage_->name(); footage_->set_name(new_name_); } -void FootagePropertiesDialog::FootageChangeCommand::undo() +void FootagePropertiesDialog::FootageChangeCommand::undo_internal() { footage_->set_name(old_name_); } FootagePropertiesDialog::StreamEnableChangeCommand::StreamEnableChangeCommand(StreamPtr stream, bool enabled, QUndoCommand *command) : - QUndoCommand(command), + UndoCommand(command), stream_(stream), old_enabled_(stream->enabled()), new_enabled_(enabled) { } -void FootagePropertiesDialog::StreamEnableChangeCommand::redo() +void FootagePropertiesDialog::StreamEnableChangeCommand::redo_internal() { stream_->set_enabled(new_enabled_); } -void FootagePropertiesDialog::StreamEnableChangeCommand::undo() +void FootagePropertiesDialog::StreamEnableChangeCommand::undo_internal() { stream_->set_enabled(old_enabled_); } diff --git a/app/dialog/footageproperties/footageproperties.h b/app/dialog/footageproperties/footageproperties.h index 65af1baf8..2cc39d78f 100644 --- a/app/dialog/footageproperties/footageproperties.h +++ b/app/dialog/footageproperties/footageproperties.h @@ -28,9 +28,9 @@ #include #include #include -#include #include "project/item/footage/footage.h" +#include "undo/undocommand.h" /** * @brief The MediaPropertiesDialog class @@ -54,14 +54,15 @@ public: */ FootagePropertiesDialog(QWidget *parent, Footage* footage); private: - class FootageChangeCommand : public QUndoCommand { + class FootageChangeCommand : public UndoCommand { public: FootageChangeCommand(Footage* footage, const QString& name, QUndoCommand *command = nullptr); - virtual void redo() override; - virtual void undo() override; + protected: + virtual void redo_internal() override; + virtual void undo_internal() override; private: Footage* footage_; @@ -70,14 +71,15 @@ private: QString old_name_; }; - class StreamEnableChangeCommand : public QUndoCommand { + class StreamEnableChangeCommand : public UndoCommand { public: StreamEnableChangeCommand(StreamPtr stream, bool enabled, QUndoCommand* command = nullptr); - virtual void redo() override; - virtual void undo() override; + protected: + virtual void redo_internal() override; + virtual void undo_internal() override; private: StreamPtr stream_; diff --git a/app/dialog/footageproperties/streamproperties/videostreamproperties.cpp b/app/dialog/footageproperties/streamproperties/videostreamproperties.cpp index 3ec6d6d39..333879e67 100644 --- a/app/dialog/footageproperties/streamproperties/videostreamproperties.cpp +++ b/app/dialog/footageproperties/streamproperties/videostreamproperties.cpp @@ -71,14 +71,14 @@ VideoStreamProperties::VideoStreamChangeCommand::VideoStreamChangeCommand(ImageS bool premultiplied, QString colorspace, QUndoCommand *parent) : - QUndoCommand(parent), + UndoCommand(parent), stream_(stream), new_premultiplied_(premultiplied), new_colorspace_(colorspace) { } -void VideoStreamProperties::VideoStreamChangeCommand::redo() +void VideoStreamProperties::VideoStreamChangeCommand::redo_internal() { old_premultiplied_ = stream_->premultiplied_alpha(); old_colorspace_ = stream_->colorspace(); @@ -87,7 +87,7 @@ void VideoStreamProperties::VideoStreamChangeCommand::redo() stream_->set_colorspace(new_colorspace_); } -void VideoStreamProperties::VideoStreamChangeCommand::undo() +void VideoStreamProperties::VideoStreamChangeCommand::undo_internal() { stream_->set_premultiplied_alpha(old_premultiplied_); stream_->set_colorspace(old_colorspace_); diff --git a/app/dialog/footageproperties/streamproperties/videostreamproperties.h b/app/dialog/footageproperties/streamproperties/videostreamproperties.h index 080e83f5b..e59bfb84f 100644 --- a/app/dialog/footageproperties/streamproperties/videostreamproperties.h +++ b/app/dialog/footageproperties/streamproperties/videostreamproperties.h @@ -23,10 +23,10 @@ #include #include -#include #include "project/item/footage/videostream.h" #include "streamproperties.h" +#include "undo/undocommand.h" class VideoStreamProperties : public StreamProperties { @@ -51,15 +51,16 @@ private: */ QComboBox* video_color_space_; - class VideoStreamChangeCommand : public QUndoCommand { + class VideoStreamChangeCommand : public UndoCommand { public: VideoStreamChangeCommand(ImageStreamPtr stream, bool premultiplied, QString colorspace, QUndoCommand* parent = nullptr); - virtual void redo() override; - virtual void undo() override; + protected: + virtual void redo_internal() override; + virtual void undo_internal() override; private: ImageStreamPtr stream_; diff --git a/app/dialog/sequence/sequence.cpp b/app/dialog/sequence/sequence.cpp index 630418dc6..9b0f91f29 100644 --- a/app/dialog/sequence/sequence.cpp +++ b/app/dialog/sequence/sequence.cpp @@ -198,7 +198,7 @@ SequenceDialog::SequenceParamCommand::SequenceParamCommand(Sequence* s, const AudioParams& audio_params, const QString& name, QUndoCommand* parent) : - QUndoCommand(parent), + UndoCommand(parent), sequence_(s), new_video_params_(video_params), new_audio_params_(audio_params), @@ -209,14 +209,14 @@ SequenceDialog::SequenceParamCommand::SequenceParamCommand(Sequence* s, { } -void SequenceDialog::SequenceParamCommand::redo() +void SequenceDialog::SequenceParamCommand::redo_internal() { sequence_->set_video_params(new_video_params_); sequence_->set_audio_params(new_audio_params_); sequence_->set_name(new_name_); } -void SequenceDialog::SequenceParamCommand::undo() +void SequenceDialog::SequenceParamCommand::undo_internal() { sequence_->set_video_params(old_video_params_); sequence_->set_audio_params(old_audio_params_); diff --git a/app/dialog/sequence/sequence.h b/app/dialog/sequence/sequence.h index a9844b21b..470803bfb 100644 --- a/app/dialog/sequence/sequence.h +++ b/app/dialog/sequence/sequence.h @@ -24,9 +24,9 @@ #include #include #include -#include #include "project/item/sequence/sequence.h" +#include "undo/undocommand.h" /** * @brief A dialog for editing Sequence parameters @@ -112,7 +112,7 @@ private: /** * @brief A QUndoCommand for setting the parameters on a sequence */ - class SequenceParamCommand : public QUndoCommand { + class SequenceParamCommand : public UndoCommand { public: SequenceParamCommand(Sequence* s, const VideoParams& video_params, @@ -120,8 +120,10 @@ private: const QString& name, QUndoCommand* parent = nullptr); - virtual void redo() override; - virtual void undo() override; + protected: + virtual void redo_internal() override; + virtual void undo_internal() override; + private: Sequence* sequence_; diff --git a/app/dialog/speedduration/speedduration.cpp b/app/dialog/speedduration/speedduration.cpp index 7ad38dac3..2bfa47434 100644 --- a/app/dialog/speedduration/speedduration.cpp +++ b/app/dialog/speedduration/speedduration.cpp @@ -333,18 +333,18 @@ void SpeedDurationDialog::DurationChanged() } BlockReverseCommand::BlockReverseCommand(Block *block, QUndoCommand *parent) : - QUndoCommand(parent), + UndoCommand(parent), block_(block) { } -void BlockReverseCommand::redo() +void BlockReverseCommand::redo_internal() { block_->set_media_in(block_->media_out()); block_->set_speed(-block_->speed()); } -void BlockReverseCommand::undo() +void BlockReverseCommand::undo_internal() { - redo(); + redo_internal(); } diff --git a/app/dialog/speedduration/speedduration.h b/app/dialog/speedduration/speedduration.h index 69a9b2acd..50d912c99 100644 --- a/app/dialog/speedduration/speedduration.h +++ b/app/dialog/speedduration/speedduration.h @@ -3,12 +3,12 @@ #include #include -#include #include "node/block/clip/clip.h" #include "node/output/track/track.h" #include "widget/slider/floatslider.h" #include "widget/slider/timeslider.h" +#include "undo/undocommand.h" class SpeedDurationDialog : public QDialog { @@ -44,12 +44,13 @@ private slots: void DurationChanged(); }; -class BlockReverseCommand : public QUndoCommand { +class BlockReverseCommand : public UndoCommand { public: BlockReverseCommand(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: Block* block_; diff --git a/app/project/projectviewmodel.cpp b/app/project/projectviewmodel.cpp index f489fa7f7..6742f83a0 100644 --- a/app/project/projectviewmodel.cpp +++ b/app/project/projectviewmodel.cpp @@ -490,7 +490,7 @@ ProjectViewModel::MoveItemCommand::MoveItemCommand(ProjectViewModel *model, Item *item, Folder *destination, QUndoCommand *parent) : - QUndoCommand(parent), + UndoCommand(parent), model_(model), item_(item), destination_(destination) @@ -500,18 +500,18 @@ ProjectViewModel::MoveItemCommand::MoveItemCommand(ProjectViewModel *model, setText(tr("Move Item")); } -void ProjectViewModel::MoveItemCommand::redo() +void ProjectViewModel::MoveItemCommand::redo_internal() { model_->MoveItemInternal(item_, destination_); } -void ProjectViewModel::MoveItemCommand::undo() +void ProjectViewModel::MoveItemCommand::undo_internal() { model_->MoveItemInternal(item_, source_); } ProjectViewModel::RenameItemCommand::RenameItemCommand(ProjectViewModel* model, Item *item, const QString &name, QUndoCommand *parent) : - QUndoCommand(parent), + UndoCommand(parent), model_(model), item_(item), new_name_(name) @@ -521,18 +521,18 @@ ProjectViewModel::RenameItemCommand::RenameItemCommand(ProjectViewModel* model, setText(tr("Rename Item")); } -void ProjectViewModel::RenameItemCommand::redo() +void ProjectViewModel::RenameItemCommand::redo_internal() { model_->RenameChild(item_, new_name_); } -void ProjectViewModel::RenameItemCommand::undo() +void ProjectViewModel::RenameItemCommand::undo_internal() { model_->RenameChild(item_, old_name_); } ProjectViewModel::AddItemCommand::AddItemCommand(ProjectViewModel* model, Item* folder, ItemPtr child, QUndoCommand* parent) : - QUndoCommand(parent), + UndoCommand(parent), model_(model), parent_(folder), child_(child), @@ -544,14 +544,14 @@ ProjectViewModel::AddItemCommand::~AddItemCommand() { } -void ProjectViewModel::AddItemCommand::redo() +void ProjectViewModel::AddItemCommand::redo_internal() { model_->AddChild(parent_, child_); done_ = true; } -void ProjectViewModel::AddItemCommand::undo() +void ProjectViewModel::AddItemCommand::undo_internal() { model_->RemoveChild(parent_, child_.get()); diff --git a/app/project/projectviewmodel.h b/app/project/projectviewmodel.h index 1f7f191db..50057ecdb 100644 --- a/app/project/projectviewmodel.h +++ b/app/project/projectviewmodel.h @@ -22,9 +22,9 @@ #define VIEWMODEL_H #include -#include #include "project.h" +#include "undo/undocommand.h" /** * @brief An adapter that interprets the data in a Project into a Qt item model for usage in ViewModel Views. @@ -108,13 +108,14 @@ public: /** * @brief A QUndoCommand for moving an item from one folder to another folder */ - class MoveItemCommand : public QUndoCommand { + class MoveItemCommand : public UndoCommand { public: MoveItemCommand(ProjectViewModel* model, Item* item, Folder* destination, QUndoCommand* parent = nullptr); - virtual void redo() override; + protected: + virtual void redo_internal() override; - virtual void undo() override; + virtual void undo_internal() override; private: ProjectViewModel* model_; @@ -127,13 +128,14 @@ public: /** * @brief A QUndoCommand for renaming an item */ - class RenameItemCommand : public QUndoCommand { + class RenameItemCommand : public UndoCommand { public: RenameItemCommand(ProjectViewModel* model, Item* item, const QString& name, QUndoCommand* parent = nullptr); - virtual void redo() override; + protected: + virtual void redo_internal() override; - virtual void undo() override; + virtual void undo_internal() override; private: ProjectViewModel* model_; @@ -145,15 +147,16 @@ public: /** * @brief A QUndoCommand for adding an item */ - class AddItemCommand : public QUndoCommand { + class AddItemCommand : public UndoCommand { public: AddItemCommand(ProjectViewModel* model, Item* folder, ItemPtr child, QUndoCommand* parent = nullptr); virtual ~AddItemCommand() override; - virtual void redo() override; + protected: + virtual void redo_internal() override; - virtual void undo() override; + virtual void undo_internal() override; private: ProjectViewModel* model_; diff --git a/app/undo/CMakeLists.txt b/app/undo/CMakeLists.txt index 82052b803..da2588690 100644 --- a/app/undo/CMakeLists.txt +++ b/app/undo/CMakeLists.txt @@ -16,6 +16,8 @@ set(OLIVE_SOURCES ${OLIVE_SOURCES} + undo/undocommand.h + undo/undocommand.cpp undo/undostack.h undo/undostack.cpp PARENT_SCOPE diff --git a/app/undo/undocommand.cpp b/app/undo/undocommand.cpp new file mode 100644 index 000000000..5c1faccf9 --- /dev/null +++ b/app/undo/undocommand.cpp @@ -0,0 +1,33 @@ +#include "undocommand.h" + +#include "core.h" + +UndoCommand::UndoCommand(QUndoCommand *parent) : + QUndoCommand(parent) +{ +} + +void UndoCommand::redo() +{ + redo_internal(); + + modified_ = Core::instance()->IsProjectModified(); + Core::instance()->SetProjectModified(true); +} + +void UndoCommand::undo() +{ + undo_internal(); + + Core::instance()->SetProjectModified(modified_); +} + +void UndoCommand::redo_internal() +{ + QUndoCommand::redo(); +} + +void UndoCommand::undo_internal() +{ + QUndoCommand::undo(); +} diff --git a/app/undo/undocommand.h b/app/undo/undocommand.h new file mode 100644 index 000000000..66c7aa2d7 --- /dev/null +++ b/app/undo/undocommand.h @@ -0,0 +1,23 @@ +#ifndef UNDOCOMMAND_H +#define UNDOCOMMAND_H + +#include + +class UndoCommand : public QUndoCommand +{ +public: + UndoCommand(QUndoCommand* parent = nullptr); + + virtual void redo() override; + virtual void undo() override; + +protected: + virtual void redo_internal(); + virtual void undo_internal(); + +private: + bool modified_; + +}; + +#endif // UNDOCOMMAND_H diff --git a/app/widget/keyframeview/keyframeviewundo.cpp b/app/widget/keyframeview/keyframeviewundo.cpp index 858979357..f3ada6e5f 100644 --- a/app/widget/keyframeview/keyframeviewundo.cpp +++ b/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_); } diff --git a/app/widget/keyframeview/keyframeviewundo.h b/app/widget/keyframeview/keyframeviewundo.h index c58ce00eb..7d1b98137 100644 --- a/app/widget/keyframeview/keyframeviewundo.h +++ b/app/widget/keyframeview/keyframeviewundo.h @@ -1,16 +1,16 @@ #ifndef KEYFRAMEVIEWUNDO_H #define KEYFRAMEVIEWUNDO_H -#include - #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_; diff --git a/app/widget/nodeparamview/nodeparamviewundo.cpp b/app/widget/nodeparamview/nodeparamviewundo.cpp index ece75c860..ffcb42248 100644 --- a/app/widget/nodeparamview/nodeparamviewundo.cpp +++ b/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_); } diff --git a/app/widget/nodeparamview/nodeparamviewundo.h b/app/widget/nodeparamview/nodeparamviewundo.h index b6f7a9f7f..35baef0aa 100644 --- a/app/widget/nodeparamview/nodeparamviewundo.h +++ b/app/widget/nodeparamview/nodeparamviewundo.h @@ -1,29 +1,30 @@ #ifndef NODEPARAMVIEWUNDO_H #define NODEPARAMVIEWUNDO_H -#include - #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_; diff --git a/app/widget/nodeview/nodeviewundo.cpp b/app/widget/nodeview/nodeviewundo.cpp index 100fee223..243cab0de 100644 --- a/app/widget/nodeview/nodeviewundo.cpp +++ b/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 &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_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_); } diff --git a/app/widget/nodeview/nodeviewundo.h b/app/widget/nodeview/nodeviewundo.h index ce111b9a2..042eadd2a 100644 --- a/app/widget/nodeview/nodeviewundo.h +++ b/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& 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 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_; diff --git a/app/widget/timelinewidget/tool/import.cpp b/app/widget/timelinewidget/tool/import.cpp index ceef04489..28c1eb4ad 100644 --- a/app/widget/timelinewidget/tool/import.cpp +++ b/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); diff --git a/app/widget/timelinewidget/undo/undo.cpp b/app/widget/timelinewidget/undo/undo.cpp index 28d56dac8..6cdc63613 100644 --- a/app/widget/timelinewidget/undo/undo.cpp +++ b/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 &blocks, const QList ×, 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 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_); } diff --git a/app/widget/timelinewidget/undo/undo.h b/app/widget/timelinewidget/undo/undo.h index f5fe9443c..a4cd2e36f 100644 --- a/app/widget/timelinewidget/undo/undo.h +++ b/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 &blocks, const QList& 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 { diff --git a/app/window/mainwindow/mainwindow.cpp b/app/window/mainwindow/mainwindow.cpp index 110784de1..f27361d7c 100644 --- a/app/window/mainwindow/mainwindow.cpp +++ b/app/window/mainwindow/mainwindow.cpp @@ -23,6 +23,7 @@ #include #include #include +#include #include "mainmenu.h" #include "mainstatusbar.h" @@ -160,6 +161,28 @@ void MainWindow::ProjectOpen(Project* p) void MainWindow::closeEvent(QCloseEvent *e) { + if (isWindowModified()) { + QMessageBox mb(this); + + mb.setIcon(QMessageBox::Question); + mb.setWindowTitle(tr("Unsaved Changes")); + mb.setText(tr("The project '%1' has unsaved changes. Would you like to save them?") + .arg(Core::instance()->GetActiveProject()->name())); + + QPushButton* yes_btn = mb.addButton(tr("Save"), QMessageBox::YesRole); + mb.addButton(tr("Don't Save"), QMessageBox::NoRole); + QPushButton* cancel_btn = mb.addButton(QMessageBox::Cancel); + + mb.exec(); + + if (mb.clickedButton() == cancel_btn + || (mb.clickedButton() == yes_btn && !Core::instance()->SaveActiveProject())) { + // Don't close if the user clicked cancel on this messagebox OR they cancelled a save as operation + e->ignore(); + return; + } + } + // Close viewers first since we don't want to delete any nodes while they might be mid-render QList viewers = PanelManager::instance()->GetPanelsOfType(); foreach (ViewerPanel* viewer, viewers) { @@ -173,9 +196,9 @@ void MainWindow::closeEvent(QCloseEvent *e) void MainWindow::UpdateTitle() { - setWindowTitle(QStringLiteral("%1 %2 - %3").arg(QApplication::applicationName(), - QApplication::applicationVersion(), - tr(""))); + setWindowTitle(QStringLiteral("%1 %2 - [*]%3").arg(QApplication::applicationName(), + QApplication::applicationVersion(), + tr("(untitled)"))); } void MainWindow::SetDefaultLayout() @@ -186,14 +209,14 @@ void MainWindow::SetDefaultLayout() curve_panel_->setFloating(true); resizeDocks({node_panel_, param_panel_, viewer_panel_}, - {width()/3, width()/3, width()/3}, + {width()/3, width()/3, width()/3}, Qt::Horizontal); resizeDocks({project_panel_, tool_panel_, timeline_panel_, audio_monitor_panel_}, - {width()/4, 1, width(), 1}, + {width()/4, 1, width(), 1}, Qt::Horizontal); resizeDocks({node_panel_, project_panel_}, - {height()/2, height()/2}, + {height()/2, height()/2}, Qt::Vertical); }