undoredocommand.cpp

/*
 
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.
 
*/
 
#include <QDebug>
 
#include "layermanager.h"
#include "selectionmanager.h"
 
#include "layersound.h"
#include "layerbitmap.h"
#include "layervector.h"
 
#include "editor.h"
#include "undoredocommand.h"
 
UndoRedoCommand::UndoRedoCommand(Editor* editor, QUndoCommand* parent) : QUndoCommand(parent)
{
    qDebug() << "backupElement created";
    mEditor = editor;
}
 
UndoRedoCommand::~UndoRedoCommand()
{
}
 
BitmapReplaceCommand::BitmapReplaceCommand(const BitmapImage* undoBitmap,
                             const int undoLayerId,
                             const QString& description,
                             Editor *editor,
                             QUndoCommand *parent) : UndoRedoCommand(editor, parent)
{
 
    this->undoBitmap = *undoBitmap;
    this->undoLayerId = undoLayerId;
 
    Layer* layer = editor->layers()->currentLayer();
    redoLayerId = layer->id();
    redoBitmap = *static_cast<LayerBitmap*>(layer)->
            getBitmapImageAtFrame(editor->currentFrame());
 
    setText(description);
}
 
void BitmapReplaceCommand::undo()
{
    QUndoCommand::undo();
 
    Layer* layer = editor()->layers()->findLayerById(undoLayerId);
    static_cast<LayerBitmap*>(layer)->replaceKeyFrame(&undoBitmap);
 
    editor()->scrubTo(undoBitmap.pos());
}
 
void BitmapReplaceCommand::redo()
{
    QUndoCommand::redo();
 
    // Ignore automatic redo when added to undo stack
    if (isFirstRedo()) { setFirstRedo(false); return; }
 
    Layer* layer = editor()->layers()->findLayerById(redoLayerId);
    static_cast<LayerBitmap*>(layer)->replaceKeyFrame(&redoBitmap);
 
    editor()->scrubTo(redoBitmap.pos());
}
 
VectorReplaceCommand::VectorReplaceCommand(const VectorImage* undoVector,
                                   const int undoLayerId,
                                   const QString& description,
                                   Editor* editor,
                                   QUndoCommand* parent) : UndoRedoCommand(editor, parent)
{
 
    this->undoVector = *undoVector;
    this->undoLayerId = undoLayerId;
    Layer* layer = editor->layers()->currentLayer();
    redoLayerId = layer->id();
    redoVector = *static_cast<LayerVector*>(layer)->
            getVectorImageAtFrame(editor->currentFrame());
 
    setText(description);
}
 
void VectorReplaceCommand::undo()
{
    QUndoCommand::undo();
 
    Layer* layer = editor()->layers()->findLayerById(undoLayerId);
 
    static_cast<LayerVector*>(layer)->replaceKeyFrame(&undoVector);
 
    editor()->scrubTo(undoVector.pos());
}
 
void VectorReplaceCommand::redo()
{
    QUndoCommand::redo();
 
    // Ignore automatic redo when added to undo stack
    if (isFirstRedo()) { setFirstRedo(false); return; }
 
    Layer* layer = editor()->layers()->findLayerById(redoLayerId);
 
    static_cast<LayerVector*>(layer)->replaceKeyFrame(&redoVector);
 
    editor()->scrubTo(redoVector.pos());
}
 
TransformCommand::TransformCommand(const QRectF& undoSelectionRect,
                                   const QPointF& undoTranslation,
                                   const qreal undoRotationAngle,
                                   const qreal undoScaleX,
                                   const qreal undoScaleY,
                                   const QPointF& undoTransformAnchor,
                                   const bool roundPixels,
                                   const QString& description,
                                   Editor* editor,
                                   QUndoCommand *parent) : UndoRedoCommand(editor, parent)
{
    this->roundPixels = roundPixels;
 
    this->undoSelectionRect = undoSelectionRect;
    this->undoAnchor = undoTransformAnchor;
    this->undoTranslation = undoTranslation;
    this->undoRotationAngle = undoRotationAngle;
    this->undoScaleX = undoScaleX;
    this->undoScaleY = undoScaleY;
 
    auto selectMan = editor->select();
    redoSelectionRect = selectMan->mySelectionRect();
    redoAnchor = selectMan->currentTransformAnchor();
    redoTranslation = selectMan->myTranslation();
    redoRotationAngle = selectMan->myRotation();
    redoScaleX = selectMan->myScaleX();
    redoScaleY = selectMan->myScaleY();
 
    setText(description);
}
 
void TransformCommand::undo()
{
    apply(undoSelectionRect,
          undoTranslation,
          undoRotationAngle,
          undoScaleX,
          undoScaleY,
          undoAnchor,
          roundPixels);
}
 
void TransformCommand::redo()
{
    // Ignore automatic redo when added to undo stack
    if (isFirstRedo()) { setFirstRedo(false); return; }
 
    apply(redoSelectionRect,
          redoTranslation,
          redoRotationAngle,
          redoScaleX,
          redoScaleY,
          redoAnchor,
          roundPixels);
}
 
void TransformCommand::apply(const QRectF& selectionRect,
                             const QPointF& translation,
                             const qreal rotationAngle,
                             const qreal scaleX,
                             const qreal scaleY,
                             const QPointF& selectionAnchor,
                             const bool roundPixels)
{
    auto selectMan = editor()->select();
    selectMan->setSelection(selectionRect, roundPixels);
    selectMan->setTransformAnchor(selectionAnchor);
    selectMan->setTranslation(translation);
    selectMan->setRotation(rotationAngle);
    selectMan->setScale(scaleX, scaleY);
 
    selectMan->calculateSelectionTransformation();
}