RStorage.h

Go to the documentation of this file.

#ifndef RSTORAGE_H
#define RSTORAGE_H

#include <QString>
#include <QSharedPointer>

#include "RBlock.h"
#include "RBox.h"
#include "REntity.h"
#include "RLayer.h"
#include "RLinetype.h"
#include "RModifiedListener.h"
#include "RNonCopyable.h"
#include "RRequireHeap.h"
#include "RTransaction.h"
#include "RUcs.h"
#include "RView.h"


class RStorage : RNonCopyable, public RRequireHeap {
public:
    RStorage();
    virtual ~RStorage() { }

    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;

    virtual QSet<RObject::Id> queryAllObjects() = 0;

    virtual QSet<REntity::Id> queryAllEntities(bool undone = false,
            bool allBlocks = false) = 0;

    virtual QSet<RUcs::Id> queryAllUcs() = 0;

    virtual QSet<RLayer::Id> queryAllLayers(bool undone = false) = 0;

    virtual QSet<RBlock::Id> queryAllBlocks(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 QSet<REntity::Id> queryBlockEntities(RBlock::Id blockId) = 0;

    virtual QSet<REntity::Id> queryBlockReferences(RBlock::Id blockId) = 0;

    virtual QSet<REntity::Id> queryAllBlockReferences() = 0;

    virtual QSet<REntity::Id> querySelectedEntities() = 0;

    virtual QSharedPointer<RObject> queryObject(RObject::Id objectId) const = 0;

    virtual QSharedPointer<RObject> queryObjectDirect(RObject::Id objectId) const {
        return queryObject(objectId);
    }

    virtual QSharedPointer<REntity> queryEntity(REntity::Id entityId) const = 0;

    virtual QSharedPointer<REntity> queryEntityDirect(REntity::Id entityId) const {
        return queryEntity(entityId);
    }

    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> queryLayer(const QString& layerName) const = 0;

    virtual QSharedPointer<RLayer> queryCurrentLayer() {
        return queryLayer(getCurrentLayerId());
    }

    virtual QSharedPointer<RView> queryCurrentView() {
        return queryView(getCurrentViewId());
    }

    virtual QSharedPointer<RLinetype> queryLinetype(RLinetype::Id linetypeId) const = 0;

    virtual QSharedPointer<RLinetype> queryLinetype(const QString& linetypeName) const = 0;

    virtual QSharedPointer<RBlock> queryBlock(RBlock::Id blockId) const = 0;
    virtual QSharedPointer<RBlock> queryBlockDirect(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) {
        //setVariable("CurrentLayer", layerId);
        currentLayerId = layerId;
    }

    void setCurrentLayer(const QString& layerName) {
        RLayer::Id id = getLayerId(layerName);
        if (id == RLayer::INVALID_ID) {
            return;
        }
        setCurrentLayer(id);
    }

    virtual RLayer::Id getCurrentLayerId() {
        //return (RLayer::Id) getVariable("CurrentLayer").toInt();
        return currentLayerId;
    }

    virtual RView::Id getCurrentViewId() {
        //return (RView::Id) getVariable("CurrentView").toInt();
        return currentViewId;
    }

    virtual void setCurrentColor(const RColor& color);
    virtual RColor getCurrentColor();

    void setCurrentLineweight(RLineweight::Lineweight lw);
    virtual RLineweight::Lineweight getCurrentLineweight();

    void setCurrentLinetype(RLinetype lt);
    virtual RLinetype getCurrentLinetype();

    virtual QSharedPointer<RBlock> queryCurrentBlock() {
        return queryBlock(getCurrentBlockId());
    }

    virtual void setCurrentBlock(RBlock::Id blockId) {
        //setVariable("CurrentBlock", blockId);
        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 (RBlock::Id) getVariable("CurrentBlock").toInt();
        return currentBlockId;
    }

    void setCurrentView(RView::Id viewId) {
        //setVariable("CurrentView", 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);
    }

    virtual RView::Id getCurrentViewId() const {
        //return (RView::Id) getVariable("CurrentView").toInt();
        return currentViewId;
    }

    virtual void setUnit(RS::Unit unit);
    virtual RS::Unit getUnit() const;

    virtual void setLinetypeScale(double v);
    virtual double getLinetypeScale() const;

    virtual QString getBlockName(RBlock::Id blockId) const = 0;
    virtual QSet<QString> getBlockNames() = 0;
    virtual RBlock::Id getBlockId(const QString& blockName) = 0;
    virtual bool hasBlock(const QString& blockName);

    virtual QString getViewName(RView::Id viewId) = 0;
    virtual QSet<QString> getViewNames() = 0;
    virtual RView::Id getViewId(const QString& viewName) = 0;
    virtual bool hasView(const QString& viewName);

    virtual QString getLayerName(RLayer::Id layerId) = 0;
    virtual QSet<QString> getLayerNames() = 0;
    virtual RLayer::Id getLayerId(const QString& layerName) = 0;
    virtual bool hasLayer(const QString& layerName);

    virtual QString getLinetypeName(RLinetype::Id linetypeId) = 0;
    virtual QSet<QString> getLinetypeNames() = 0;
    virtual RLinetype::Id getLinetypeId(const QString& linetypeName) = 0;
    virtual bool hasLinetype(const QString& linetypeName);

    virtual QStringList getVariables() const = 0;
    virtual void setVariable(const QString& key, const QVariant & value) = 0;
    virtual QVariant getVariable(const QString& key) const = 0;

    virtual void setKnownVariable(RS::KnownVariable key, const QVariant& value) = 0;
    virtual QVariant getKnownVariable(RS::KnownVariable key) const = 0;

    virtual void clearEntitySelection(
        QSet<REntity::Id>* affectedEntities=NULL
    ) = 0;

    virtual void selectAllEntites(QSet<REntity::Id>* affectedEntities = NULL) = 0;

    virtual void selectEntity(
        REntity::Id entityId,
        bool add=false,
        QSet<REntity::Id>* affectedEntities=NULL
    ) = 0;

    virtual void 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 void 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 isEntity(RObject::Id objectId) {
        QSharedPointer<REntity> e = queryEntityDirect(objectId);
        return !e.isNull();
    }

    virtual bool isLayerLocked(RLayer::Id layerId) const {
        QSharedPointer<RLayer> l = queryLayerDirect(layerId);
        if (l.isNull()) {
            return false;
        }
        return l->isLocked();
    }

    virtual bool isLayerFrozen(RLayer::Id layerId) const {
        QSharedPointer<RLayer> l = queryLayerDirect(layerId);
        if (l.isNull()) {
            return false;
        }
        return l->isFrozen();
    }

    virtual bool isBlockFrozen(RBlock::Id blockId) const {
        QSharedPointer<RBlock> b = queryBlockDirect(blockId);
        if (b.isNull()) {
            return false;
        }
        return b->isFrozen();
    }

    void setObjectId(RObject& object, RObject::Id objectId);
    void setObjectHandle(RObject& object, RObject::Handle objectHandle);

    virtual bool hasSelection() const = 0;

    virtual RBox getBoundingBox(bool includeHiddenLayer = true) = 0;

    virtual RBox getSelectionBox() = 0;

    virtual bool saveObject(QSharedPointer<RObject> object) = 0;

    virtual bool deleteObject(RObject::Id objectId) = 0;

    virtual int getLastTransactionId() {
        //return getVariable("LastTransaction").toInt();
        return lastTransactionId;
    }

    virtual void setLastTransactionId(int transactionId) {
        //setVariable("LastTransaction", transactionId);
        lastTransactionId = transactionId;

        setModified(true);
    }

    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;
    }

    void addModifiedListener(RModifiedListener* l);

protected:
    bool modified;

private:
    int maxDrawOrder;
    RObject::Id idCounter;
    RObject::Handle handleCounter;
    RColor currentColor;
    RLineweight::Lineweight currentLineweight;
    RLinetype currentLinetype;
    RLayer::Id currentLayerId;
    RView::Id currentViewId;
    RBlock::Id currentBlockId;
    int lastTransactionId;

    QList<RModifiedListener*> modifiedListeners;
};

Q_DECLARE_METATYPE(RStorage*)

#endif