RTransaction.h

Go to the documentation of this file.

 
#ifndef RTRANSACTION_H
#define RTRANSACTION_H
 
#include "core_global.h"
 
#include <QList>
#include <QMap>
#include <QSet>
#include <QSharedPointer>
 
#include "RObject.h"
#include "RPropertyTypeId.h"
#include "RPropertyChange.h"
 
class RBlock;
class RStorage;
 
#define RDEFAULT_QSET_RPROPERTYTYPEID QSet<RPropertyTypeId> ()
 
class QCADCORE_EXPORT RTransaction {
public:
    enum Type {
        Generic = 0x0000,
        CurrentLayerChange = 0x0001,
        CurrentLayerSelectionChange = 0x0002,
        LayerLockStatusChange = 0x0004,
        LayerVisibilityStatusChange = 0x0008,
        SaveWorkingSet = 0x0010,
        ChangeDocumentSetting = 0x0020,
        Undo = 0x0040,
        Redo = 0x0080
    };
    Q_DECLARE_FLAGS(Types, Type)
 
public:
    RTransaction();
 
    RTransaction(RStorage& storage);
 
    RTransaction(RStorage& storage, int transactionId, const QString& text,
            const QList<RObject::Id>& affectedObjectIds,
            //const QSet<RObject::Id>& affectedEntities,
            const QMap<RObject::Id, QList<RPropertyChange> >& propertyChanges);
            //RTransaction* parent = NULL);
 
    RTransaction(RStorage& storage, const QString& text, bool undoable = true);
            //RTransaction* parent = NULL);
 
    virtual ~RTransaction();
 
    void setRecordAffectedObjects(bool on) {
        recordAffectedObjects = on;
    }
 
    void setAllowAll(bool on) {
        allowAll = on;
    }
 
    void setAllowInvisible(bool on) {
        allowInvisible = on;
    }
 
    void setSpatialIndexDisabled(bool on) {
        spatialIndexDisabled = on;
    }
 
    void setExistingBlockDetectionDisabled(bool on) {
        existingBlockDetectionDisabled = on;
    }
 
    void setExistingLayerDetectionDisabled(bool on) {
        existingLayerDetectionDisabled = on;
    }
 
    void setExistingLinetypeDetectionDisabled(bool on) {
        existingLinetypeDetectionDisabled = on;
    }
 
    void setBlockRecursionDetectionDisabled(bool on) {
        blockRecursionDetectionDisabled = on;
    }
 
    void setKeepHandles(bool on) {
        keepHandles = on;
    }
 
    void setKeepChildren(bool on) {
        keepChildren = on;
    }
 
//    void setUndoing(bool on) {
//        undoing = on;
//    }
 
    bool isUndoing() {
        return undoing;
    }
 
//    void setRedoing(bool on) {
//        redoing = on;
//    }
 
    bool isRedoing() {
        return redoing;
    }
 
    bool isUndoable() const {
        return undoable;
    }
 
    bool isFailed() const {
        return failed;
    }
 
    virtual void redo();
 
    virtual void undo();
 
    void end();
 
    void updateAffectedBlockReferences();
 
    void setId(int id) {
        transactionId = id;
    }
 
    int getId() const {
        return transactionId;
    }
 
    void setGroup(int group) {
        transactionGroup = group;
    }
 
    int getGroup() const {
        return transactionGroup;
    }
 
    QString getText() const {
        return text;
    }
 
    bool overwriteBlock(QSharedPointer<RBlock> block);
 
    bool addObject(QSharedPointer<RObject> obj,
                   bool useCurrentAttributes = true,
                   bool forceNew = false,
                   const QSet<RPropertyTypeId>& modifiedPropertyTypeIds = RDEFAULT_QSET_RPROPERTYTYPEID);
 
    void addAffectedObject(RObject::Id objectId);
    void addAffectedObjects(const QSet<RObject::Id>& objectIds);
    void addAffectedObject(QSharedPointer<RObject> object);
 
    void deleteObject(RObject::Id objectId, bool force = false);
    void deleteObject(QSharedPointer<RObject> object, bool force = false);
 
    QList<RObject::Id> getAffectedObjects() const {
        return affectedObjectIds;
    }
 
    QSet<RObject::Id> getStatusChanges() const {
        return statusChanges;
    }
 
    bool hasStatusChange(RObject::Id id) const {
        return statusChanges.contains(id);
    }
 
    QMap<RObject::Id, QList<RPropertyChange> > getPropertyChanges() const {
        return propertyChanges;
    }
 
    RObject::Id getNewObjectId(RObject::Id oldId) const;
 
    QList<RPropertyChange> getPropertyChanges(RObject::Id id) const;
 
    bool hasOnlyChanges() const {
        return onlyChanges;
    }
 
    void fail();
 
    void endCycle();
 
    bool isPreview() const;
 
    void setTypes(RTransaction::Types t) {
        types = t;
    }
    RTransaction::Types getTypes() const {
        return types;
    }
    void setType(RTransaction::Type type, bool on = true);
    bool isType(RTransaction::Type type) const;
 
protected:
    bool addPropertyChange(RObject::Id objectId, const RPropertyChange& propertyChange);
    //void appendChild(RTransaction& t);
 
    void commit();
    void rollback();
 
protected:
    RTransaction::Types types;
 
    RStorage* storage;
 
    int transactionId;
 
    int transactionGroup;
 
    QString text;
 
    QList<RObject::Id> affectedObjectIds;
    QSet<RObject::Id> affectedObjectIdsSet;
 
    QSet<RObject::Id> affectedBlockReferenceIds;
 
    QMap<RObject::Id, QList<RPropertyChange> > propertyChanges;
 
    QSet<RObject::Id> statusChanges;
 
    //QList<RTransaction> childTransactions;
 
    bool undoable;
 
    bool failed;
 
    bool onlyChanges;
 
    bool recordAffectedObjects;
 
    bool allowAll;
 
    bool allowInvisible;
 
    bool spatialIndexDisabled;
 
    bool existingBlockDetectionDisabled;
 
    bool existingLayerDetectionDisabled;
 
    bool existingLinetypeDetectionDisabled;
 
    bool blockRecursionDetectionDisabled;
 
    bool deletingBlock;
 
    QStringList usedBlockNames;
 
    bool keepHandles;
 
    bool keepChildren;
 
    QMap<RObject::Id, RObject::Id> cloneIds;
 
    bool undoing;
    bool redoing;
};
 
QCADCORE_EXPORT QDebug operator<<(QDebug dbg, RTransaction& t);
 
Q_DECLARE_OPERATORS_FOR_FLAGS(RTransaction::Types)
Q_DECLARE_METATYPE(RTransaction)
Q_DECLARE_METATYPE(RTransaction*)
Q_DECLARE_METATYPE(RTransaction::Type)
Q_DECLARE_METATYPE(RTransaction::Type*)
Q_DECLARE_METATYPE(QFlags<RTransaction::Type>)
Q_DECLARE_METATYPE(QFlags<RTransaction::Type>*)
 
#endif