RStorage.h

Go to the documentation of this file.

 
#ifndef RSTORAGE_H
#define RSTORAGE_H
 
#include "core_global.h"
 
#include <QString>
#include <QSharedPointer>
 
#include "RBlock.h"
#include "RBlockReferenceEntity.h"
#include "RBox.h"
#include "RDocumentVariables.h"
#include "REntity.h"
#include "RLayer.h"
#include "RLayerState.h"
#include "RLinetype.h"
#include "RLinetypePattern.h"
#include "RModifiedListener.h"
#include "RNonCopyable.h"
#include "RRequireHeap.h"
#include "RTransaction.h"
#include "RUcs.h"
#include "RView.h"
#include "RViewportEntity.h"
 
class RDocument;
 
#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<REntity::Id> orderBackToFront(const QSet<REntity::Id>& entityIds) const;
 
    QList<RBlock::Id> sortBlocks(const QList<RBlock::Id>& blockIds) const;
 
    QList<RLayer::Id> sortLayers(const QList<RLayer::Id>& layerIds) const;
 
    static bool lessThan(const QPair<REntity::Id, int>& p1, const QPair<REntity::Id, int>& p2);
 
    virtual QSet<RObject::Id> queryAllObjects() const = 0;
 
    virtual QSet<REntity::Id> queryAllVisibleEntities() = 0;
 
    virtual QSet<REntity::Id> queryAllEntities(bool undone = false,
            bool allBlocks = false, RS::EntityType type = RS::EntityAll) = 0;
 
    virtual QSet<REntity::Id> queryAllEntities(bool undone,
            bool allBlocks, QList<RS::EntityType> types) = 0;
 
    virtual QSet<REntity::Id> queryWorkingSetEntities() = 0;
 
    virtual QSet<RUcs::Id> queryAllUcs() = 0;
 
    virtual QSet<RLayer::Id> queryAllLayers(bool undone = false) = 0;
 
    virtual QSet<RLayerState::Id> queryAllLayerStates(bool undone = false) const = 0;
 
    virtual QSet<RBlock::Id> queryAllBlocks(bool undone = false) = 0;
 
    virtual QSet<RBlock::Id> queryAllLayoutBlocks(bool includeModelSpace = false, bool undone = false) const = 0;
 
    virtual QSet<RLayout::Id> queryAllLayouts(bool undone = false) = 0;
 
    virtual QSet<RView::Id> queryAllViews(bool undone = false) = 0;
 
    virtual QSet<RLinetype::Id> queryAllLinetypes() = 0;
 
    virtual QSet<REntity::Id> queryLayerEntities(RLayer::Id layerId, bool allBlocks = false) = 0;
 
    virtual bool hasBlockEntities(RBlock::Id blockId) const = 0;
 
    virtual QSet<REntity::Id> queryBlockEntities(RBlock::Id blockId) = 0;
 
    virtual QSet<REntity::Id> queryLayerBlockEntities(RLayer::Id layerId, RBlock::Id blockId) = 0;
 
    virtual QSet<REntity::Id> queryChildEntities(REntity::Id parentId, RS::EntityType type = RS::EntityAll) = 0;
 
    virtual bool hasChildEntities(REntity::Id parentId) const = 0;
 
    virtual QSet<REntity::Id> queryBlockReferences(RBlock::Id blockId) const = 0;
 
    virtual QSet<REntity::Id> queryAllBlockReferences() const = 0;
 
    virtual QSet<REntity::Id> queryAllViewports() const = 0;
 
    virtual QSet<REntity::Id> querySelectedEntities() const = 0;
 
    virtual QSet<RObject::Id> querySelectedLayers() const = 0;
 
    virtual QSet<REntity::Id> queryInfiniteEntities() const = 0;
 
    virtual QSharedPointer<RDocumentVariables> queryDocumentVariables() const = 0;
    virtual QSharedPointer<RDocumentVariables> queryDocumentVariablesDirect() const = 0;
 
    virtual QSharedPointer<RObject> queryObject(RObject::Id objectId) const = 0;
 
    virtual QSharedPointer<RObject> queryObjectDirect(RObject::Id objectId) const {
        return queryObject(objectId);
    }
    virtual QSharedPointer<RObject> queryObjectByHandle(RObject::Handle objectHandle) const = 0;
 
    virtual QSharedPointer<REntity> queryEntity(REntity::Id entityId) const = 0;
 
    virtual QSharedPointer<REntity> queryEntityDirect(REntity::Id entityId) const {
        return queryEntity(entityId);
    }
 
    virtual QSharedPointer<REntity> queryVisibleEntityDirect(REntity::Id entityId) const {
        QSharedPointer<REntity> ret = queryEntityDirect(entityId);
//        if (ret->isUndone()) {
//            return QSharedPointer<REntity>();
//        }
//        if (ret->getBlockId()!=currentBlockId) {
//            return QSharedPointer<REntity>();
//        }
        if (!ret->isVisible()) {
            return QSharedPointer<REntity>();
        }
        return ret;
    }
 
    virtual QSharedPointer<RUcs> queryUcs(RUcs::Id ucsId) const = 0;
 
    virtual QSharedPointer<RUcs> queryUcsDirect(RUcs::Id ucsId) const {
        return queryUcs(ucsId);
    }
 
    virtual QSharedPointer<RUcs> queryUcs(const QString& ucsName) const = 0;
 
    virtual QSharedPointer<RLayer> queryLayer(RLayer::Id layerId) const = 0;
 
    virtual QSharedPointer<RLayer> queryLayerDirect(RLayer::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(RLayerState::Id layerStateId) const = 0;
 
    virtual QSharedPointer<RLayerState> queryLayerStateDirect(RLayerState::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(RLayout::Id layoutId) const = 0;
 
    virtual QSharedPointer<RLayout> queryLayoutDirect(RLayout::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(RLinetype::Id linetypeId) const = 0;
    virtual QSharedPointer<RLinetype> queryLinetype(RLinetype::Id linetypeId) const = 0;
    virtual QSharedPointer<RLinetype> queryLinetype(const QString& linetypeName) const = 0;
 
    virtual QSharedPointer<RBlock> queryBlockDirect(RBlock::Id blockId) const = 0;
    virtual QSharedPointer<RBlock> queryBlockDirect(const QString& blockName) const {
        return queryBlockDirect(getBlockId(blockName));
    }
    virtual QSharedPointer<RBlock> queryBlock(RBlock::Id blockId) const = 0;
    virtual QSharedPointer<RBlock> queryBlock(const QString& blockName) const = 0;
 
    virtual QSharedPointer<RView> queryView(RView::Id viewId) const = 0;
    virtual QSharedPointer<RView> queryView(const QString& viewName) const = 0;
 
    void setCurrentLayer(RLayer::Id layerId, RTransaction* transaction=NULL);
    void setCurrentLayer(const QString& layerName, RTransaction* transaction=NULL);
 
    virtual RLayer::Id getCurrentLayerId() const;
    virtual RView::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(RLinetype::Id ltId);
    void setCurrentLinetype(const QString& name);
    void setCurrentLinetypePattern(const RLinetypePattern& p);
    virtual RLinetype::Id getCurrentLinetypeId() const;
    virtual RLinetypePattern getCurrentLinetypePattern() const;
    virtual QSharedPointer<RLinetype> queryCurrentLinetype() const {
        return queryLinetype(getCurrentLinetypeId());
    }
 
    virtual QSharedPointer<RBlock> queryCurrentBlock() {
        return queryBlock(getCurrentBlockId());
    }
 
    virtual void setCurrentBlock(RBlock::Id blockId) {
        if (queryBlockDirect(blockId).isNull()) {
            currentBlockId = modelSpaceBlockId;
        }
        else {
            currentBlockId = blockId;
        }
    }
 
    void setCurrentBlock(const QString& blockName) {
        RBlock::Id id = getBlockId(blockName);
        if (id == RBlock::INVALID_ID) {
            return;
        }
        setCurrentBlock(id);
    }
 
    virtual RBlock::Id getCurrentBlockId() const {
        return currentBlockId;
    }
 
    virtual void setCurrentViewport(RObject::Id viewportId) {
        currentViewportId = viewportId;
    }
 
    virtual void unsetCurrentViewport() {
        currentViewportId = RViewportEntity::INVALID_ID;
    }
 
    virtual RObject::Id getCurrentViewportId() const {
        return currentViewportId;
    }
 
    virtual void setModelSpaceBlockId(RBlock::Id id) {
        modelSpaceBlockId = id;
    }
    virtual RBlock::Id getModelSpaceBlockId() const {
        return modelSpaceBlockId;
    }
 
    void setCurrentView(RView::Id viewId) {
        currentViewId = viewId;
    }
 
    void setCurrentView(const QString& viewName) {
        RView::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(RBlock::Id blockId) const = 0;
    virtual QString getBlockNameFromLayout(const QString& layoutName) const = 0;
    virtual QString getBlockNameFromLayout(RLayout::Id layoutId) const = 0;
    virtual QSet<QString> getBlockNames(const QString& rxStr = RDEFAULT_QSTRING) const = 0;
    virtual RBlock::Id getBlockId(const QString& blockName) const = 0;
    virtual RBlock::Id getBlockIdAuto(const QString& blockLayoutName) const = 0;
    virtual bool hasBlock(const QString& blockName) const;
 
    virtual QString getViewName(RView::Id viewId) const = 0;
    virtual QSet<QString> getViewNames() const = 0;
    virtual RView::Id getViewId(const QString& viewName) const = 0;
    virtual bool hasView(const QString& viewName) const;
 
    virtual QString getLayerName(RLayer::Id layerId) const = 0;
    virtual QSet<QString> getLayerNames(const QString& rxStr = RDEFAULT_QSTRING) const = 0;
    virtual RLayer::Id getLayerId(const QString& layerName) const = 0;
    virtual void setLayer0Id(RLayer::Id id) {
        layer0Id = id;
    }
    virtual RLayer::Id getLayer0Id() const {
        return layer0Id;
    }
    virtual bool hasLayer(const QString& layerName) const;
 
    virtual QString getLayerStateName(RLayerState::Id layerStateId) const = 0;
    virtual QSet<QString> getLayerStateNames(const QString& rxStr = RDEFAULT_QSTRING) const = 0;
    virtual RLayer::Id getLayerStateId(const QString& layerStateName) const = 0;
    virtual bool hasLayerStates() const;
    virtual bool hasLayerState(const QString& layerStateName) const;
 
    virtual QString getLayoutName(RLayout::Id layoutId) const = 0;
    virtual QSet<QString> getLayoutNames(const QString& rxStr = RDEFAULT_QSTRING) const = 0;
    virtual RLayout::Id getLayoutId(const QString& layoutName) const = 0;
    virtual bool hasLayout(const QString& layoutName) const;
 
    virtual QString getLinetypeName(RLinetype::Id linetypeId) const = 0;
    virtual QString getLinetypeDescription(RLinetype::Id linetypeId) const = 0;
    virtual QString getLinetypeLabel(RLinetype::Id linetypeId) const = 0;
    virtual QSet<QString> getLinetypeNames() const = 0;
    virtual QList<RLinetypePattern> getLinetypePatterns() const = 0;
    virtual RLinetype::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<REntity::Id>* affectedEntities=NULL
    ) = 0;
 
    virtual void selectAllEntities(QSet<REntity::Id>* affectedEntities = NULL) = 0;
 
    virtual void selectEntity(
        REntity::Id entityId,
        bool add=false,
        QSet<REntity::Id>* affectedEntities=NULL
    ) = 0;
 
    virtual int selectEntities(
        const QSet<REntity::Id>& entityIds,
        bool add=false,
        QSet<REntity::Id>* affectedEntities=NULL
    ) = 0;
 
    virtual void deselectEntity(
        REntity::Id entityId,
        QSet<REntity::Id>* affectedEntities=NULL
    ) = 0;
 
    virtual int deselectEntities(
        const QSet<REntity::Id>& entityIds,
        QSet<REntity::Id>* affectedEntities=NULL
    ) = 0;
 
    virtual bool isSelected(REntity::Id entityId) {
        QSharedPointer<REntity> e = queryEntityDirect(entityId);
        return (!e.isNull() && e->isSelected());
    }
 
    virtual bool isSelectedWorkingSet(REntity::Id entityId) {
        QSharedPointer<REntity> e = queryEntityDirect(entityId);
        return (!e.isNull() && e->isSelectedWorkingSet());
    }
 
    virtual bool isEntity(RObject::Id objectId) {
        QSharedPointer<REntity> e = queryEntityDirect(objectId);
        return !e.isNull();
    }
 
    virtual bool isLayerLocked(RLayer::Id layerId) const;
    virtual bool isLayerLocked(const RLayer& layer) const;
    virtual bool isParentLayerLocked(RLayer::Id layerId) const;
    virtual bool isParentLayerLocked(const RLayer& layer) const;
 
    virtual bool isLayerOff(RLayer::Id layerId) const;
    virtual bool isLayerOff(const RLayer& layer) const;
 
    virtual bool isLayerOffOrFrozen(RLayer::Id layerId) const;
    virtual bool isLayerOffOrFrozen(const RLayer& layer) const;
 
    virtual bool isLayerFrozen(RLayer::Id layerId) const;
    virtual bool isLayerFrozen(const RLayer& layer) const;
    virtual bool isParentLayerFrozen(RLayer::Id layerId) const;
    virtual bool isParentLayerFrozen(const RLayer& layer) const;
 
    virtual bool isLayerSnappable(RLayer::Id layerId) const;
    virtual bool isLayerSnappable(const RLayer& layer) const;
    virtual bool isParentLayerSnappable(RLayer::Id layerId) const;
    virtual bool isParentLayerSnappable(const RLayer& layer) const;
 
    virtual bool isLayerPlottable(RLayer::Id layerId) const;
    virtual bool isLayerPlottable(const RLayer& layer) const;
    virtual bool isParentLayerPlottable(RLayer::Id layerId) const;
    virtual bool isParentLayerPlottable(const RLayer& layer) const;
 
    virtual bool isEntityVisible(const REntity& entity, RBlock::Id blockId) const;
 
    virtual bool isBlockFrozen(RBlock::Id blockId) const {
        QSharedPointer<RBlock> b = queryBlockDirect(blockId);
        if (b.isNull()) {
            return false;
        }
        return b->isFrozen();
    }
 
    virtual bool isLayoutBlock(RBlock::Id blockId) const {
        QSharedPointer<RBlock> b = queryBlockDirect(blockId);
        if (b.isNull()) {
            return false;
        }
        return b->hasLayout();
    }
 
    virtual void setObjectId(RObject& object, RObject::Id objectId) const;
    virtual void setObjectHandle(RObject& object, RObject::Handle objectHandle);
 
    virtual void setEntityParentId(REntity& entity, REntity::Id parentId) {
        entity.setParentId(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<REntity::Id>& ids) const = 0;
 
    virtual bool removeObject(QSharedPointer<RObject> object) = 0;
 
    virtual bool saveObject(QSharedPointer<RObject> object, bool checkBlockRecursion = true, bool keepHandles = false) = 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() {}
 
//    RBlockReferenceEntity::Id getWorkingSetBlockReferenceId() const;
//    void setWorkingSetBlockReferenceId(RBlockReferenceEntity::Id id, int group = -1, RTransaction* transaction = NULL);
 
protected:
    QDateTime lastModified;
    bool modified;
    RObject::Handle handleCounter;
 
private:
    RDocument* document;
    int maxDrawOrder;
    RObject::Id idCounter;
    RColor currentColor;
    RLineweight::Lineweight currentLineweight;
    RLinetype::Id currentLinetypeId;
    RView::Id currentViewId;
    RBlock::Id currentBlockId;
    RObject::Id currentViewportId;
    RBlock::Id modelSpaceBlockId;
    RLayer::Id layer0Id;
 
    int lastTransactionId;
    int lastTransactionGroup;
 
    QList<RModifiedListener*> modifiedListeners;
};
 
Q_DECLARE_METATYPE(RStorage*)
Q_DECLARE_METATYPE(const RStorage*)
 
#endif