REntityData.h

Go to the documentation of this file.

 
#ifndef RENTITYDATA_H
#define RENTITYDATA_H
 
#include "core_global.h"
 
#include <QList>
#include <QStack>
 
#include "RBox.h"
#include "RColor.h"
#include "RLineweight.h"
#include "RMath.h"
#include "RObject.h"
 
class RBlockReferenceEntity;
class RDocument;
class REntity;
class RExporter;
class RLinetypePattern;
class RPolyline;
class RRefPoint;
class RLine;
 
#ifndef RDEFAULT_QSET_INT
#define RDEFAULT_QSET_INT QSet<int>()
#endif
 
#ifndef RDEFAULT_TOLERANCE_1E_MIN4
#define RDEFAULT_TOLERANCE_1E_MIN4 1.0e-4
#endif
 
class QCADCORE_EXPORT REntityData {
 
    friend class REntity;
 
public:
    REntityData(RDocument* document=NULL);
 
    virtual ~REntityData() {}
 
    RDocument* getDocument() {
        return document;
    }
 
    const RDocument* getDocument() const {
        return document;
    }
 
    void setDocument(RDocument* document) {
        this->document = document;
    }
 
    virtual RS::EntityType getType() const {
        return RS::EntityUnknown;
    }
 
    virtual bool isPointType() const {
        return false;
    }
 
    virtual bool isValid() const {
        return true;
    }
    virtual bool isSane() const {
        return true;
    }
 
    virtual QList<QSharedPointer<RShape> > getShapes(const RBox& queryBox = RDEFAULT_RBOX, bool ignoreComplex = false, bool segment = false, QList<RObject::Id>* entityIds = NULL) const {
        Q_UNUSED(queryBox)
        Q_UNUSED(ignoreComplex)
        Q_UNUSED(segment)
        Q_UNUSED(entityIds)
 
        return QList<QSharedPointer<RShape> >();
    }
 
    RObject::Id getClosestSubEntityId(const RVector& pos, double range, bool ignoreComplex) const {
        RObject::Id ret = RObject::INVALID_ID;
        QSharedPointer<RShape> shape = getClosestShape(pos, range, ignoreComplex, &ret);
        return ret;
    }
 
    virtual QSharedPointer<RShape> getClosestShape(const RVector& pos, double range = RNANDOUBLE, bool ignoreComplex = false, RObject::Id* subEntityId = NULL) const;
 
    virtual RShape* castToShape() {
        return NULL;
    }
 
    virtual const RShape* castToConstShape() const {
        return const_cast<REntityData*>(this)->castToShape();
    }
 
    virtual RBox getBoundingBox(bool ignoreEmpty=false) const;
 
    void copyAttributesFrom(const REntityData& entityData, bool copyBlockId = true);
 
    virtual void to2D();
    virtual void setZ(double z);
 
    virtual QList<RBox> getBoundingBoxes(bool ignoreEmpty=false) const {
        return QList<RBox>() << getBoundingBox(ignoreEmpty);
    }
 
    virtual RPolyline getHull(double offset) const;
 
    virtual bool isUpdatesEnabled() const {
        return updatesEnabled;
    }
 
    void setUpdatesEnabled(bool on) {
        updatesEnabled = on;
    }
 
    virtual bool cloneOnChange() const {
        return false;
    }
 
    virtual bool isSelected() const {
        return selectionStatus;
    }
 
    virtual void setSelected(bool on) {
        selectionStatus = on;
    }
 
    virtual bool isSelectedWorkingSet() const {
        return selectionStatusWorkingSet;
    }
 
    virtual void setSelectedWorkingSet(bool on) {
        selectionStatusWorkingSet = on;
    }
 
    virtual int getDrawOrder() const {
        return drawOrder;
    }
 
    virtual void setDrawOrder(int drawOrder) {
        this->drawOrder = drawOrder;
    }
 
    virtual void setLayerId(RObject::Id layerId) {
        this->layerId = layerId;
    }
 
    RObject::Id getLayerId() const {
        return layerId;
    }
 
    void setLayerName(const QString& layerName);
    QString getLayerName() const;
 
    virtual void setBlockId(RObject::Id blockId) {
        this->blockId = blockId;
    }
 
    RObject::Id getBlockId() const {
        return blockId;
    }
 
    virtual void setParentId(RObject::Id parentId) {
        this->parentId = parentId;
    }
 
    RObject::Id getParentId() const {
        return parentId;
    }
 
    QString getBlockName() const;
 
    virtual void setLinetypeId(RObject::Id linetypeId) {
        this->linetypeId = linetypeId;
    }
 
    virtual RObject::Id getLinetypeId() const {
        return linetypeId;
    }
 
    virtual void setLinetypePattern(const RLinetypePattern& p);
    virtual RLinetypePattern getLinetypePattern() const;
 
    virtual RObject::Id getLinetypeId(bool resolve,
        const QStack<QSharedPointer<REntity> >& blockRefStack) const;
 
    virtual void setLinetypeScale(double linetypeScale) {
        this->linetypeScale = linetypeScale;
    }
 
    virtual double getLinetypeScale() const {
        return linetypeScale;
    }
 
    virtual RLineweight::Lineweight getLineweight() const {
        return lineweight;
    }
 
    virtual RLineweight::Lineweight getLineweight(bool resolve,
        const QStack<QSharedPointer<REntity> >& blockRefStack) const;
 
    double getLineweightInUnits(const QStack<QSharedPointer<REntity> >& blockRefStack) const;
 
    void setLineweight(RLineweight::Lineweight lineweight) {
        this->lineweight = lineweight;
//        if (RSettings::getAutoScaleLinetypePattern()) {
//            this->linetypeScale = lineweight;
//        }
    }
 
    void setColor(const RColor& color) {
        this->color = color;
    }
 
    virtual RColor getColor() const {
        return color;
    }
 
    virtual RColor getColor(const RColor& unresolvedColor, const QStack<QSharedPointer<REntity> >& blockRefStack) const;
    virtual RColor getColor(bool resolve, const QStack<QSharedPointer<REntity> >& blockRefStack) const;
 
    virtual RColor getDisplayColor() {
        QStack<QSharedPointer<REntity> > stack;
        return getColor(true, stack);
    }
 
    virtual QList<RRefPoint> getInternalReferencePoints(RS::ProjectionRenderingHint hint=RS::RenderTop, QList<RObject::Id>* subEntityIds = NULL) const;
 
    virtual QList<RRefPoint> getReferencePoints(RS::ProjectionRenderingHint hint=RS::RenderTop) const = 0;
 
    virtual RVector getPointOnEntity() const;
    virtual QList<RVector> getEndPoints(const RBox& queryBox = RDEFAULT_RBOX, QList<RObject::Id>* subEntityIds = NULL) const;
    virtual QList<RVector> getMiddlePoints(const RBox& queryBox = RDEFAULT_RBOX, QList<RObject::Id>* subEntityIds = NULL) const;
    virtual QList<RVector> getCenterPoints(const RBox& queryBox = RDEFAULT_RBOX, QList<RObject::Id>* subEntityIds = NULL) const;
    virtual QList<RVector> getArcReferencePoints(const RBox& queryBox = RDEFAULT_RBOX) const;
    virtual QList<RVector> getPointsWithDistanceToEnd(
        double distance, int from = RS::FromAny, const RBox& queryBox = RDEFAULT_RBOX, QList<RObject::Id>* subEntityIds = NULL) const;
 
    virtual RVector getClosestPointOnEntity(const RVector& point,
        double range=RNANDOUBLE, bool limited=true, RObject::Id* subEntityId = NULL) const;
 
//    /**
//     * Override to disable intersection point
//     */
//    virtual bool intersectionsEnabled() {
//        return true;
//    }
 
    virtual QList<RVector> getIntersectionPoints(
            const REntityData& other, bool limited = true, bool same = false,
            const RBox& queryBox = RDEFAULT_RBOX, bool ignoreComplex = true,
            QList<QPair<RObject::Id, RObject::Id> >* entityIds = NULL) const;
    virtual QList<RVector> getIntersectionPoints(
            const RShape& shape, bool limited = true,
            const RBox& queryBox = RDEFAULT_RBOX, bool ignoreComplex = true) const;
 
    virtual RVector getVectorTo(const RVector& point, bool limited=true, double strictRange = RMAXDOUBLE) const;
 
    virtual double getDistanceTo(const RVector& point, bool limited = true, double range = 0.0, bool draft = false, double strictRange = RMAXDOUBLE) const;
 
    virtual bool isInside(const RBox& box) const {
        return box.contains(getBoundingBox());
    }
 
    virtual bool isOnEntity(const RVector& point, bool limited = true, double tolerance = RDEFAULT_TOLERANCE_1E_MIN4) const;
 
    virtual bool intersectsWith(const RShape& shape) const;
 
    virtual bool clickReferencePoint(const RVector& referencePoint) {
        Q_UNUSED(referencePoint)
        return false;
    }
 
    virtual bool moveReferencePoint(const RVector& referencePoint, const RVector& targetPoint, Qt::KeyboardModifiers modifiers = Qt::NoModifier) = 0;
 
    virtual bool move(const RVector& offset);
    virtual bool rotate(double rotation, const RVector& center = RDEFAULT_RVECTOR);
    virtual bool scale(const RVector& scaleFactors, const RVector& center = RDEFAULT_RVECTOR);
    virtual bool scale(double scaleFactor, const RVector& center = RDEFAULT_RVECTOR);
    virtual void scaleVisualProperties(double scaleFactor);
    virtual bool mirror(const RLine& axis);
    virtual bool mirror(const RVector& axis1, const RVector& axis2);
    virtual bool flipHorizontal();
    virtual bool flipVertical();
    virtual bool stretch(const RPolyline& area, const RVector& offset);
 
    virtual void update() const {}
    void setAutoUpdatesBlocked(bool on);
    bool getAutoUpdatesBlocked() const;
 
    static int getDefaultDrawOrder() {
        return RMININT;
    }
 
protected:
    RDocument* document;
    bool updatesEnabled;
    bool selectionStatus;
    bool selectionStatusWorkingSet;
    bool autoUpdatesBlocked;
    int drawOrder;
    RObject::Id layerId;
    RObject::Id blockId;
    RObject::Id parentId;
    RObject::Id linetypeId;
    double linetypeScale;
    RLineweight::Lineweight lineweight;
    RColor color;
};
 
Q_DECLARE_METATYPE(REntityData*)
Q_DECLARE_METATYPE(const REntityData*)
Q_DECLARE_METATYPE(QSharedPointer<REntityData>)
Q_DECLARE_METATYPE(QSharedPointer<REntityData>*)
 
#endif