REntity.h

Go to the documentation of this file.

#ifndef RENTITY_H
#define RENTITY_H

#include <QList>
#include <QStack>

#include "RBox.h"
#include "RColor.h"
#include "RDebug.h"
#include "REntityData.h"
#include "RLayer.h"
#include "RLineweight.h"
#include "RMatrix.h"
#include "RObject.h"
#include "RPropertyAttributes.h"
#include "RPropertyTypeId.h"
#include "RVector.h"
#include "RExplodable.h"

class RDocument;
class REntity;
class RBlockReferenceEntity;
class RExporter;

#ifndef RDEFAULT_QSET_INT
#define RDEFAULT_QSET_INT QSet<int>()
#endif

class REntity : public RObject {

    Q_DECLARE_TR_FUNCTIONS(REntity)

public:
    static RPropertyTypeId PropertyCustom;
    static RPropertyTypeId PropertyHandle;
    static RPropertyTypeId PropertyType;
    static RPropertyTypeId PropertyBlock;
    static RPropertyTypeId PropertyLayer;
    static RPropertyTypeId PropertyLinetype;
    static RPropertyTypeId PropertyLineweight;
    static RPropertyTypeId PropertyColor;
    static RPropertyTypeId PropertyDrawOrder;

public:
    REntity(RDocument* document, Id objectId=-1) : RObject(document, objectId) {}
    virtual ~REntity();

    static void init();

    void setDocument(RDocument* document) {
        RObject::setDocument(document);
        getData().setDocument(document);
    }

    virtual REntity* clone() const = 0;

    virtual RS::EntityType getType() const {
        return RS::EntityUnknown;
    }

    virtual REntityData& getData() = 0;

    virtual const REntityData& getData() const = 0;

    bool isSelected() const {
        return getData().isSelected();
    }

    void setSelected(bool on);

    void setDrawOrder(int drawOrder) {
        getData().setDrawOrder(drawOrder);
    }

    int getDrawOrder() const {
        return getData().getDrawOrder();
    }

    void setLayerId(RLayer::Id layerId) {
        getData().setLayerId(layerId);
    }

    RLayer::Id getLayerId() const {
        return getData().getLayerId();
    }

    QString getLayerName() {
        return getData().getLayerName();
    }

    void setBlockId(RBlock::Id blockId) {
        getData().setBlockId(blockId);
    }

    RBlock::Id getBlockId() const {
        return getData().getBlockId();
    }

    QString getBlockName() {
        return getData().getBlockName();
    }

    void setLinetypeId(RLinetype::Id linetypeId) {
        getData().setLinetypeId(linetypeId);
    }

    void setLinetype(RLinetype linetype) {
        getData().setLinetype(linetype);
    }

    RLinetype::Id getLinetypeId() const {
        return getData().getLinetypeId();
    }

    RLinetype::Id getLinetypeId(bool resolve,
        const QStack<RBlockReferenceEntity*>& blockRefStack) const;

    void setLineweight(RLineweight::Lineweight lineweight) {
        getData().setLineweight(lineweight);
    }

    RLineweight::Lineweight getLineweight() const {
        return getData().getLineweight();
    }

    RLineweight::Lineweight getLineweight(bool resolve,
        const QStack<RBlockReferenceEntity*>& blockRefStack) const;

    double getLineweightInUnits(const QStack<RBlockReferenceEntity*>& blockRefStack) const;

    void setColor(const RColor& color) {
        getData().setColor(color);
    }

    RColor getColor() const {
        return getData().getColor();
    }

    RColor getColor(bool resolve, const QStack<RBlockReferenceEntity*>& blockRefStack);

    void copyAttributesFrom(REntity* entity);

    virtual RBox getBoundingBox() const {
        return getData().getBoundingBox();
    }

    virtual QList<RBox> getBoundingBoxes(/*REntity::Id subEntityId = REntity::INVALID_ID*/) const {
        return getData().getBoundingBoxes(/*subEntityId*/);
    }

//    virtual QList<QPair<REntity::Id, RBox> > getIdBoundingBoxes() const {
//        return getData().getIdBoundingBoxes();
//    }

    virtual QList<QSharedPointer<RShape> > getShapes(const RBox& queryBox = RDEFAULT_RBOX) const {
        return getData().getShapes(queryBox);
    }

    virtual QSharedPointer<RShape> getClosestShape(const RVector& pos, double range = RNANDOUBLE) const {
        return getData().getClosestShape(pos, range);
    }

    virtual bool isInside(const RBox& box) const {
        return getData().isInside(box);
    }

    virtual bool isOnEntity(const RVector& point, bool limited=true) const {
        return getData().isOnEntity(point, limited);
    }

    virtual bool intersectsWith(const RShape& shape) const {
        return getData().intersectsWith(shape);
    }

    virtual double getDistanceTo(const RVector& point, bool limited = true, double range = 0.0, bool draft = false) const {
        return getData().getDistanceTo(point, limited, range, draft);
    }

    virtual RVector getVectorTo(const RVector& point, bool limited = true) const {
        return getData().getVectorTo(point, limited);
    }

    virtual QList<RVector> getReferencePoints(RS::ProjectionRenderingHint hint=RS::RenderTop) const {
        return getData().getReferencePoints(hint);
    }

    virtual RVector getPointOnEntity() const {
        return getData().getPointOnEntity();
    }

    virtual QList<RVector> getEndPoints(const RBox& queryBox = RDEFAULT_RBOX) const {
        return getData().getEndPoints(queryBox);
    }

    virtual QList<RVector> getMiddlePoints(const RBox& queryBox = RDEFAULT_RBOX) const {
        return getData().getMiddlePoints(queryBox);
    }

    virtual QList<RVector> getCenterPoints(const RBox& queryBox = RDEFAULT_RBOX) const {
        return getData().getCenterPoints(queryBox);
    }

    virtual RVector getClosestPointOnEntity(const RVector& point,
        double range=RNANDOUBLE, bool limited=true) const {

        return getData().getClosestPointOnEntity(point, range, limited);
    }

    virtual QList<RVector> getPointsWithDistanceToEnd(
            double distance,
            RS::From from = RS::FromAny,
            const RBox& queryBox = RDEFAULT_RBOX) const {
        return getData().getPointsWithDistanceToEnd(distance, from, queryBox);
    }

    /*
    virtual QList<RVector> getIntersectionPoints(RDocument& document) const {
        return getData().getIntersectionPoints(document);
    }
    */

    virtual QList<RVector> getIntersectionPoints(
            const REntity& other, bool limited = true, const RBox& queryBox = RDEFAULT_RBOX
            /*const QSet<int>& pos = RDEFAULT_QSET_INT, const QSet<int>& posOther = RDEFAULT_QSET_INT*/) const;

    virtual QList<RVector> getIntersectionPoints(const RShape& shape, bool limited = true, const RBox& queryBox = RDEFAULT_RBOX) const;

    virtual bool moveReferencePoint(
        const RVector& referencePoint, const RVector& targetPoint) {
        return getData().moveReferencePoint(referencePoint, targetPoint);
    }

    virtual bool move(const RVector& offset) {
        return getData().move(offset);
    }

    virtual bool rotate(double rotation, const RVector& center = RDEFAULT_RVECTOR) {
        return getData().rotate(rotation, center);
    }

    virtual bool scale(const RVector& scaleFactors,
        const RVector& center = RDEFAULT_RVECTOR) {

        return getData().scale(scaleFactors, center);
    }

    virtual bool scale(double scaleFactor,
        const RVector& center = RDEFAULT_RVECTOR) {

        return getData().scale(scaleFactor, center);
    }

    virtual bool mirror(const RLine& axis) {
        return getData().mirror(axis);
    }

    virtual bool mirror(const RVector& axis1, const RVector& axis2) {
        return getData().mirror(axis1, axis2);
    }

    virtual bool flipHorizontal() {
        return getData().flipHorizontal();
    }

    virtual bool flipVertical() {
        return getData().flipVertical();
    }

    virtual bool stretch(const RPolyline& area, const RVector& offset) {
        return getData().stretch(area, offset);
    }

    void update() const {
        getData().update();
    }

    virtual RShape* castToShape() {
        return getData().castToShape();
    }

    virtual const RShape* castToConstShape() const {
        return getData().castToConstShape();
    }

    virtual void exportEntity(RExporter& e, bool preview = false) const = 0;

    // from RObject:
    virtual bool isSelectedForPropertyEditing() {
        return isSelected();
    }

    virtual QPair<QVariant, RPropertyAttributes> getProperty(
            RPropertyTypeId propertyTypeId,
            bool humanReadable = false, bool noAttributes = false);

    virtual bool setProperty(RPropertyTypeId propertyTypeId,
            const QVariant& value);

    bool isVisible() const;
    bool isEditable(bool allowInvisible = false) const;

    virtual int getComplexity() const {
        return 1;
    }

    void dump();

protected:
    virtual void print(QDebug dbg) const;
};

Q_DECLARE_METATYPE(REntity*)
Q_DECLARE_METATYPE(QSharedPointer<REntity>)
Q_DECLARE_METATYPE(QSharedPointer<REntity>*)
Q_DECLARE_METATYPE(QStack<REntity*>)

#endif