Shamusworld >> Repos - architektonas/blob - src/base/rs_filterdxf.h

   1 #ifndef RS_FILTERDXF_H
   2 #define RS_FILTERDXF_H
   3
   4 #include "rs_filterinterface.h"
   5
   6 #include "rs_block.h"
   7 #include "rs_color.h"
   8 #include "rs_dimension.h"
   9 #include "rs_hatch.h"
  10 #include "rs_insert.h"
  11 #include "rs_layer.h"
  12 #include "rs_layer.h"
  13 #include "rs_leader.h"
  14 #include "rs_polyline.h"
  15 #include "rs_spline.h"
  16 #include "rs_solid.h"
  17 #include "rs_text.h"
  18 #include "rs_image.h"
  19
  20 #include "dl_creationinterface.h"
  21 #include "dl_dxf.h"
  22
  23 class DL_WriterA;
  24
  25 /**
  26  * This format filter class can import and export DXF files.
  27  * It depends on the dxflib library.
  28  *
  29  * @author Andrew Mustun
  30  */
  31 class RS_FilterDXF: public RS_FilterInterface, DL_CreationInterface
  32 {
  33         public:
  34                 RS_FilterDXF();
  35                 ~RS_FilterDXF();
  36
  37                 /**
  38                 * @return RS2::FormatDXF.
  39                 */
  40                 //RS2::FormatType rtti() {
  41                 //      return RS2::FormatDXF;
  42                 //}
  43
  44                 /*
  45                 virtual bool canImport(RS2::FormatType t) {
  46                         return (t==RS2::FormatDXF);
  47                 }
  48
  49                 virtual bool canExport(RS2::FormatType t) {
  50                         return (t==RS2::FormatDXF || t==RS2::FormatDXF12);
  51                 }*/
  52
  53                 // Import:
  54                 virtual bool fileImport(Drawing& g, const QString& file, RS2::FormatType /*type*/);
  55
  56                 // Methods from DL_CreationInterface:
  57                 virtual void addLayer(const DL_LayerData & data);
  58                 virtual void addBlock(const DL_BlockData & data);
  59                 virtual void endBlock();
  60                 virtual void addPoint(const DL_PointData & data);
  61                 virtual void addLine(const DL_LineData & data);
  62                 virtual void addArc(const DL_ArcData & data);
  63                 virtual void addEllipse(const DL_EllipseData & data);
  64                 virtual void addCircle(const DL_CircleData & data);
  65                 virtual void addPolyline(const DL_PolylineData & data);
  66                 virtual void addVertex(const DL_VertexData & data);
  67                 virtual void addSpline(const DL_SplineData & data);
  68                 virtual void addKnot(const DL_KnotData &);
  69                 virtual void addControlPoint(const DL_ControlPointData & data);
  70                 virtual void addInsert(const DL_InsertData & data);
  71                 virtual void addTrace(const DL_TraceData &);
  72                 virtual void addSolid(const DL_SolidData &);
  73                 virtual void addMTextChunk(const char * text);
  74                 virtual void addMText(const DL_MTextData & data);
  75                 virtual void addText(const DL_TextData & data);
  76                 //virtual void addDimension(const DL_DimensionData& data);
  77                 RS_DimensionData convDimensionData(const DL_DimensionData & data);
  78                 virtual void addDimAlign(const DL_DimensionData & data, const DL_DimAlignedData & edata);
  79                 virtual void addDimLinear(const DL_DimensionData & data, const DL_DimLinearData & edata);
  80                 virtual void addDimRadial(const DL_DimensionData & data, const DL_DimRadialData & edata);
  81                 virtual void addDimDiametric(const DL_DimensionData & data, const DL_DimDiametricData & edata);
  82                 virtual void addDimAngular(const DL_DimensionData & data, const DL_DimAngularData & edata);
  83                 virtual void addDimAngular3P(const DL_DimensionData & data, const DL_DimAngular3PData & edata);
  84                 virtual void addLeader(const DL_LeaderData & data);
  85                 virtual void addLeaderVertex(const DL_LeaderVertexData & data);
  86                 virtual void addHatch(const DL_HatchData & data);
  87                 virtual void addHatchLoop(const DL_HatchLoopData & data);
  88                 virtual void addHatchEdge(const DL_HatchEdgeData & data);
  89                 virtual void addImage(const DL_ImageData & data);
  90                 virtual void linkImage(const DL_ImageDefData & data);
  91                 virtual void endEntity();
  92                 virtual void endSequence();
  93
  94                 virtual void setVariableVector(const char * key, double v1, double v2, double v3, int code);
  95                 virtual void setVariableString(const char * key, const char * value, int code);
  96                 virtual void setVariableInt(const char * key, int value, int code);
  97                 virtual void setVariableDouble(const char * key, double value, int code);
  98
  99                 // Export:
 100                 virtual bool fileExport(Drawing & g, const QString & file, RS2::FormatType type);
 101
 102                 void writeVariables(DL_WriterA & dw);
 103                 void writeLayer(DL_WriterA & dw, RS_Layer * l);
 104                 void writeLineType(DL_WriterA & dw, RS2::LineType t);
 105                 void writeAppid(DL_WriterA & dw, const char * appid);
 106                 void writeBlock(DL_WriterA & dw, RS_Block * blk);
 107                 void writeEntity(DL_WriterA & dw, RS_Entity * e);
 108                 void writeEntity(DL_WriterA & dw, RS_Entity * e, const DL_Attributes & attrib);
 109                 void writePoint(DL_WriterA & dw, RS_Point * p, const DL_Attributes & attrib);
 110                 void writeLine(DL_WriterA & dw, RS_Line * l, const DL_Attributes & attrib);
 111                 void writePolyline(DL_WriterA & dw, RS_Polyline * l, const DL_Attributes & attrib);
 112                 void writeSpline(DL_WriterA & dw, RS_Spline * s, const DL_Attributes & attrib);
 113                 void writeCircle(DL_WriterA & dw, RS_Circle * c, const DL_Attributes & attrib);
 114                 void writeArc(DL_WriterA & dw, RS_Arc * a, const DL_Attributes & attrib);
 115                 void writeEllipse(DL_WriterA & dw, RS_Ellipse * s, const DL_Attributes & attrib);
 116                 void writeInsert(DL_WriterA & dw, RS_Insert * i, const DL_Attributes & attrib);
 117                 void writeText(DL_WriterA & dw, RS_Text * t, const DL_Attributes & attrib);
 118                 void writeDimension(DL_WriterA & dw, RS_Dimension * d, const DL_Attributes & attrib);
 119                 void writeLeader(DL_WriterA & dw, RS_Leader * l, const DL_Attributes & attrib);
 120                 void writeHatch(DL_WriterA & dw, RS_Hatch * h, const DL_Attributes & attrib);
 121                 void writeSolid(DL_WriterA & dw, RS_Solid * s, const DL_Attributes & attrib);
 122                 void writeImage(DL_WriterA & dw, RS_Image * i, const DL_Attributes & attrib);
 123                 void writeEntityContainer(DL_WriterA & dw, RS_EntityContainer * con,
 124                         const DL_Attributes & attrib);
 125                 void writeAtomicEntities(DL_WriterA & dw, RS_EntityContainer * c,
 126                         const DL_Attributes & attrib, RS2::ResolveLevel level);
 127
 128                 void writeImageDef(DL_WriterA & dw, RS_Image * i);
 129
 130                 void setEntityAttributes(RS_Entity * entity, const DL_Attributes& attrib);
 131                 DL_Attributes getEntityAttributes(RS_Entity * entity);
 132
 133                 static QString toDxfString(const QString & string);
 134                 static QString toNativeString(const QString & string);
 135
 136         public:
 137                 RS_Pen attributesToPen(const DL_Attributes & attrib) const;
 138
 139                 static RS_Color numberToColor(int num, bool comp = false);
 140                 static int colorToNumber(const RS_Color & col);
 141
 142                 static RS2::LineType nameToLineType(const QString& name);
 143                 static QString lineTypeToName(RS2::LineType lineType);
 144                 //static QString lineTypeToDescription(RS2::LineType lineType);
 145
 146                 static RS2::LineWidth numberToWidth(int num);
 147                 static int widthToNumber(RS2::LineWidth width);
 148
 149                 static RS2::AngleFormat numberToAngleFormat(int num);
 150                 static int angleFormatToNumber(RS2::AngleFormat af);
 151
 152                 static RS2::Unit numberToUnit(int num);
 153                 static int unitToNumber(RS2::Unit unit);
 154
 155                 static bool isVariableTwoDimensional(const QString & var);
 156
 157         private:
 158                 /** Pointer to the graphic we currently operate on. */
 159                 Drawing * graphic;
 160                 /** File name. Used to find out the full path of images. */
 161                 QString file;
 162                 /** string for concatinating text parts of MTEXT entities. */
 163                 QString mtext;
 164                 /** Pointer to current polyline entity we're adding vertices to. */
 165                 RS_Polyline * polyline;
 166                 /** Pointer to current spline entity we're adding control points to. */
 167                 RS_Spline * spline;
 168                 /** Pointer to current leader entity we're adding vertices to. */
 169                 RS_Leader * leader;
 170                 /** Pointer to current entity container (either block or graphic) */
 171                 RS_EntityContainer * currentContainer;
 172
 173                 /** Pointer to current hatch or NULL. */
 174                 RS_Hatch * hatch;
 175                 /** Pointer to current hatch loop or NULL. */
 176                 RS_EntityContainer * hatchLoop;
 177
 178                 DL_Dxf dxf;
 179                 RS_VariableDict variables;
 180 };
 181
 182 #endif