RHatchData.h

Go to the documentation of this file.

 
#ifndef RHATCHDATA_H
#define RHATCHDATA_H
 
#include "entity_global.h"
 
#include "RBox.h"
#include "REntityData.h"
#include "RHatchProxy.h"
#include "RPattern.h"
#include "RPainterPath.h"
#include "RPainterPathSource.h"
#include "RVector.h"
 
class RDocument;
class REntity;
class RLine;
class RRefPoint;
class RPolyline;
 
#ifndef RDEFAULT_MIN1
#define RDEFAULT_MIN1 -1
#endif
 
class QCADENTITY_EXPORT RHatchData: public REntityData, public RPainterPathSource {
 
    friend class RHatchEntity;
 
protected:
    RHatchData(RDocument* document, const RHatchData& data);
 
public:
    RHatchData();
    RHatchData(const RHatchData& other);
    RHatchData(bool solid, double scaleFactor, double angle, const QString& patternName);
 
    virtual RS::EntityType getType() const {
        return RS::EntityHatch;
    }
    RHatchData& operator=(const RHatchData& other);
 
    void clearBoundary();
 
    bool hasCustomPattern() const {
        return !pattern.getPatternLines().isEmpty();
    }
 
    RPattern getCustomPattern() const {
        return pattern;
    }
 
    void setCustomPattern(const RPattern& p) {
        pattern = p;
    }
 
    virtual bool cloneOnChange() const {
        // force clone to preserve custom pattern for undo:
        //return hasCustomPattern();
        // 20190510: always clone (since allowing non-uniform scaling of hatches)
        return true;
    }
 
    virtual RBox getBoundingBox(bool ignoreEmpty=false) const;
 
    virtual RVector getPointOnEntity() const;
    virtual double getDistanceTo(const RVector& point, bool limited = true, double range = 0.0, bool draft = false, double strictRange = RMAXDOUBLE) const;
    virtual bool intersectsWith(const RShape& shape) const;
 
    virtual QList<RRefPoint> getReferencePoints(RS::ProjectionRenderingHint hint = RS::RenderTop) const;
 
    virtual bool moveReferencePoint(const RVector& referencePoint, const RVector& targetPoint, Qt::KeyboardModifiers modifiers = Qt::NoModifier);
 
    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 mirror(const RLine& axis);
    virtual bool stretch(const RPolyline& area, const RVector& offset);
 
    virtual RShape* castToShape() {
        return NULL;
    }
 
    virtual QList<QSharedPointer<RShape> > getShapes(const RBox& queryBox = RDEFAULT_RBOX, bool ignoreComplex = false, bool segment = false, QList<RObject::Id>* entityIds = NULL) const;
    virtual QList<QSharedPointer<RShape> > getExploded() const;
 
    bool isSolid() const {
        return solid;
    }
 
    void setSolid(bool on) {
        solid = on;
        clearCustomPattern();
    }
 
    bool isWinding() const {
        return winding;
    }
 
    void setWinding(bool on) {
        winding = on;
        clearCustomPattern();
    }
 
    bool getAutoRegen() const {
        return autoRegen;
    }
 
    void setAutoRegen(bool on) {
        autoRegen = on;
        clearCustomPattern();
    }
 
    double getScale() const {
        return scaleFactor;
    }
 
    void setScale(double s) {
        scaleFactor = s;
        clearCustomPattern();
    }
 
    double getAngle() const {
        return angle;
    }
 
    void setAngle(double a) {
        angle = a;
        clearCustomPattern();
    }
 
    RVector getOriginPoint() const {
        return originPoint;
    }
 
    void setOriginPoint(const RVector& op, bool clearCustom = true) {
        originPoint = op;
        if (clearCustom) {
            clearCustomPattern();
        }
    }
 
    QString getPatternName() const {
        return patternName;
    }
 
    void setPatternName(const QString& n) {
        patternName = n;
        clearCustomPattern();
    }
 
    int getTransparency() const {
        return transparency;
    }
 
    void setTransparency(int t) {
        transparency = t;
    }
 
    double getLength() const;
    double getArea() const;
 
    void clearCustomPattern();
 
    void newLoop();
    void cancelLoop();
    void addBoundary(QSharedPointer<RShape> shape, bool addAutoLoops = true);
    void addBoundaryShape(QSharedPointer<RShape> shape, int loop) {
        if (loop < boundary.length()) {
            boundary[loop].append(shape);
        }
    }
    RPainterPath getBoundaryPath(double pixelSizeHint = RDEFAULT_MIN1) const;
    virtual QList<RPainterPath> getPainterPaths(bool draft = false, double pixelSizeHint = RDEFAULT_MIN1) const;
 
    QList<QList<QSharedPointer<RShape> > > getBoundary() const {
        return boundary;
    }
 
    QPair<QSharedPointer<RShape>, QSharedPointer<RShape> > getBoundaryElementsAt(int index, int& internalIndex) const;
 
    virtual void update() const;
    bool order();
 
    int getLoopCount() const {
        return boundary.count();
    }
 
    QList<QSharedPointer<RShape> > getLoopBoundary(int index) const;
 
    QList<RPolyline> getBoundaryAsPolylines(double segmentLength = RDEFAULT_MIN1) const;
 
    void autoCloseLoops() {
        if (hatchProxy!=NULL) {
            hatchProxy->autoCloseLoops(*this);
        }
    }
 
    int getComplexity() const;
 
    void setPattern(const RPattern& p) {
        pattern = p;
    }
 
    virtual RColor getColor() const {
        RColor c = REntityData::getColor();
        c.setAlpha(transparency);
        return c;
    }
 
    virtual RColor getColor(const RColor& unresolvedColor, const QStack<QSharedPointer<REntity> >& blockRefStack) const {
        RColor c = REntityData::getColor(unresolvedColor, blockRefStack);
        c.setAlpha(transparency);
        return c;
    }
    virtual RColor getColor(bool resolve, const QStack<QSharedPointer<REntity> >& blockRefStack) const {
        RColor c = REntityData::getColor(resolve, blockRefStack);
        c.setAlpha(transparency);
        return c;
    }
 
    static bool hasProxy() {
        return hatchProxy!=NULL;
    }
 
    static void setHatchProxy(RHatchProxy* p) {
        if (hatchProxy!=NULL) {
            delete hatchProxy;
        }
        hatchProxy = p;
    }
 
    static RHatchProxy* getHatchProxy() {
        return hatchProxy;
    }
 
protected:
    QList<RLine> getSegments(const RLine& line) const;
 
private:
    bool solid;
    bool winding;
    bool autoRegen;
    double scaleFactor;
    double angle;
    QString patternName;
    RVector originPoint;
    int transparency;
 
    QList<QList<QSharedPointer<RShape> > > boundary;
 
    mutable RPattern pattern;
 
    mutable RPainterPath boundaryPath;
    mutable QList<RPainterPath> painterPaths;
    mutable bool dirty;
    mutable bool gotDraft;
    mutable double gotPixelSizeHint;
 
    static RHatchProxy* hatchProxy;
};
 
Q_DECLARE_METATYPE(RHatchData)
Q_DECLARE_METATYPE(RHatchData*)
Q_DECLARE_METATYPE(const RHatchData*)
Q_DECLARE_METATYPE(QSharedPointer<RHatchData>)
 
#endif