commands.hpp

Go to the documentation of this file.

#ifndef CSM_WOLRD_COMMANDS_H
#define CSM_WOLRD_COMMANDS_H

#include "record.hpp"

#include <string>
#include <map>
#include <memory>
#include <vector>

#include <QVariant>
#include <QUndoCommand>
#include <QModelIndex>

#include "columnimp.hpp"
#include "universalid.hpp"
#include "nestedtablewrapper.hpp"

class QModelIndex;
class QAbstractItemModel;

namespace CSMWorld
{
    class IdTable;
    class IdTree;
    struct RecordBase;
    struct NestedTableWrapperBase;

    class TouchCommand : public QUndoCommand
    {
        public:

            TouchCommand(IdTable& model, const std::string& id, QUndoCommand* parent=nullptr);

            void redo() override;
            void undo() override;

        private:

            IdTable& mTable;
            std::string mId;
            std::unique_ptr<RecordBase> mOld;

            bool mChanged;
    };

    class ImportLandTexturesCommand : public QUndoCommand
    {
        public:

            ImportLandTexturesCommand(IdTable& landTable, IdTable& ltexTable,
                QUndoCommand* parent);

            void redo() override;
            void undo() override;

        protected:

            using DataType = LandTexturesColumn::DataType;

            virtual const std::string& getOriginId() const = 0;
            virtual const std::string& getDestinationId() const = 0;

            virtual void onRedo() = 0;
            virtual void onUndo() = 0;

            IdTable& mLands;
            IdTable& mLtexs;
            DataType mOld;
            int mOldState;
            std::vector<std::string> mCreatedTextures;
    };

    class CopyLandTexturesCommand : public ImportLandTexturesCommand
    {
        public:

            CopyLandTexturesCommand(IdTable& landTable, IdTable& ltexTable, const std::string& origin,
                const std::string& dest, QUndoCommand* parent = nullptr);

        private:

            const std::string& getOriginId() const override;
            const std::string& getDestinationId() const override;

            void onRedo() override {}
            void onUndo() override {}

            std::string mOriginId;
            std::string mDestId;
    };

    class TouchLandCommand : public ImportLandTexturesCommand
    {
        public:

            TouchLandCommand(IdTable& landTable, IdTable& ltexTable,
                const std::string& id, QUndoCommand* parent = nullptr);

        private:

            const std::string& getOriginId() const override;
            const std::string& getDestinationId() const override;

            void onRedo() override;
            void onUndo() override;

            std::string mId;
            std::unique_ptr<RecordBase> mOld;

            bool mChanged;
    };

    class ModifyCommand : public QUndoCommand
    {
            QAbstractItemModel *mModel;
            QModelIndex mIndex;
            QVariant mNew;
            QVariant mOld;

            bool mHasRecordState;
            QModelIndex mRecordStateIndex;
            CSMWorld::RecordBase::State mOldRecordState;

        public:

            ModifyCommand (QAbstractItemModel& model, const QModelIndex& index, const QVariant& new_,
                QUndoCommand *parent = 0);

            virtual void redo();

            virtual void undo();
    };

    class CreateCommand : public QUndoCommand
    {
            std::map<int, QVariant> mValues;
            std::map<int, std::pair<int, QVariant> > mNestedValues;

        protected:

            IdTable& mModel;
            std::string mId;
            UniversalId::Type mType;

        protected:

            void applyModifications();

        public:

            CreateCommand (IdTable& model, const std::string& id, QUndoCommand *parent = 0);

            void setType (UniversalId::Type type);

            void addValue (int column, const QVariant& value);

            void addNestedValue(int parentColumn, int nestedColumn, const QVariant &value);

            virtual void redo();

            virtual void undo();
    };

    class CloneCommand : public CreateCommand
    {
            std::string mIdOrigin;

        public:

            CloneCommand (IdTable& model, const std::string& idOrigin,
                          const std::string& IdDestination,
                          const UniversalId::Type type,
                          QUndoCommand* parent = 0);

            virtual void redo();

            virtual void undo();
    };

    class RevertCommand : public QUndoCommand
    {
            IdTable& mModel;
            std::string mId;
            RecordBase *mOld;

            // not implemented
            RevertCommand (const RevertCommand&);
            RevertCommand& operator= (const RevertCommand&);

        public:

            RevertCommand (IdTable& model, const std::string& id, QUndoCommand *parent = 0);

            virtual ~RevertCommand();

            virtual void redo();

            virtual void undo();
    };

    class DeleteCommand : public QUndoCommand
    {
            IdTable& mModel;
            std::string mId;
            RecordBase *mOld;
            UniversalId::Type mType;

            // not implemented
            DeleteCommand (const DeleteCommand&);
            DeleteCommand& operator= (const DeleteCommand&);

        public:

            DeleteCommand (IdTable& model, const std::string& id,
                    UniversalId::Type type = UniversalId::Type_None, QUndoCommand *parent = 0);

            virtual ~DeleteCommand();

            virtual void redo();

            virtual void undo();
    };

    class ReorderRowsCommand : public QUndoCommand
    {
            IdTable& mModel;
            int mBaseIndex;
            std::vector<int> mNewOrder;

        public:

            ReorderRowsCommand (IdTable& model, int baseIndex, const std::vector<int>& newOrder);

            virtual void redo();

            virtual void undo();
    };

    class CreatePathgridCommand : public CreateCommand
    {
        public:

            CreatePathgridCommand(IdTable& model, const std::string& id, QUndoCommand *parent = 0);

            virtual void redo();
    };

    class UpdateCellCommand : public QUndoCommand
    {
            IdTable& mModel;
            int mRow;
            QModelIndex mIndex;
            QVariant mNew; // invalid, if new cell ID has not been calculated yet
            QVariant mOld;

        public:

            UpdateCellCommand (IdTable& model, int row, QUndoCommand *parent = 0);

            virtual void redo();

            virtual void undo();
    };


    class NestedTableStoring
    {
        NestedTableWrapperBase* mOld;

    public:
        NestedTableStoring(const IdTree& model, const std::string& id, int parentColumn);

        ~NestedTableStoring();

    protected:

        const NestedTableWrapperBase& getOld() const;
    };

    class DeleteNestedCommand : public QUndoCommand, private NestedTableStoring
    {
            IdTree& mModel;

            std::string mId;

            int mParentColumn;

            int mNestedRow;

            // The command to redo/undo the Modified status of a record
            ModifyCommand *mModifyParentCommand;

        public:

            DeleteNestedCommand (IdTree& model, const std::string& id, int nestedRow, int parentColumn, QUndoCommand* parent = 0);

            virtual void redo();

            virtual void undo();
    };

    class AddNestedCommand : public QUndoCommand, private NestedTableStoring
    {
            IdTree& mModel;

            std::string mId;

            int mNewRow;

            int mParentColumn;

            // The command to redo/undo the Modified status of a record
            ModifyCommand *mModifyParentCommand;

        public:

            AddNestedCommand(IdTree& model, const std::string& id, int nestedRow, int parentColumn, QUndoCommand* parent = 0);

            virtual void redo();

            virtual void undo();
    };
}

#endif