DACommandsForGraphics.h

#ifndef DACOMMANDSFORGRAPHICS_H
#define DACOMMANDSFORGRAPHICS_H
#include "DAGraphicsViewGlobal.h"
#include <QUndoCommand>
#include <QPointer>
#include <QDateTime>
class QGraphicsScene;
class QGraphicsItem;
class QGraphicsTextItem;
class QTextDocument;
 
namespace DA
{
class DAGraphicsScene;
class DAGraphicsResizeableItem;
class DAGRAPHICSVIEW_API DACommandsForGraphicsItemAdd : public QUndoCommand
{
public:
    DACommandsForGraphicsItemAdd(QGraphicsItem* item, QGraphicsScene* scene, QUndoCommand* parent = nullptr);
    ~DACommandsForGraphicsItemAdd();
    void redo() override;
    void undo() override;
    virtual int id() const override
    {
        return CmdID_ItemAdd;
    }
 
private:
    QGraphicsItem* mItem;
    QGraphicsScene* mScene;
    bool mNeedDelete;
};
 
class DAGRAPHICSVIEW_API DACommandsForGraphicsItemsAdd : public QUndoCommand
{
public:
    DACommandsForGraphicsItemsAdd(const QList< QGraphicsItem* > its, QGraphicsScene* scene, QUndoCommand* parent = nullptr);
    ~DACommandsForGraphicsItemsAdd();
    void redo() override;
    void undo() override;
    virtual int id() const override
    {
        return CmdID_ItemsAdd;
    }
 
private:
    QList< QGraphicsItem* > mItems;
    QGraphicsScene* mScene;
    bool mNeedDelete;
};
 
class DAGRAPHICSVIEW_API DACommandsForGraphicsItemRemove : public QUndoCommand
{
public:
    DACommandsForGraphicsItemRemove(QGraphicsItem* item, QGraphicsScene* scene, QUndoCommand* parent = nullptr);
    ~DACommandsForGraphicsItemRemove();
    void redo() override;
    void undo() override;
    virtual int id() const override
    {
        return CmdID_ItemRemove;
    }
 
private:
    QGraphicsItem* mItem;
    QGraphicsScene* mScene;
    bool mNeedDelete;
};
 
class DAGRAPHICSVIEW_API DACommandsForGraphicsItemsRemove : public QUndoCommand
{
public:
    DACommandsForGraphicsItemsRemove(const QList< QGraphicsItem* > its, QGraphicsScene* scene, QUndoCommand* parent = nullptr);
    ~DACommandsForGraphicsItemsRemove();
    void redo() override;
    void undo() override;
    virtual int id() const override
    {
        return CmdID_ItemsRemove;
    }
 
private:
    QList< QGraphicsItem* > mItems;
    QGraphicsScene* mScene;
    bool mNeedDelete;
};
 
class DAGRAPHICSVIEW_API DACommandsForGraphicsItemsMoved : public QUndoCommand
{
public:
    DACommandsForGraphicsItemsMoved(const QList< QGraphicsItem* >& items,
                                    const QList< QPointF >& starts,
                                    const QList< QPointF >& ends,
                                    bool skipfirst,
                                    QUndoCommand* parent = nullptr);
    void redo() override;
    void undo() override;
    int id() const override;
    bool mergeWith(const QUndoCommand* command) override;
    // 注意，此命令可能会合并，不应该在推入栈后再对此命令有任何操作，会出现空指针
    const QList< QGraphicsItem* >& getItems() const;
    // 注意，此命令可能会合并，不应该在推入栈后再对此命令有任何操作，会出现空指针
    const QList< QPointF >& getStartsPos() const;
    // 注意，此命令可能会合并，不应该在推入栈后再对此命令有任何操作，会出现空指针
    const QList< QPointF >& getEndsPos() const;
 
protected:
    QList< QGraphicsItem* > mItems;
    QList< QPointF > mStartsPos;
    QList< QPointF > mEndsPos;
    QDateTime mCmdDatetime;
    bool mSkipFirst;
};
 
class DAGRAPHICSVIEW_API DACommandsForGraphicsItemMoved : public QUndoCommand
{
public:
    DACommandsForGraphicsItemMoved(QGraphicsItem* item,
                                   const QPointF& start,
                                   const QPointF& end,
                                   bool skipfirst,
                                   QUndoCommand* parent = nullptr);
    void redo() override;
    void undo() override;
    int id() const override;
    bool mergeWith(const QUndoCommand* command) override;
 
protected:
    QGraphicsItem* mItem;
    QPointF mStartPos;
    QPointF mEndPos;
    bool mSkipFirst;
    QDateTime mDatetime;
};
 
class DAGRAPHICSVIEW_API DACommandsForGraphicsItemResized : public QUndoCommand
{
public:
    DACommandsForGraphicsItemResized(DAGraphicsResizeableItem* item,
                                     const QPointF& oldpos,
                                     const QSizeF& oldSize,
                                     const QPointF& newpos,
                                     const QSizeF& newSize,
                                     bool skipfirst       = true,
                                     QUndoCommand* parent = nullptr);
    DACommandsForGraphicsItemResized(DAGraphicsResizeableItem* item,
                                     const QSizeF& oldSize,
                                     const QSizeF& newSize,
                                     QUndoCommand* parent = nullptr);
    void redo() override;
    void undo() override;
    int id() const override;
    bool mergeWith(const QUndoCommand* command) override;
 
private:
    DAGraphicsResizeableItem* mItem;
    QPointF mOldpos;
    QSizeF mOldSize;
    QPointF mNewPosition;
    QSizeF mNewSize;
    bool mSkipfirst { false };
    QDateTime mDatetime;
};
 
class DAGRAPHICSVIEW_API DACommandsForGraphicsItemResizeWidth : public QUndoCommand
{
public:
    DACommandsForGraphicsItemResizeWidth(DAGraphicsResizeableItem* item,
                                         const qreal& oldWidth,
                                         const qreal& newWidth,
                                         QUndoCommand* parent = nullptr);
    void redo() override;
    void undo() override;
    int id() const override;
    bool mergeWith(const QUndoCommand* command) override;
 
private:
    DAGraphicsResizeableItem* mItem;
    qreal mOldWidth;
    qreal mNewWidth;
    qreal mHeight;
    QDateTime mDatetime;
};
 
class DAGRAPHICSVIEW_API DACommandsForGraphicsItemResizeHeight : public QUndoCommand
{
public:
    DACommandsForGraphicsItemResizeHeight(DAGraphicsResizeableItem* item,
                                          const qreal& oldHeight,
                                          const qreal& newHeight,
                                          QUndoCommand* parent = nullptr);
    void redo() override;
    void undo() override;
    int id() const override;
    bool mergeWith(const QUndoCommand* command) override;
 
private:
    DAGraphicsResizeableItem* mItem;
    qreal mOldHeight;
    qreal mNewHeight;
    qreal mWidth;
    QDateTime mDatetime;
};
 
class DAGRAPHICSVIEW_API DACommandsForGraphicsItemRotation : public QUndoCommand
{
public:
    DACommandsForGraphicsItemRotation(DAGraphicsResizeableItem* item,
                                      const qreal& oldRotation,
                                      const qreal& newRotation,
                                      QUndoCommand* parent = nullptr);
    void redo() override;
    void undo() override;
    int id() const override;
    bool mergeWith(const QUndoCommand* command) override;
 
private:
    DAGraphicsResizeableItem* mItem;
    qreal mOldRotation;
    qreal mNewRotation;
    QDateTime mDatetime;
};
 
class DAGRAPHICSVIEW_API DACommandsForGraphicsItemGrouping : public QUndoCommand
{
public:
    DACommandsForGraphicsItemGrouping(DAGraphicsScene* sc,
                                      const QList< QGraphicsItem* >& groupingitems,
                                      QUndoCommand* parent = nullptr);
    ~DACommandsForGraphicsItemGrouping();
    void redo() override;
    void undo() override;
    // 这是一个清洗，要分组的item里面，如果存在item的parent在分组的item里，就驱除，这样不会分组嵌套，形成单一的层级
    static QList< QGraphicsItem* > toSimple(const QList< QGraphicsItem* >& groupingitems);
    QList< QGraphicsItem* > getWillGroupItems() const;
    virtual int id() const override
    {
        return CmdID_ItemGrouping;
    }
 
private:
    DAGraphicsScene* mScene;
    QList< QGraphicsItem* > mWillGroupItems;
    QGraphicsItemGroup* mGroupItem { nullptr };
    bool mNeedDelete { false };
};
 
class DAGRAPHICSVIEW_API DACommandsForGraphicsItemUngrouping : public QUndoCommand
{
public:
    DACommandsForGraphicsItemUngrouping(QGraphicsScene* sc, QGraphicsItemGroup* group, QUndoCommand* parent = nullptr);
    ~DACommandsForGraphicsItemUngrouping();
    void redo() override;
    void undo() override;
    virtual int id() const override
    {
        return CmdID_ItemUnGrouping;
    }
 
private:
    QGraphicsScene* mScene;
    QList< QGraphicsItem* > mItems;
    QGraphicsItemGroup* mGroupItem { nullptr };
    bool mNeedDelete { false };
};
 
class DAGRAPHICSVIEW_API DACommandTextDocumentWrapper : public QUndoCommand
{
public:
    DACommandTextDocumentWrapper(QTextDocument* doc, QUndoCommand* parent = nullptr);
    ~DACommandTextDocumentWrapper();
    virtual void redo() override;
    virtual void undo() override;
    virtual int id() const override
    {
        return CmdID_ItemTextDocumentWrapper;
    }
 
private:
    QPointer< QTextDocument > mDoc;
};
 
class DAGRAPHICSVIEW_API DACommandTextItemHtmlContentChanged : public QUndoCommand
{
public:
    DACommandTextItemHtmlContentChanged(QGraphicsTextItem* item,
                                        const QString& oldHtml,
                                        const QString& newHtml,
                                        QUndoCommand* parent = nullptr);
    ~DACommandTextItemHtmlContentChanged();
    virtual void redo() override;
    virtual void undo() override;
    virtual int id() const override
    {
        return CmdID_ItemTextHtmlContentChanged;
    }
    // 合并
    virtual bool mergeWith(const QUndoCommand* command) override;
 
private:
    QGraphicsTextItem* mItem;
    QString mOldHtml;
    QString mNewHtml;
    bool mSkipFirst { true };
    QDateTime mDate;
};
}
#endif  // DACOMMANDSFORGRAPHICS_H