RExporter.h

Go to the documentation of this file.

#ifndef REXPORTER_H
#define REXPORTER_H

#include <QBrush>
#include <QColor>
#include <QPen>
#include <QStack>
#include <QTextLayout>

#include "REntity.h"
#include "RMatrix.h"
#include "RView.h"
#include "RPainterPath.h"
#include "RPainterPathSource.h"

class RArc;
class RCircle;
class RDocument;
class REllipse;
class RImageData;
class RLine;
class RLinetype;
class RLinetypePattern;
class RPoint;
class RPolyline;
class RSpline;
//class RTextLabel;
class RTriangle;
class RVector;

class RExporter {

public:
    RExporter();
    RExporter(RDocument& document);
    virtual ~RExporter();

    QString getErrorMessage() const;

    void setLayerSource(RDocument* ls);
    void setBlockSource(RDocument* bs);

    RDocument& getDocument() const;

    void setProjectionRenderingHint(RS::ProjectionRenderingHint p);
    RS::ProjectionRenderingHint getProjectionRenderingHint();
    virtual void setPen(const QPen& pen);
    virtual QPen getPen(const RPainterPath& path);
    virtual QPen getPen();
    virtual void setBrush(const QBrush& brush);
    virtual QBrush getBrush(const RPainterPath& path);
    virtual QBrush getBrush();

    virtual void setEntityAttributes();

    virtual void setStyle(Qt::PenStyle penStyle);
    virtual void setBrushStyle(Qt::BrushStyle brushStyle);
    virtual void setDashPattern(const QVector<qreal>& dashes);

    virtual void setColor(float r, float g, float b, float a = 1.0f);
    virtual void setColor(const RColor& color);

    virtual void setLineweight(RLineweight::Lineweight weight);

    virtual void setLinetypeId(RLinetype::Id ltId);
    virtual void setLinetypePattern(const RLinetypePattern& ltPattern);
    RLinetypePattern getLinetypePattern();

    virtual REntity* getBlockRefOrEntity();
    virtual REntity* getEntity();

    virtual const REntity* getEntity() const;

    virtual bool isEntitySelected();

    virtual void startExport();
    virtual void endExport();

    virtual bool exportDocument();
    virtual bool exportDocumentSettings();
    virtual void exportDocumentSetting(
            const QString& /*key*/, const QVariant& /*value*/) {}

    virtual void exportLayers();
    virtual void exportBlocks();
    virtual void exportViews();
    virtual void exportLinetypes();

    virtual void exportLayer(RLayer& /*layer*/) {}
    virtual void exportLayer(RLayer::Id layerId);
    virtual void exportBlock(RBlock& /*block*/) {}
    virtual void exportBlock(RBlock::Id blockId);
    virtual void exportView(RView& /*view*/) {}
    virtual void exportView(RView::Id viewId);
    virtual void exportLinetype(RLinetype& /*linetype*/) {}

    virtual void exportEntities(bool allBlocks = true, bool undone = false);
    virtual void exportEntities(const RBox& box);
    virtual void exportEntities(QSet<REntity::Id>& entityIds, bool allBlocks = true);
    virtual void exportTrialEntities();
    virtual void exportEntity(REntity& e, bool preview = false, bool allBlocks = true);
    virtual void exportEntity(REntity::Id entityId, bool allBlocks = true);
    virtual void startEntity(bool /*topLevelEntity*/) {}
    virtual void endEntity() {}
    virtual void exportCurrentEntity(bool preview = false);
    virtual void unexportEntity(REntity::Id entityId);

    virtual void exportShapes(const QList<QSharedPointer<RShape> >& shapes);
    virtual void exportShape(QSharedPointer<RShape> shape);

    virtual void exportLine(const RLine& line, double offset = RNANDOUBLE);

    virtual void exportLineSegment(const RLine& line) = 0;

    virtual void exportPoint(const RPoint& point) = 0;

    virtual void exportCircle(const RCircle& circle);

    virtual void exportArc(const RArc& arc, double offset = RNANDOUBLE);

    virtual void exportArcSegment(const RArc& arc) = 0;

    virtual void exportEllipse(const REllipse& ellipse, double offset = RNANDOUBLE);

    virtual void exportPolyline(const RPolyline& polyline, double offset = RNANDOUBLE);

    virtual void exportSpline(const RSpline& spline, double offset = RNANDOUBLE);

    virtual void exportExplodable(const RExplodable& explodable, double offset = RNANDOUBLE);

    virtual void exportPainterPathSource(const RPainterPathSource& pathSource);

    virtual void exportPainterPaths(const QList<RPainterPath>& paths);
    virtual void exportBoundingBoxPaths(const QList<RPainterPath>& paths);

    virtual void exportImage(const RImageData& image);

    virtual void exportQuad(
        const RVector& p1,
        const RVector& p2,
        const RVector& p3,
        const RVector& p4
    );

    virtual void exportVerticalQuad(
        const RVector& p1,
        const RVector& p2,
        double height
    );

    virtual void exportBox(const RBox& box);

    virtual void exportTriangle(const RTriangle& triangle) = 0;

    virtual void exportRectangle(const RVector& p1, const RVector& p2);

    virtual double getPatternFactor();

    QStack<REntity*> getEntityStack();

    double getPatternOffset(double length, const RLinetypePattern& pattern);
    double getPatternOffset(double length, const RLinetypePattern& pattern,
            int index, double* gap = NULL);

    void setDraftMode(bool on) {
        draftMode = on;
    }

    bool getDraftMode() const {
        return draftMode;
    }

    bool isVisualExporter() const {
        return visualExporter;
    }

    void setVisualExporter(bool on) {
        visualExporter = on;
    }

protected:
    RDocument* document;
    QPen currentPen;
    RLinetypePattern currentLinetypePattern;
    QBrush currentBrush;
    QStack<REntity*> entityStack;
    RLayer* currentLayer;
    QStack<RBlockReferenceEntity*> blockRefStack;
    //QSharedPointer<REntity> blockRefBS;
    RDocument* layerSource;
    RDocument* blockSource;
    bool draftMode;
    bool visualExporter;
    QString errorMessage;

private:
    RS::ProjectionRenderingHint projectionRenderingHint;
    //bool fixedColor;
};

Q_DECLARE_METATYPE(RExporter*)

#endif