RStorage.h

Go to the documentation of this file.

 
#ifndef RSTORAGE_H
#define RSTORAGE_H
 
#include "core_global.h"
 
#include <QString>
#include <QSharedPointer>
#include <QDateTime>
 
#include "RColor.h"
#include "RLinetype.h"
#include "RLinetypePattern.h"
#include "RLineweight.h"
#include "RNonCopyable.h"
#include "RRequireHeap.h"
#include "RUcs.h"
 
class RBlock;
class RBox;
class RDimStyle;
class RDocument;
class RDocumentVariables;
class REntity;
class RLayer;
class RLayerState;
class RLayout;
class RModifiedListener;
class RTransaction;
class RView;
 
#ifndef RDEFAULT_QSTRING
#define RDEFAULT_QSTRING QString()
#endif
 
 
 
class QCADCORE_EXPORT RStorage : RNonCopyable, public RRequireHeap {
public:
    RStorage();
    virtual ~RStorage() { }
 
    void setDocument(RDocument* doc) {
        document = doc;
    }
 
    RDocument* getDocument() const {
        return document;
    }
 
    virtual void clear();
 
    virtual void beginTransaction() = 0;
 
    virtual void commitTransaction() = 0;
 
    virtual void rollbackTransaction() = 0;
 
    virtual QList<RObject::Id> orderBackToFront(const QSet<RObject::Id>& entityIds) const;
 
    QList<RObject::Id> sortBlocks(const QList<RObject::Id>& blockIds) const;
 
    QList<RObject::Id> sortLayers(const QList<RObject::Id>& layerIds) const;
 
    static bool lessThan(const QPair<RObject::Id, int>& p1, const QPair<RObject::Id, int>& p2);
 
    virtual QSet<RObject::Id> queryAllObjects() const = 0;
 
    virtual QSet<RObject::Id> queryAllVisibleEntities() = 0;
 
    virtual QSet<RObject::Id> queryAllEntities(bool undone = false,
            bool allBlocks = false, RS::EntityType type = RS::EntityAll) = 0;
 
    virtual QSet<RObject::Id> queryAllEntities(bool undone,
            bool allBlocks, QList<RS::EntityType> types) = 0;
 
    virtual QSet<RObject::Id> queryWorkingSetEntities() = 0;
 
    virtual QSet<RObject::Id> queryAllUcs() = 0;
 
    virtual QSet<RObject::Id> queryAllLayers(bool undone = false) = 0;
 
    virtual QSet<RObject::Id> queryAllLayerStates(bool undone = false) const = 0;
 
    virtual QSet<RObject::Id> queryAllBlocks(bool undone = false) = 0;
 
    virtual QSet<RObject::Id> queryAllLayoutBlocks(bool includeModelSpace = false, bool undone = false) const = 0;
 
    virtual QSet<RObject::Id> queryAllLayouts(bool undone = false) = 0;
 
    virtual QSet<RObject::Id> queryAllViews(bool undone = false) = 0;
 
    virtual QSet<RObject::Id> queryAllLinetypes() = 0;
 
    virtual QSet<RObject::Id> queryLayerEntities(RObject::Id layerId, bool allBlocks = false) = 0;
 
    virtual QSet<RObject::Id> querySelectedLayerEntities(RObject::Id layerId, bool allBlocks = false) = 0;
 
    virtual bool hasBlockEntities(RObject::Id blockId) const = 0;
 
    virtual QSet<RObject::Id> queryBlockEntities(RObject::Id blockId) = 0;
 
    virtual QSet<RObject::Id> queryLayerBlockEntities(RObject::Id layerId, RObject::Id blockId) = 0;
 
    virtual QSet<RObject::Id> queryChildEntities(RObject::Id parentId, RS::EntityType type = RS::EntityAll) = 0;
 
    virtual bool hasChildEntities(RObject::Id parentId) const = 0;
 
    virtual QSet<RObject::Id> queryBlockReferences(RObject::Id blockId) const = 0;
 
    virtual QSet<RObject::Id> queryAllBlockReferences() const = 0;
 
    virtual QSet<RObject::Id> queryAllViewports() const = 0;
 
    virtual QSet<RObject::Id> querySelectedEntities() const = 0;
 
    virtual QSet<RObject::Id> querySelectedLayers() const = 0;
 
    virtual QSet<RObject::Id> queryInfiniteEntities() const = 0;
 
    virtual QSharedPointer<RDocumentVariables> queryDocumentVariables() const = 0;
    virtual QSharedPointer<RDocumentVariables> queryDocumentVariablesDirect() const = 0;
 
    virtual QSharedPointer<RDimStyle> queryDimStyle() const = 0;
    virtual QSharedPointer<RDimStyle> queryDimStyleDirect() const = 0;
 
    virtual QSharedPointer<RObject> queryObject(RObject::Id objectId) const = 0;
 
    virtual QSharedPointer<RObject> queryObjectDirect(RObject::Id objectId) const {
        return queryObject(objectId);
    }
    virtual RObject* queryObjectCC(RObject::Id objectId) const = 0;
    virtual QSharedPointer<RObject> queryObjectByHandle(RObject::Handle objectHandle) const = 0;
 
    virtual QSharedPointer<REntity> queryEntity(RObject::Id entityId) const = 0;
 
    virtual QSharedPointer<REntity> queryEntityDirect(RObject::Id entityId) const;
 
    virtual QSharedPointer<REntity> queryVisibleEntityDirect(RObject::Id entityId) const;
 
    virtual QSharedPointer<RUcs> queryUcs(RObject::Id ucsId) const = 0;
 
    virtual QSharedPointer<RUcs> queryUcsDirect(RObject::Id ucsId) const {
        return queryUcs(ucsId);
    }
 
    virtual QSharedPointer<RUcs> queryUcs(const QString& ucsName) const = 0;
 
    virtual QSharedPointer<RLayer> queryLayer(RObject::Id layerId) const = 0;
 
    virtual QSharedPointer<RLayer> queryLayerDirect(RObject::Id layerId) const {
        return queryLayer(layerId);
    }
    virtual QSharedPointer<RLayer> queryLayerDirect(const QString& layerName) const {
        return queryLayerDirect(getLayerId(layerName));
    }
 
    virtual QSharedPointer<RLayer> queryLayer(const QString& layerName) const = 0;
 
    virtual QSharedPointer<RLayer> queryCurrentLayer() {
        return queryLayer(getCurrentLayerId());
    }
 
    virtual QSharedPointer<RLayerState> queryLayerState(RObject::Id layerStateId) const = 0;
 
    virtual QSharedPointer<RLayerState> queryLayerStateDirect(RObject::Id layerStateId) const {
        return queryLayerState(layerStateId);
    }
    virtual QSharedPointer<RLayerState> queryLayerStateDirect(const QString& layerStateName) const {
        return queryLayerStateDirect(getLayerStateId(layerStateName));
    }
 
    virtual QSharedPointer<RLayerState> queryLayerState(const QString& layerStateName) const = 0;
 
 
    virtual QSharedPointer<RLayout> queryLayout(RObject::Id layoutId) const = 0;
 
    virtual QSharedPointer<RLayout> queryLayoutDirect(RObject::Id layoutId) const {
        return queryLayout(layoutId);
    }
 
    virtual QSharedPointer<RLayout> queryLayout(const QString& layoutName) const = 0;
 
    virtual QSharedPointer<RView> queryCurrentView() {
        return queryView(getCurrentViewId());
    }
 
    virtual QSharedPointer<RLinetype> queryLinetypeDirect(RObject::Id linetypeId) const = 0;
    virtual QSharedPointer<RLinetype> queryLinetype(RObject::Id linetypeId) const = 0;
    virtual QSharedPointer<RLinetype> queryLinetype(const QString& linetypeName) const = 0;
 
    virtual QSharedPointer<RBlock> queryBlockDirect(RObject::Id blockId) const = 0;
    virtual QSharedPointer<RBlock> queryBlockDirect(const QString& blockName) const {
        return queryBlockDirect(getBlockId(blockName));
    }
    virtual QSharedPointer<RBlock> queryBlock(RObject::Id blockId) const = 0;
    virtual QSharedPointer<RBlock> queryBlock(const QString& blockName) const = 0;
 
    virtual QSharedPointer<RView> queryView(RObject::Id viewId) const = 0;
    virtual QSharedPointer<RView> queryView(const QString& viewName) const = 0;
 
    void setCurrentLayer(RObject::Id layerId, RTransaction* transaction=NULL);
    void setCurrentLayer(const QString& layerName, RTransaction* transaction=NULL);
 
    virtual RObject::Id getCurrentLayerId() const;
    virtual RObject::Id getCurrentViewId() const {
        return currentViewId;
    }
 
    virtual void setCurrentColor(const RColor& color);
    virtual RColor getCurrentColor() const;
 
    void setCurrentLineweight(RLineweight::Lineweight lw);
    virtual RLineweight::Lineweight getCurrentLineweight() const;
 
    void setCurrentLinetype(RObject::Id ltId);
    void setCurrentLinetype(const QString& name);
    void setCurrentLinetypePattern(const RLinetypePattern& p);
    virtual RObject::Id getCurrentLinetypeId() const;
    virtual RLinetypePattern getCurrentLinetypePattern() const;
    virtual QSharedPointer<RLinetype> queryCurrentLinetype() const {
        return queryLinetype(getCurrentLinetypeId());
    }
 
    virtual QSharedPointer<RBlock> queryCurrentBlock();
 
    virtual void setCurrentBlock(RObject::Id blockId);
 
    void setCurrentBlock(const QString& blockName) {
        RObject::Id id = getBlockId(blockName);
        if (id == RObject::INVALID_ID) {
            return;
        }
        setCurrentBlock(id);
    }
 
    virtual RObject::Id getCurrentBlockId() const {
        return currentBlockId;
    }
 
    virtual void setCurrentViewport(RObject::Id viewportId) {
        currentViewportId = viewportId;
    }
 
    virtual void unsetCurrentViewport() {
        currentViewportId = RObject::INVALID_ID;
    }
 
    virtual RObject::Id getCurrentViewportId() const {
        return currentViewportId;
    }
 
    virtual void setModelSpaceBlockId(RObject::Id id) {
        modelSpaceBlockId = id;
    }
    virtual RObject::Id getModelSpaceBlockId() const {
        return modelSpaceBlockId;
    }
 
    void setCurrentView(RObject::Id viewId) {
        currentViewId = viewId;
    }
 
    void setCurrentView(const QString& viewName) {
        RObject::Id id = getViewId(viewName);
        // unlike blocks and layers, the current view can be invalid:
        setCurrentView(id);
    }
 
    QSharedPointer<RDocumentVariables> startDocumentVariablesTransaction(RTransaction*& transaction, bool& useLocalTransaction);
    void endDocumentVariablesTransaction(RTransaction* transaction, bool useLocalTransaction, QSharedPointer<RDocumentVariables> docVars);
 
    void setUnit(RS::Unit unit, RTransaction* transaction=NULL);
    RS::Unit getUnit() const;
 
    void setMeasurement(RS::Measurement m, RTransaction* transaction=NULL);
    RS::Measurement getMeasurement() const;
 
    virtual void setDimensionFont(const QString& f, RTransaction* transaction=NULL);
    virtual QString getDimensionFont() const;
 
    virtual void setLinetypeScale(double v, RTransaction* transaction=NULL);
    virtual double getLinetypeScale() const;
 
    virtual QString getBlockName(RObject::Id blockId) const = 0;
    virtual QString getBlockNameFromHandle(RObject::Handle blockHandle) const = 0;
    virtual QString getBlockNameFromLayout(const QString& layoutName) const = 0;
    virtual QString getBlockNameFromLayout(RObject::Id layoutId) const = 0;
    virtual QSet<QString> getBlockNames(const QString& rxStr = RDEFAULT_QSTRING, bool undone = false) const = 0;
    virtual RObject::Id getBlockId(const QString& blockName) const = 0;
    virtual RObject::Id getBlockIdAuto(const QString& blockLayoutName) const = 0;
    virtual bool hasBlock(const QString& blockName) const;
 
    virtual QString getViewName(RObject::Id viewId) const = 0;
    virtual QSet<QString> getViewNames() const = 0;
    virtual RObject::Id getViewId(const QString& viewName) const = 0;
    virtual bool hasView(const QString& viewName) const;
 
    virtual QString getLayerName(RObject::Id layerId) const = 0;
    virtual QSet<QString> getLayerNames(const QString& rxStr = RDEFAULT_QSTRING) const = 0;
    virtual RObject::Id getLayerId(const QString& layerName) const = 0;
    virtual void setLayer0Id(RObject::Id id) {
        layer0Id = id;
    }
    virtual RObject::Id getLayer0Id() const {
        return layer0Id;
    }
    virtual bool hasLayer(const QString& layerName) const;
 
    virtual QString getLayerStateName(RObject::Id layerStateId) const = 0;
    virtual QSet<QString> getLayerStateNames(const QString& rxStr = RDEFAULT_QSTRING) const = 0;
    virtual RObject::Id getLayerStateId(const QString& layerStateName) const = 0;
    virtual bool hasLayerStates() const;
    virtual bool hasLayerState(const QString& layerStateName) const;
 
    virtual QString getLayoutName(RObject::Id layoutId) const = 0;
    virtual QSet<QString> getLayoutNames(const QString& rxStr = RDEFAULT_QSTRING) const = 0;
    virtual RObject::Id getLayoutId(const QString& layoutName) const = 0;
    virtual bool hasLayout(const QString& layoutName) const;
 
    virtual QString getLinetypeName(RObject::Id linetypeId) const = 0;
    virtual QString getLinetypeDescription(RObject::Id linetypeId) const = 0;
    virtual QString getLinetypeLabel(RObject::Id linetypeId) const = 0;
    virtual QSet<QString> getLinetypeNames() const = 0;
    virtual QList<RLinetypePattern> getLinetypePatterns() const = 0;
    virtual RObject::Id getLinetypeId(const QString& linetypeName) const = 0;
    virtual bool hasLinetype(const QString& linetypeName) const;
 
    virtual QStringList getVariables() const = 0;
    virtual void setVariable(const QString& key, const QVariant& value, bool overwrite=true) = 0;
    virtual void removeVariable(const QString& key) = 0;
    virtual QVariant getVariable(const QString& key) const = 0;
 
    virtual bool hasVariable(const QString& key) const {
        QVariant value = getVariable(key);
        return value.isValid();
    }
 
    virtual void setKnownVariable(RS::KnownVariable key, const QVariant& value, RTransaction* transaction = NULL) = 0;
 
    virtual QVariant getKnownVariable(RS::KnownVariable key) const = 0;
 
    virtual int countSelectedEntities() const {
        return querySelectedEntities().size();
    }
 
    virtual void clearEntitySelection(
        QSet<RObject::Id>* affectedEntities=NULL
    ) = 0;
 
    virtual void selectAllEntities(QSet<RObject::Id>* affectedEntities = NULL) = 0;
 
    virtual void selectEntity(
        RObject::Id entityId,
        bool add=false,
        QSet<RObject::Id>* affectedEntities=NULL
    ) = 0;
 
    virtual int selectEntities(
        const QSet<RObject::Id>& entityIds,
        bool add=false,
        QSet<RObject::Id>* affectedEntities=NULL
    ) = 0;
 
    virtual void deselectEntity(
        RObject::Id entityId,
        QSet<RObject::Id>* affectedEntities=NULL
    ) = 0;
 
    virtual int deselectEntities(
        const QSet<RObject::Id>& entityIds,
        QSet<RObject::Id>* affectedEntities=NULL
    ) = 0;
 
    virtual bool isSelected(RObject::Id entityId);
 
    virtual bool isSelectedWorkingSet(RObject::Id entityId);
 
    virtual bool isEntity(RObject::Id objectId);
 
    virtual bool isLayerLocked(RObject::Id layerId) const;
    virtual bool isLayerLocked(const RLayer& layer) const;
    virtual bool isParentLayerLocked(RObject::Id layerId) const;
    virtual bool isParentLayerLocked(const RLayer& layer) const;
 
    virtual bool isLayerOff(RObject::Id layerId) const;
    virtual bool isLayerOff(const RLayer& layer) const;
 
    virtual bool isLayerOffOrFrozen(RObject::Id layerId) const;
    virtual bool isLayerOffOrFrozen(const RLayer& layer) const;
 
    virtual bool isLayerFrozen(RObject::Id layerId) const;
    virtual bool isLayerFrozen(const RLayer& layer) const;
    virtual bool isParentLayerFrozen(RObject::Id layerId) const;
    virtual bool isParentLayerFrozen(const RLayer& layer) const;
 
    virtual bool isLayerSnappable(RObject::Id layerId) const;
    virtual bool isLayerSnappable(const RLayer& layer) const;
    virtual bool isParentLayerSnappable(RObject::Id layerId) const;
    virtual bool isParentLayerSnappable(const RLayer& layer) const;
 
    virtual bool isLayerPlottable(RObject::Id layerId) const;
    virtual bool isLayerPlottable(const RLayer& layer) const;
    virtual bool isParentLayerPlottable(RObject::Id layerId) const;
    virtual bool isParentLayerPlottable(const RLayer& layer) const;
 
    virtual bool isEntityVisible(const REntity& entity, RObject::Id blockId) const;
 
    virtual bool isBlockFrozen(RObject::Id blockId) const;
 
    virtual bool isLayoutBlock(RObject::Id blockId) const;
 
    virtual void setObjectId(RObject& object, RObject::Id objectId) const;
    virtual void setObjectHandle(RObject& object, RObject::Handle objectHandle);
 
    virtual void setEntityParentId(REntity& entity, RObject::Id parentId);
 
    virtual void setUndoStatus(RObject& object, bool status);
 
    virtual bool hasSelection() const = 0;
 
    virtual RBox getBoundingBox(bool ignoreHiddenLayers = true, bool ignoreEmpty = false) const = 0;
 
    virtual RBox getSelectionBox() const = 0;
    virtual RBox getEntitiesBox(QSet<RObject::Id>& ids) const = 0;
 
    virtual bool removeObject(QSharedPointer<RObject> object) = 0;
 
    virtual bool saveObject(QSharedPointer<RObject> object, bool checkBlockRecursion = true, bool keepHandles = false, bool* overwrite = NULL) = 0;
 
    virtual bool deleteObject(RObject::Id objectId) = 0;
 
    virtual int getLastTransactionId() {
        return lastTransactionId;
    }
 
    virtual void setLastTransactionId(int transactionId) {
        lastTransactionId = transactionId;
 
        setModified(true);
    }
 
    virtual void startTransactionGroup() {
        lastTransactionGroup++;
    }
 
    virtual int getTransactionGroup() const {
        return lastTransactionGroup;
    }
 
    virtual void saveTransaction(RTransaction& transaction) = 0;
 
    virtual void deleteTransactionsFrom(int transactionId) = 0;
 
    virtual void resetTransactionStack() = 0;
 
    virtual RTransaction getTransaction(int transactionId) = 0;
 
    virtual void toggleUndoStatus(QSet<RObject::Id>& objects) = 0;
 
    virtual void toggleUndoStatus(RObject::Id object) = 0;
 
    virtual bool setUndoStatus(RObject::Id object, bool status) = 0;
 
    //virtual bool getUndoStatus(RObject::Id object) const = 0;
 
    virtual int getMaxTransactionId() = 0;
 
    virtual RLineweight::Lineweight getMaxLineweight() const = 0;
 
    virtual RObject::Id getNewObjectId();
    virtual RObject::Id getMaxObjectId();
    virtual RObject::Handle getNewObjectHandle();
    virtual RObject::Handle getMaxObjectHandle();
 
    virtual void setMaxDrawOrder(int m) {
        maxDrawOrder = m;
    }
 
    virtual int getMaxDrawOrder() {
        return maxDrawOrder;
    }
 
    virtual int getMinDrawOrder();
 
    virtual bool isInBackStorage(RObject::Id /*object*/) {
        return false;
    }
 
    static QString getKnownVariableName(RS::KnownVariable n);
 
    friend QDebug operator<<(QDebug dbg, RStorage& s);
 
    void setModified(bool m);
 
    bool isModified() const {
        return modified;
    }
 
    QDateTime getLastModifiedDateTime() const {
        return lastModified;
    }
 
    QString getLastModified() const {
        return lastModified.toString("yyyyMMddHHmmsszzz");
    }
 
    void addModifiedListener(RModifiedListener* l);
 
    virtual void update() {}
 
    void setNotifyListeners(bool on) {
        notifyGlobalListeners = on;
    }
    bool getNotifyListeners() const {
        return notifyGlobalListeners;
    }
 
    static void registerCustomEntityType(RS::EntityType type);
    static void unregisterCustomEntityType(RS::EntityType type);
 
//    RObject::Id getWorkingSetBlockReferenceId() const;
//    void setWorkingSetBlockReferenceId(RObject::Id id, int group = -1, RTransaction* transaction = NULL);
 
protected:
    QDateTime lastModified;
    bool modified;
    RObject::Handle handleCounter;
 
    static QList<RS::EntityType> customEntityTypes;
 
private:
    RDocument* document;
    int maxDrawOrder;
    RObject::Id idCounter;
    RColor currentColor;
    RLineweight::Lineweight currentLineweight;
    RObject::Id currentLinetypeId;
    RObject::Id currentViewId;
    RObject::Id currentBlockId;
    RObject::Id currentViewportId;
    RObject::Id modelSpaceBlockId;
    RObject::Id layer0Id;
 
    int lastTransactionId;
    int lastTransactionGroup;
 
    QList<RModifiedListener*> modifiedListeners;
    bool notifyGlobalListeners;
 
};
 
Q_DECLARE_METATYPE(RStorage*)
Q_DECLARE_METATYPE(const RStorage*)
 
#endif