Commands.cpp

Go to the documentation of this file.

/********************************************************************************
 * Copyright (C) 2011 by Stephen Allewell                                       *
 * sallewell@users.sourceforge.net                                              *
 *                                                                              *
 * 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; either version 2 of the License, or            *
 * (at your option) any later version.                                          *
 ********************************************************************************/


#include "Commands.h"

#include <QPainterPath>
#include <QMimeData>

#include <KLocale>

#include "Editor.h"
#include "SymbolLibrary.h"


enum IDs {MoveTo,
          LineTo,
          CubicTo,
          Rectangle,
          Ellipse,
          MovePoint,
          UpdateSymbol,
          ImportLibrary,
          RotateLeft,
          RotateRight,
          FlipHorizontal,
          FlipVertical,
          ChangeFilled,
          ChangeFillRule,
          ChangeCapStyle,
          ChangeJoinStyle,
          DeleteSymbol,
          IncreaseLineWidth,
          DecreaseLineWidth,
          DragAndDrop
         };


MoveToCommand::MoveToCommand(Editor *editor, const QPointF &to)
    :   QUndoCommand(i18n("Move to")),
        m_editor(editor),
        m_to(to)
{
}


MoveToCommand::~MoveToCommand()
{
}


void MoveToCommand::undo()
{
    m_editor->removeLast(m_path);
}


void MoveToCommand::redo()
{
    m_path = m_editor->moveTo(m_to);
}


LineToCommand::LineToCommand(Editor *editor, const QPointF &to)
    :   QUndoCommand(i18n("Line to")),
        m_editor(editor),
        m_to(to)
{
}


LineToCommand::~LineToCommand()
{
}


void LineToCommand::undo()
{
    m_editor->removeLast(m_path);
}


void LineToCommand::redo()
{
    m_path = m_editor->lineTo(m_to);
}


CubicToCommand::CubicToCommand(Editor *editor, const QPointF &control1, const QPointF &control2, const QPointF &to)
    :   QUndoCommand(i18n("Cubic to")),
        m_editor(editor),
        m_control1(control1),
        m_control2(control2),
        m_to(to)
{
}


CubicToCommand::~CubicToCommand()
{
}


void CubicToCommand::undo()
{
    m_editor->removeLast(m_path);
}


void CubicToCommand::redo()
{
    m_path = m_editor->cubicTo(m_control1, m_control2, m_to);
}


RectangleCommand::RectangleCommand(Editor *editor, const QPointF &from, const QPointF &to)
    :   QUndoCommand(i18n("Add Rectangle")),
        m_editor(editor),
        m_from(from),
        m_to(to)
{
}


RectangleCommand::~RectangleCommand()
{
}


void RectangleCommand::undo()
{
    m_editor->removeLast(m_path);
}


void RectangleCommand::redo()
{
    m_path = m_editor->addRectangle(m_from, m_to);
}


EllipseCommand::EllipseCommand(Editor *editor, const QPointF &from, const QPointF &to)
    :   QUndoCommand(i18n("Add Ellipse")),
        m_editor(editor),
        m_from(from),
        m_to(to)
{
}


EllipseCommand::~EllipseCommand()
{
}


void EllipseCommand::undo()
{
    m_editor->removeLast(m_path);
}


void EllipseCommand::redo()
{
    m_path = m_editor->addEllipse(m_from, m_to);
}


MovePointCommand::MovePointCommand(Editor *editor, int index, const QPointF &from, const QPointF &to)
    :   QUndoCommand(i18n("Move point")),
        m_editor(editor),
        m_index(index),
        m_from(from),
        m_to(to)
{
}


MovePointCommand::~MovePointCommand()
{
}


void MovePointCommand::undo()
{
    m_editor->movePoint(m_index, m_from);
}


void MovePointCommand::redo()
{
    m_editor->movePoint(m_index, m_to);
}


UpdateSymbolCommand::UpdateSymbolCommand(SymbolLibrary *library, qint16 index, const Symbol &symbol)
    :   QUndoCommand(i18n("Update Symbol")),
        m_symbolLibrary(library),
        m_index(index),
        m_symbol(symbol)
{
}


UpdateSymbolCommand::~UpdateSymbolCommand()
{
}


void UpdateSymbolCommand::undo()
{
    if (m_originalSymbol.path().isEmpty()) {
        m_symbolLibrary->takeSymbol(m_index);
        m_index = 0;
    } else {
        m_symbolLibrary->setSymbol(m_index, m_originalSymbol);
    }
}


void UpdateSymbolCommand::redo()
{
    m_originalSymbol = m_symbolLibrary->symbol(m_index);
    m_index = m_symbolLibrary->setSymbol(m_index, m_symbol);
}


ImportLibraryCommand::ImportLibraryCommand(SymbolLibrary *library, SymbolLibrary *imported)
    :   QUndoCommand(i18n("Import Library")),
        m_symbolLibrary(library),
        m_imported(imported)
{
}


ImportLibraryCommand::~ImportLibraryCommand()
{
    delete m_imported;
}


void ImportLibraryCommand::undo()
{
    foreach (qint16 i, m_addedIndexes) {
        m_symbolLibrary->takeSymbol(i);
    }

    m_addedIndexes.clear();
}


void ImportLibraryCommand::redo()
{
    foreach (qint16 i, m_imported->indexes()) {
        m_addedIndexes.append(m_symbolLibrary->setSymbol(0, m_imported->symbol(i))); // gets a new index
    }
}


RotateLeftCommand::RotateLeftCommand(Editor *editor)
    :   QUndoCommand(i18n("Rotate Left")),
        m_editor(editor)
{
}


RotateLeftCommand::~RotateLeftCommand()
{
}


void RotateLeftCommand::undo()
{
    m_editor->rotatePointsRight();
}


void RotateLeftCommand::redo()
{
    m_editor->rotatePointsLeft();
}


RotateRightCommand::RotateRightCommand(Editor *editor)
    :   QUndoCommand(i18n("Rotate Right")),
        m_editor(editor)
{
}


RotateRightCommand::~RotateRightCommand()
{
}


void RotateRightCommand::undo()
{
    m_editor->rotatePointsLeft();
}


void RotateRightCommand::redo()
{
    m_editor->rotatePointsRight();
}


FlipHorizontalCommand::FlipHorizontalCommand(Editor *editor)
    :   QUndoCommand(i18n("Flip Horizontally")),
        m_editor(editor)
{
}


FlipHorizontalCommand::~FlipHorizontalCommand()
{
}


void FlipHorizontalCommand::undo()
{
    m_editor->flipPointsHorizontal();
}


void FlipHorizontalCommand::redo()
{
    m_editor->flipPointsHorizontal();
}


FlipVerticalCommand::FlipVerticalCommand(Editor *editor)
    :   QUndoCommand(i18n("Flip Vertical")),
        m_editor(editor)
{
}


FlipVerticalCommand::~FlipVerticalCommand()
{
}


void FlipVerticalCommand::undo()
{
    m_editor->flipPointsVertical();
}


void FlipVerticalCommand::redo()
{
    m_editor->flipPointsVertical();
}


ScalePreferredCommand::ScalePreferredCommand(Editor *editor, const QPainterPath &originalSymbol, int gridElements, int borderSize)
    :   QUndoCommand(i18n("Scale to preferred size")),
        m_editor(editor),
        m_originalSymbol(originalSymbol),
        m_gridElements(gridElements),
        m_borderSize(borderSize)
{
}


ScalePreferredCommand::~ScalePreferredCommand()
{
}


void ScalePreferredCommand::undo()
{
    m_editor->setPath(m_originalSymbol);
}


void ScalePreferredCommand::redo()
{
    double borderSize = double(m_borderSize) / double(m_gridElements);
    double threshold = 0.01;
    QRectF fullSize(0.0, 0.0, 1.0, 1.0);
    QRectF preferredSize(borderSize, borderSize, 1.0 - borderSize - borderSize, 1.0 - borderSize - borderSize);

    QPainterPath border;
    border.addRect(fullSize);
    border.addRect(preferredSize.adjusted(-threshold, -threshold, threshold, threshold));
    border.setFillRule(Qt::OddEvenFill);

    if (m_originalSymbol.intersects(border)) {
        QRectF boundingRect = m_originalSymbol.boundingRect();
        double leftOverlap = std::max(preferredSize.left() - boundingRect.left(), 0.0);
        double topOverlap = std::max(preferredSize.top() - boundingRect.top(), 0.0);
        double rightOverlap = std::max(boundingRect.right() - preferredSize.right(), 0.0);
        double bottomOverlap = std::max(boundingRect.bottom() - preferredSize.bottom(), 0.0);
        double overlap = std::max(std::max(leftOverlap, rightOverlap), std::max(topOverlap, bottomOverlap));
        QRectF startingSize = preferredSize.adjusted(-overlap, -overlap, overlap, overlap);
        double scale = preferredSize.width() / startingSize.width();
        QTransform transform = QTransform::fromTranslate(-0.5, -0.5) * QTransform::fromScale(scale, scale) * QTransform::fromTranslate(0.5, 0.5);
        QPainterPath scaledPath = transform.map(m_originalSymbol);
        m_editor->setPath(scaledPath);
    }
}


ChangeFilledCommand::ChangeFilledCommand(Editor *editor, bool from, bool to)
    :   QUndoCommand(i18n("Change Fill State")),
        m_editor(editor),
        m_from(from),
        m_to(to)
{
}


ChangeFilledCommand::~ChangeFilledCommand()
{
}


void ChangeFilledCommand::undo()
{
    m_editor->setFilled(m_from);
}


void ChangeFilledCommand::redo()
{
    m_editor->setFilled(m_to);
}


ChangeFillRuleCommand::ChangeFillRuleCommand(Editor *editor, Qt::FillRule from, Qt::FillRule to)
    :   QUndoCommand(i18n("Change Fill Rule")),
        m_editor(editor),
        m_from(from),
        m_to(to)
{
}


ChangeFillRuleCommand::~ChangeFillRuleCommand()
{
}


void ChangeFillRuleCommand::undo()
{
    m_editor->setFillRule(m_from);
}


void ChangeFillRuleCommand::redo()
{
    m_editor->setFillRule(m_to);
}


ChangeCapStyleCommand::ChangeCapStyleCommand(Editor *editor, Qt::PenCapStyle from, Qt::PenCapStyle to)
    :   QUndoCommand(i18n("Change Cap Style")),
        m_editor(editor),
        m_from(from),
        m_to(to)
{
}


ChangeCapStyleCommand::~ChangeCapStyleCommand()
{
}


void ChangeCapStyleCommand::undo()
{
    m_editor->setCapStyle(m_from);
}


void ChangeCapStyleCommand::redo()
{
    m_editor->setCapStyle(m_to);
}


ChangeJoinStyleCommand::ChangeJoinStyleCommand(Editor *editor, Qt::PenJoinStyle from, Qt::PenJoinStyle to)
    :   QUndoCommand(i18n("Change Join Style")),
        m_editor(editor),
        m_from(from),
        m_to(to)
{
}


ChangeJoinStyleCommand::~ChangeJoinStyleCommand()
{
}


void ChangeJoinStyleCommand::undo()
{
    m_editor->setJoinStyle(m_from);
}


void ChangeJoinStyleCommand::redo()
{
    m_editor->setJoinStyle(m_to);
}


DeleteSymbolCommand::DeleteSymbolCommand(SymbolLibrary *library, qint16 index)
    :   QUndoCommand(i18n("Delete Symbol")),
        m_symbolLibrary(library),
        m_index(index)
{
}


DeleteSymbolCommand::~DeleteSymbolCommand()
{
}


void DeleteSymbolCommand::undo()
{
    m_symbolLibrary->setSymbol(m_index, m_symbol);
}


void DeleteSymbolCommand::redo()
{
    m_symbol = m_symbolLibrary->takeSymbol(m_index);
}


IncreaseLineWidthCommand::IncreaseLineWidthCommand(Editor *editor, qreal from, qreal to)
    :   QUndoCommand(i18n("Increase Line Width")),
        m_editor(editor),
        m_from(from),
        m_to(to)
{
}


IncreaseLineWidthCommand::~IncreaseLineWidthCommand()
{
}


void IncreaseLineWidthCommand::undo()
{
    m_editor->setLineWidth(m_from);
}


void IncreaseLineWidthCommand::redo()
{
    m_editor->setLineWidth(m_to);
}


int IncreaseLineWidthCommand::id() const
{
    return static_cast<int>(IncreaseLineWidth);
}


bool IncreaseLineWidthCommand::mergeWith(const QUndoCommand *command)
{
    if (command->id() != id()) {
        return false;
    }

    m_to += static_cast<const IncreaseLineWidthCommand *>(command)->m_to;
    return true;
}


DecreaseLineWidthCommand::DecreaseLineWidthCommand(Editor *editor, qreal from, qreal to)
    :   QUndoCommand(i18n("Decrease Line Width")),
        m_editor(editor),
        m_from(from),
        m_to(to)
{
}


DecreaseLineWidthCommand::~DecreaseLineWidthCommand()
{
}


void DecreaseLineWidthCommand::undo()
{
    m_editor->setLineWidth(m_from);
}


void DecreaseLineWidthCommand::redo()
{
    m_editor->setLineWidth(m_to);
}


int DecreaseLineWidthCommand::id() const
{
    return static_cast<int>(DecreaseLineWidth);
}


bool DecreaseLineWidthCommand::mergeWith(const QUndoCommand *command)
{
    if (command->id() != id()) {
        return false;
    }

    m_to -= static_cast<const DecreaseLineWidthCommand *>(command)->m_to;
    return true;
}


DragAndDropCommand::DragAndDropCommand(SymbolLibrary *library, const QMimeData *mimeData)
    :   QUndoCommand(i18n("Add Symbols")),
        m_library(library)
{
    QByteArray data = mimeData->data("application/kxstitchsymbol");
    QDataStream stream(&data, QIODevice::ReadOnly);

    while (!stream.atEnd()) {
        Symbol symbol;
        stream >> symbol;
        m_symbols.append(symbol);
    }
}


void DragAndDropCommand::redo()
{
    foreach (const Symbol & symbol, m_symbols) {
        m_indexes.append(m_library->setSymbol(0, symbol));
    }
}


void DragAndDropCommand::undo()
{
    foreach (qint16 index, m_indexes) {
        m_library->takeSymbol(index);
    }

    m_indexes.clear();
}


AddCharacterCommand::AddCharacterCommand(Editor *editor, const QPainterPath &path)
    :   QUndoCommand(i18n("Add Character")),
        m_editor(editor),
        m_path(path)
{
}


void AddCharacterCommand::redo()
{
    m_path = m_editor->setPath(m_path);
}


void AddCharacterCommand::undo()
{
    m_path = m_editor->setPath(m_path);
}