undoredomanager.h

/*
 
Pencil2D - Traditional Animation Software
Copyright (C) 2005-2007 Patrick Corrieri & Pascal Naidon
Copyright (C) 2008-2009 Mj Mendoza IV
Copyright (C) 2012-2020 Matthew Chiawen Chang
 
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; version 2 of the License.
 
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.
 
*/
#ifndef UNDOREDOMANAGER_H
#define UNDOREDOMANAGER_H
 
#include "basemanager.h"
#include "layer.h"
#include "keyframe.h"
 
#include "preferencesdef.h"
 
#include <QUndoStack>
#include <QRectF>
#include <QMap>
 
class QAction;
class QUndoCommand;
 
class BitmapImage;
class VectorImage;
class Camera;
class SoundClip;
class KeyFrame;
class LegacyBackupElement;
class UndoRedoCommand;
 
using SAVESTATE_ID = int;
 
enum class UndoRedoRecordType {
    KEYFRAME_MODIFY, // Any modification that involve a keyframe
    KEYFRAME_REMOVE, // Removing a keyframe
    KEYFRAME_ADD, // Adding a keyframe
    KEYFRAME_MOVE,
    // SCRUB_LAYER, // Scrubbing layer
    // SCRUB_KEYFRAME, // Scrubbing keyframe
    INVALID
};
 
struct SelectionSaveState {
 
    SelectionSaveState() = default;
    SelectionSaveState(const QRectF& rect,
                       const qreal rotationAngle,
                       const qreal scaleX,
                       const qreal scaleY,
                       const QPointF& translation,
                       const QPointF& anchor)
    {
        this->bounds = rect;
        this->rotationAngle = rotationAngle;
        this->scaleX = scaleX;
        this->scaleY = scaleY;
        this->translation = translation;
        this->anchor = anchor;
    }
 
    QRectF  bounds;
    qreal   rotationAngle = 0.0;
    qreal   scaleX = 0.0;
    qreal   scaleY = 0.0;
    QPointF translation;
    QPointF anchor;
};
 
struct MoveFramesSaveState {
 
    MoveFramesSaveState() = default;
    MoveFramesSaveState(int offset,
                        const QList<int>& positions)
    {
        this->offset = offset;
        this->positions = positions;
    }
 
    int offset = 0;
    QList<int> positions;
};
 
struct UserSaveState {
    MoveFramesSaveState moveFramesState = {};
};
 
struct UndoSaveState {
    // Common data
    UndoRedoRecordType recordType = UndoRedoRecordType::INVALID;
    int layerId = 0;
    int currentFrameIndex = 0;
    Layer::LAYER_TYPE layerType = Layer::UNDEFINED;
    std::unique_ptr<KeyFrame> keyframe;
    SelectionSaveState selectionState = {};
 
    UserSaveState userState = {};
};
 
class UndoRedoManager : public BaseManager
{
    Q_OBJECT
 
public:
    explicit UndoRedoManager(Editor* editor);
    ~UndoRedoManager() override;
 
    bool init() override;
    Status load(Object*) override;
    Status save(Object*) override;
 
    void record(SAVESTATE_ID SaveStateId, const QString& description);
 
 
    bool hasUnsavedChanges() const;
 
    SAVESTATE_ID createState(UndoRedoRecordType recordType);
 
    void addUserState(SAVESTATE_ID SaveStateId, const UserSaveState& userState);
 
    QAction* createUndoAction(QObject* parent, const QIcon& icon);
    QAction* createRedoAction(QObject* parent, const QIcon& icon);
 
    void updateUndoAction(QAction* undoAction);
    void updateRedoAction(QAction* redoAction);
 
    void clearStack();
 
    // Developer note:
    // Our legacy undo/redo system is not meant to be build upon anymore.
    // The implementation should however be kept until the new undo/redo system takes over.
 
    void legacyBackup(const QString& undoText);
    bool legacyBackup(int backupLayer, int backupFrame, const QString& undoText);
    void sanitizeLegacyBackupElementsAfterLayerDeletion(int layerIndex);
    void restoreLegacyKey();
 
    void rememberLastModifiedFrame(int layerNumber, int frameNumber);
 
    void onSettingChanged(SETTING setting);
 
signals:
    void didUpdateUndoStack();
 
private:
 
    void replaceKeyFrame(const UndoSaveState& undoState, const QString& description);
    void replaceBitmap(const UndoSaveState& undoState, const QString& description);
    void replaceVector(const UndoSaveState& undoState, const QString& description);
 
    void addKeyFrame(const UndoSaveState& undoState, const QString& description);
    void removeKeyFrame(const UndoSaveState& undoState, const QString& description);
    void moveKeyFrames(const UndoSaveState& undoState, const QString& description);
 
    void initCommonKeyFrameState(UndoSaveState* undoSaveState) const;
 
    void pushCommand(QUndoCommand* command);
 
    void clearState(UndoSaveState*& state);
    void clearSaveStates();
 
    void legacyUndo();
    void legacyRedo();
 
    QUndoStack mUndoStack;
 
    QMap<SAVESTATE_ID, UndoSaveState*> mSaveStates;
 
    // Legacy system
    int mLegacyBackupIndex = -1;
    LegacyBackupElement* mLegacyBackupAtSave = nullptr;
    QList<LegacyBackupElement*> mLegacyBackupList;
 
    int mLegacyLastModifiedLayer = -1;
    int mLegacyLastModifiedFrame = -1;
 
    SAVESTATE_ID mSaveStateId = 1;
 
    bool mNewBackupSystemEnabled = false;
};
 
#endif // UNDOREDOMANAGER_H