Merge pull request #4 from FOSSEE/develop

merging dev into master

1 files changed, 1342 insertions, 0 deletions

diff --git a/lib_dxf/drw_entities.h b/lib_dxf/drw_entities.h
new file mode 100644
index 0000000..7f7b085
--- /dev/null
+++ b/lib_dxf/drw_entities.h
@@ -0,0 +1,1342 @@
+/******************************************************************************
+**  libDXFrw - Library to read/write DXF files (ascii & binary)              **
+**                                                                           **
+**  Copyright (C) 2011 Rallaz, rallazz@gmail.com                             **
+**                                                                           **
+**  This library is free software, licensed under the terms of the GNU       **
+**  General Public License as published by the Free Software Foundation,     **
+**  either version 2 of the License, or (at your option) any later version.  **
+**  You should have received a copy of the GNU General Public License        **
+**  along with this program.  If not, see <http://www.gnu.org/licenses/>.    **
+******************************************************************************/
+
+#ifndef DRW_ENTITIES_H
+#define DRW_ENTITIES_H
+
+
+#include <string>
+#include <vector>
+#include "drw_base.h"
+
+class dxfReader;
+class DRW_Polyline;
+
+namespace DRW {
+// ! Entity's type.
+enum ETYPE
+{
+    POINT,
+    LINE,
+    CIRCLE,
+    ARC,
+    ELLIPSE,
+    TRACE,
+    SOLID,
+    BLOCK,
+    INSERT,
+    LWPOLYLINE,
+    POLYLINE,
+    VERTEX,
+    SPLINE,
+    HATCH,
+    TEXT,
+    MTEXT,
+    E3DFACE,
+    IMAGE,
+    LEADER,
+    DIMENSION,
+    DIMALIGNED,
+    DIMLINEAR,
+    DIMRADIAL,
+    DIMDIAMETRIC,
+    DIMANGULAR,
+    DIMANGULAR3P,
+    DIMORDINATE,
+
+// OVERLAYBOX,
+// CONSTRUCTIONLINE,
+    RAY,
+    XLINE,
+    VIEWPORT,
+    UNKNOWN
+};
+}
+
+// ! Base class for entities
+/*!
+ *  Base class for entities
+ *  @author Rallaz
+ */
+class DRW_Entity
+{
+public:
+    // initializes default values
+    DRW_Entity()
+    {
+        eType = DRW::UNKNOWN;
+        lineType = "BYLAYER";
+        color = 256;    // default BYLAYER (256)
+        ltypeScale = 1.0;
+        visible = true;
+        layer = "0";
+        lWeight = DRW_LW_Conv::widthByLayer;    // default BYLAYER  (dxf -1, dwg 29)
+        handleBlock = space = 0;                // default ModelSpace (0) & handleBlock = no handle (0)
+        haveExtrusion = false;
+        color24 = -1;                           // default -1 not set
+        handle  = 0;
+        curr = NULL;
+    }
+
+    virtual ~DRW_Entity()
+    {
+        for( std::vector<DRW_Variant*>::iterator it = extData.begin(); it!=extData.end(); ++it )
+            delete *it;
+
+        extData.clear();
+    }
+
+    DRW_Entity( const DRW_Entity& d )
+    {
+        eType   = d.eType;
+        handle  = d.handle;
+        handleBlock = d.handleBlock;
+        layer = d.layer;
+        lineType = d.lineType;
+        color = d.color;
+        color24 = d.color24;
+        colorName   = d.colorName;
+        ltypeScale  = d.ltypeScale;
+        visible = d.visible;
+        lWeight = d.lWeight;
+        space = d.space;
+        haveExtrusion = d.haveExtrusion;
+        curr = NULL;
+    }
+
+    virtual void applyExtrusion() = 0;
+
+protected:
+    void    parseCode( int code, dxfReader* reader );
+    void    calculateAxis( DRW_Coord extPoint );
+    void    extrudePoint( DRW_Coord extPoint, DRW_Coord* point );
+
+public:
+    enum DRW::ETYPE eType;                  /*!< enum: entity type, code 0 */
+    int handle;                             /*!< entity identifier, code 5 */
+    int handleBlock;                        /*!< Soft-pointer ID/handle to owner BLOCK_RECORD object, code 330 */
+    UTF8STRING  layer;                      /*!< layer name, code 8 */
+    UTF8STRING  lineType;                   /*!< line type, code 6 */
+    int color;                              /*!< entity color, code 62 */
+    enum DRW_LW_Conv::lineWidth lWeight;    /*!< entity lineweight, code 370 */
+    double  ltypeScale;                     /*!< linetype scale, code 48 */
+    bool    visible;                        /*!< entity visibility, code 60 */
+    int color24;                            /*!< 24-bit color, code 420 */
+    std::string colorName;                  /*!< color name, code 430 */
+    int space;                              /*!< space indicator 0 = model, 1 paper, code 67*/
+    bool haveExtrusion;                     /*!< set to true if the entity have extrusion*/
+    std::vector<DRW_Variant*> extData;      /*!< FIFO list of extended data, codes 1000 to 1071*/
+
+private:
+    DRW_Coord   extAxisX;
+    DRW_Coord   extAxisY;
+    DRW_Variant* curr;
+};
+
+
+// ! Class to handle point entity
+/*!
+ *  Class to handle point entity
+ *  @author Rallaz
+ */
+class DRW_Point : public DRW_Entity
+{
+public:
+    DRW_Point()
+    {
+        eType = DRW::POINT;
+        basePoint.z = extPoint.x = extPoint.y = 0;
+        extPoint.z  = 1;
+        thickness = 0;
+    }
+
+    virtual void applyExtrusion() {}
+
+    void parseCode( int code, dxfReader* reader );
+
+public:
+    DRW_Coord basePoint;        /*!<  base point, code 10, 20 & 30 */
+    double thickness;           /*!< thickness, code 39 */
+    DRW_Coord extPoint;         /*!<  Dir extrusion normal vector, code 210, 220 & 230 */
+};
+
+// ! Class to handle line entity
+/*!
+ *  Class to handle line entity
+ *  @author Rallaz
+ */
+class DRW_Line : public DRW_Point
+{
+public:
+    DRW_Line()
+    {
+        eType = DRW::LINE;
+        secPoint.z = 0;
+    }
+
+    virtual void applyExtrusion() {}
+    void parseCode( int code, dxfReader* reader );
+
+public:
+    DRW_Coord secPoint;        /*!< second point, code 11, 21 & 31 */
+};
+
+// ! Class to handle ray entity
+/*!
+ *  Class to handle ray entity
+ *  @author Rallaz
+ */
+class DRW_Ray : public DRW_Line
+{
+public:
+    DRW_Ray()
+    {
+        eType = DRW::RAY;
+    }
+};
+
+// ! Class to handle xline entity
+/*!
+ *  Class to handle xline entity
+ *  @author Rallaz
+ */
+class DRW_Xline : public DRW_Line
+{
+public:
+    DRW_Xline()
+    {
+        eType = DRW::XLINE;
+    }
+};
+
+// ! Class to handle circle entity
+/*!
+ *  Class to handle circle entity
+ *  @author Rallaz
+ */
+class DRW_Circle : public DRW_Point
+{
+public:
+    DRW_Circle()
+    {
+        eType = DRW::CIRCLE;
+        radious = 0.0;
+    }
+
+    virtual void    applyExtrusion();
+    void            parseCode( int code, dxfReader* reader );
+
+public:
+    double radious;                 /*!< radius, code 40 */
+};
+
+// ! Class to handle arc entity
+/*!
+ *  Class to handle arc entity
+ *  @author Rallaz
+ */
+class DRW_Arc : public DRW_Circle
+{
+public:
+    DRW_Arc()
+    {
+        eType   = DRW::ARC;
+        isccw   = 1;
+        staangle    = 0.0;
+        endangle    = 0.0;
+    }
+
+    virtual void    applyExtrusion();
+    void            parseCode( int code, dxfReader* reader );
+
+public:
+    double  staangle;           /*!< start angle, code 50 in radians*/
+    double  endangle;           /*!< end angle, code 51 in radians */
+    int isccw;                  /*!< is counter clockwise arc?, only used in hatch, code 73 */
+};
+
+// ! Class to handle ellipse entity
+/*!
+ *  Class to handle ellipse and elliptic arc entity
+ *  Note: start/end parameter are in radians for ellipse entity but
+ *  for hatch boundary are in degrees
+ *  @author Rallaz
+ */
+class DRW_Ellipse : public DRW_Line
+{
+public:
+    DRW_Ellipse()
+    {
+        eType   = DRW::ELLIPSE;
+        isccw   = 1;
+        ratio   = 1.0;
+        staparam = endparam = 0;
+    }
+
+    void            parseCode( int code, dxfReader* reader );
+    void            toPolyline( DRW_Polyline* pol, int parts = 128 );
+    virtual void    applyExtrusion();
+    void            correctAxis();
+
+public:
+    double  ratio;          /*!< ratio, code 40 */
+    double  staparam;       /*!< start parameter, code 41, 0.0 for full ellipse*/
+    double  endparam;       /*!< end parameter, code 42, 2*PI for full ellipse */
+    int isccw;              /*!< is counter clockwise arc?, only used in hatch, code 73 */
+};
+
+// ! Class to handle trace entity
+/*!
+ *  Class to handle trace entity
+ *  @author Rallaz
+ */
+class DRW_Trace : public DRW_Line
+{
+public:
+    DRW_Trace()
+    {
+        eType = DRW::TRACE;
+        thirdPoint.z    = 0;
+        fourPoint.z     = 0;
+    }
+
+    virtual void    applyExtrusion();
+    void            parseCode( int code, dxfReader* reader );
+
+public:
+    DRW_Coord   thirdPoint;     /*!< third point, code 12, 22 & 32 */
+    DRW_Coord   fourPoint;      /*!< four point, code 13, 23 & 33 */
+};
+
+// ! Class to handle solid entity
+/*!
+ *  Class to handle solid entity
+ *  @author Rallaz
+ */
+class DRW_Solid : public DRW_Trace
+{
+public:
+    DRW_Solid()
+    {
+        eType = DRW::SOLID;
+    }
+
+    void parseCode( int code, dxfReader* reader );
+};
+
+// ! Class to handle 3dface entity
+/*!
+ *  Class to handle 3dface entity
+ *  @author Rallaz
+ */
+class DRW_3Dface : public DRW_Trace
+{
+public:
+    DRW_3Dface()
+    {
+        eType = DRW::E3DFACE;
+        invisibleflag = 0;
+    }
+
+    virtual void applyExtrusion() {}
+    void parseCode( int code, dxfReader* reader );
+
+public:
+    int invisibleflag;       /*!< invisible edge flag, code 70 */
+};
+
+// ! Class to handle block entries
+/*!
+ *  Class to handle block entries
+ *  @author Rallaz
+ */
+class DRW_Block : public DRW_Point
+{
+public:
+    DRW_Block()
+    {
+        eType   = DRW::BLOCK;
+        layer   = "0";
+        flags   = 0;
+        name    = "*U0";
+    }
+
+    virtual void applyExtrusion() {}
+    void parseCode( int code, dxfReader* reader );
+
+public:
+    UTF8STRING name;                /*!< block name, code 2 */
+    int flags;                      /*!< block type, code 70 */
+};
+
+
+// ! Class to handle insert entries
+/*!
+ *  Class to handle insert entries
+ *  @author Rallaz
+ */
+class DRW_Insert : public DRW_Point
+{
+public:
+    DRW_Insert()
+    {
+        eType   = DRW::INSERT;
+        xscale  = 1;
+        yscale  = 1;
+        zscale  = 1;
+        angle   = 0;
+        colcount    = 1;
+        rowcount    = 1;
+        colspace    = 0;
+        rowspace    = 0;
+    }
+
+    virtual void applyExtrusion() { DRW_Point::applyExtrusion(); }
+    void parseCode( int code, dxfReader* reader );
+
+public:
+    UTF8STRING name;            /*!< block name, code 2 */
+    double  xscale;             /*!< x scale factor, code 41 */
+    double  yscale;             /*!< y scale factor, code 42 */
+    double  zscale;             /*!< z scale factor, code 43 */
+    double  angle;              /*!< rotation angle, code 50 */
+    int colcount;               /*!< column count, code 70 */
+    int rowcount;               /*!< row count, code 71 */
+    double  colspace;           /*!< column space, code 44 */
+    double  rowspace;           /*!< row space, code 45 */
+};
+
+// ! Class to handle lwpolyline entity
+/*!
+ *  Class to handle lwpolyline entity
+ *  @author Rallaz
+ */
+class DRW_LWPolyline : public DRW_Entity
+{
+public:
+    DRW_LWPolyline()
+    {
+        eType = DRW::LWPOLYLINE;
+        elevation = thickness = width = 0.0;
+        flags = 0;
+        extPoint.x  = extPoint.y = 0;
+        extPoint.z  = 1;
+        vertex = NULL;
+        vertexnum = 0;
+    }
+
+    ~DRW_LWPolyline()
+    {
+        while( !vertlist.empty() )
+        {
+            vertlist.pop_back();
+        }
+    }
+
+    virtual void applyExtrusion();
+
+    void addVertex( DRW_Vertex2D v )
+    {
+        DRW_Vertex2D* vert = new DRW_Vertex2D();
+
+        vert->x = v.x;
+        vert->y = v.y;
+        vert->stawidth  = v.stawidth;
+        vert->endwidth  = v.endwidth;
+        vert->bulge = v.bulge;
+        vertlist.push_back( vert );
+    }
+
+    DRW_Vertex2D* addVertex()
+    {
+        DRW_Vertex2D* vert = new DRW_Vertex2D();
+
+        vert->stawidth  = 0;
+        vert->endwidth  = 0;
+        vert->bulge = 0;
+        vertlist.push_back( vert );
+        return vert;
+    }
+
+    void parseCode( int code, dxfReader* reader );
+
+public:
+    int vertexnum;                          /*!< number of vertex, code 90 */
+    int flags;                              /*!< polyline flag, code 70, default 0 */
+    double  width;                          /*!< constant width, code 43 */
+    double  elevation;                      /*!< elevation, code 38 */
+    double  thickness;                      /*!< thickness, code 39 */
+    DRW_Coord extPoint;                     /*!<  Dir extrusion normal vector, code 210, 220 & 230 */
+    DRW_Vertex2D* vertex;                   /*!< current vertex to add data */
+    std::vector<DRW_Vertex2D*> vertlist;    /*!< vertex list */
+};
+
+// ! Class to handle insert entries
+/*!
+ *  Class to handle insert entries
+ *  @author Rallaz
+ */
+class DRW_Text : public DRW_Line
+{
+public:
+    // ! Vertical alignments.
+    enum VAlign
+    {
+        VBaseLine = 0,      /*!< Top = 0 */
+        VBottom,            /*!< Bottom = 1 */
+        VMiddle,            /*!< Middle = 2 */
+        VTop                /*!< Top = 3 */
+    };
+
+    // ! Horizontal alignments.
+    enum HAlign
+    {
+        HLeft = 0,          /*!< Left = 0 */
+        HCenter,            /*!< Centered = 1 */
+        HRight,             /*!< Right = 2 */
+        HAligned,           /*!< Aligned = 3 (if VAlign==0) */
+        HMiddle,            /*!< middle = 4 (if VAlign==0) */
+        HFit                /*!< fit into point = 5 (if VAlign==0) */
+    };
+
+    DRW_Text()
+    {
+        eType   = DRW::TEXT;
+        angle   = 0;
+        widthscale = 1;
+        oblique = 0;
+        style = "STANDARD";
+        textgen = 0;
+        alignH  = HLeft;
+        alignV  = VBaseLine;
+        height  = 0.0;
+    }
+
+    virtual void applyExtrusion() {}    // RLZ TODO
+    void parseCode( int code, dxfReader* reader );
+
+public:
+    double height;              /*!< height text, code 40 */
+    UTF8STRING text;            /*!< text string, code 1 */
+    double  angle;              /*!< rotation angle in degrees (360), code 50 */
+    double  widthscale;         /*!< width factor, code 41 */
+    double  oblique;            /*!< oblique angle, code 51 */
+    UTF8STRING style;           /*!< style name, code 7 */
+    int textgen;                /*!< text generation, code 71 */
+    enum HAlign alignH;         /*!< horizontal align, code 72 */
+    enum VAlign alignV;         /*!< vertical align, code 73 */
+};
+
+// ! Class to handle insert entries
+/*!
+ *  Class to handle insert entries
+ *  @author Rallaz
+ */
+class DRW_MText : public DRW_Text
+{
+public:
+    // ! Attachments.
+    enum Attach
+    {
+        TopLeft = 1,
+        TopCenter,
+        TopRight,
+        MiddleLeft,
+        MiddleCenter,
+        MiddleRight,
+        BottomLeft,
+        BottomCenter,
+        BottomRight
+    };
+
+    DRW_MText()
+    {
+        eType = DRW::MTEXT;
+        interlin = 1;
+        alignV  = (VAlign) TopLeft;
+        textgen = 1;
+        haveXAxis = false;    // if true needed to recalculate angle
+    }
+
+    void    parseCode( int code, dxfReader* reader );
+    void    updateAngle(); // recalculate angle if 'haveXAxis' is true
+
+public:
+    double interlin;     /*!< width factor, code 44 */
+
+private:
+    bool haveXAxis;
+};
+
+// ! Class to handle vertex
+/*!
+ *  Class to handle vertex  for polyline entity
+ *  @author Rallaz
+ */
+class DRW_Vertex : public DRW_Point
+{
+public:
+    DRW_Vertex()
+    {
+        eType = DRW::VERTEX;
+        stawidth    = endwidth = bulge = 0;
+        vindex1     = vindex2 = vindex3 = vindex4 = 0;
+        flags   = identifier = 0;
+        tgdir   = 0.0;
+    }
+
+    DRW_Vertex( double sx, double sy, double sz, double b )
+    {
+        stawidth    = endwidth = 0;
+        vindex1     = vindex2 = vindex3 = vindex4 = 0;
+        flags = identifier = 0;
+        basePoint.x = sx;
+        basePoint.y = sy;
+        basePoint.z = sz;
+        bulge   = b;
+        tgdir   = 0.0;
+    }
+
+    void parseCode( int code, dxfReader* reader );
+
+public:
+    double  stawidth;       /*!< Start width, code 40 */
+    double  endwidth;       /*!< End width, code 41 */
+    double  bulge;          /*!< bulge, code 42 */
+
+    int flags;              /*!< vertex flag, code 70, default 0 */
+    double tgdir;           /*!< curve fit tangent direction, code 50 */
+    int vindex1;            /*!< polyface mesh vertex index, code 71, default 0 */
+    int vindex2;            /*!< polyface mesh vertex index, code 72, default 0 */
+    int vindex3;            /*!< polyface mesh vertex index, code 73, default 0 */
+    int vindex4;            /*!< polyface mesh vertex index, code 74, default 0 */
+    int identifier;         /*!< vertex identifier, code 91, default 0 */
+};
+
+// ! Class to handle polyline entity
+/*!
+ *  Class to handle polyline entity
+ *  @author Rallaz
+ */
+class DRW_Polyline : public DRW_Point
+{
+public:
+    DRW_Polyline()
+    {
+        eType = DRW::POLYLINE;
+        defstawidth = defendwidth = 0.0;
+        basePoint.x = basePoint.y = 0.0;
+        flags = vertexcount = facecount = 0;
+        smoothM = smoothN = curvetype = 0;
+    }
+
+    ~DRW_Polyline()
+    {
+        while( !vertlist.empty() )
+        {
+            vertlist.pop_back();
+        }
+    }
+
+    void addVertex( DRW_Vertex v )
+    {
+        DRW_Vertex* vert = new DRW_Vertex();
+
+        vert->basePoint.x   = v.basePoint.x;
+        vert->basePoint.y   = v.basePoint.y;
+        vert->basePoint.z   = v.basePoint.z;
+        vert->stawidth  = v.stawidth;
+        vert->endwidth  = v.endwidth;
+        vert->bulge = v.bulge;
+        vertlist.push_back( vert );
+    }
+
+    void appendVertex( DRW_Vertex* v )
+    {
+        vertlist.push_back( v );
+    }
+
+    void parseCode( int code, dxfReader* reader );
+
+public:
+    int flags;                          /*!< polyline flag, code 70, default 0 */
+    double  defstawidth;                /*!< Start width, code 40, default 0 */
+    double  defendwidth;                /*!< End width, code 41, default 0 */
+    int vertexcount;                    /*!< polygon mesh M vertex or  polyface vertex num, code 71, default 0 */
+    int facecount;                      /*!< polygon mesh N vertex or  polyface face num, code 72, default 0 */
+    int smoothM;                        /*!< smooth surface M density, code 73, default 0 */
+    int smoothN;                        /*!< smooth surface M density, code 74, default 0 */
+    int curvetype;                      /*!< curves & smooth surface type, code 75, default 0 */
+
+    std::vector<DRW_Vertex*> vertlist;  /*!< vertex list */
+};
+
+
+// ! Class to handle spline entity
+/*!
+ *  Class to handle spline entity
+ *  @author Rallaz
+ */
+class DRW_Spline : public DRW_Entity
+{
+public:
+    DRW_Spline()
+    {
+        eType   = DRW::SPLINE;
+        flags   = nknots = ncontrol = nfit = 0;
+        ex  = ey = 0.0;
+        ez  = 1.0;
+        tolknot = tolcontrol = tolfit = 0.0000001;
+        tgsx = tgsy = tgsz = tgex = tgey = tgez = 0.0;
+        degree = 0;
+        controlpoint = 0;
+        fitpoint = 0;
+    }
+
+    ~DRW_Spline()
+    {
+        while( !controllist.empty() )
+        {
+            controllist.pop_back();
+        }
+
+        while( !fitlist.empty() )
+        {
+            fitlist.pop_back();
+        }
+    }
+
+    virtual void applyExtrusion() {}
+
+    void parseCode( int code, dxfReader* reader );
+
+public:
+    double  ex;                             /*!< normal vector x coordinate, code 210 */
+    double  ey;                             /*!< normal vector y coordinate, code 220 */
+    double  ez;                             /*!< normal vector z coordinate, code 230 */
+    double  tgsx;                           /*!< start tangent x coordinate, code 12 */
+    double  tgsy;                           /*!< start tangent y coordinate, code 22 */
+    double  tgsz;                           /*!< start tangent z coordinate, code 32 */
+    double  tgex;                           /*!< end tangent x coordinate, code 13 */
+    double  tgey;                           /*!< end tangent y coordinate, code 23 */
+    double  tgez;                           /*!< end tangent z coordinate, code 33 */
+    int flags;                              /*!< spline flag, code 70 */
+    int degree;                             /*!< degree of the spline, code 71 */
+    int nknots;                             /*!< number of knots, code 72, default 0 */
+    int ncontrol;                           /*!< number of control points, code 73, default 0 */
+    int nfit;                               /*!< number of fit points, code 74, default 0 */
+    double  tolknot;                        /*!< knot tolerance, code 42, default 0.0000001 */
+    double  tolcontrol;                     /*!< control point tolerance, code 43, default 0.0000001 */
+    double  tolfit;                         /*!< fit point tolerance, code 44, default 0.0000001 */
+
+    std::vector<double> knotslist;          /*!< knots list, code 40 */
+    std::vector<DRW_Coord*> controllist;    /*!< control points list, code 10, 20 & 30 */
+    std::vector<DRW_Coord*> fitlist;        /*!< fit points list, code 11, 21 & 31 */
+
+private:
+    DRW_Coord*  controlpoint;   /*!< current control point to add data */
+    DRW_Coord*  fitpoint;       /*!< current fit point to add data */
+};
+
+// ! Class to handle hatch loop
+/*!
+ *  Class to handle hatch loop
+ *  @author Rallaz
+ */
+class DRW_HatchLoop
+{
+public:
+    DRW_HatchLoop( int t )
+    {
+        type = t;
+        numedges = 0;
+    }
+
+    ~DRW_HatchLoop()
+    {
+/*        while (!pollist.empty()) {
+ *          pollist.pop_back();
+ *        }*/
+        while( !objlist.empty() )
+        {
+            objlist.pop_back();
+        }
+    }
+
+    void update()
+    {
+        numedges = objlist.size();
+    }
+
+public:
+    int type;               /*!< boundary path type, code 92, polyline=2, default=0 */
+    int numedges;           /*!< number of edges (if not a polyline), code 93 */
+// TODO: store lwpolylines as entities
+// std::vector<DRW_LWPolyline *> pollist;  /*!< polyline list */
+    std::vector<DRW_Entity*> objlist;      /*!< entities list */
+};
+
+// ! Class to handle hatch entity
+/*!
+ *  Class to handle hatch entity
+ *  @author Rallaz
+ */
+// TODO: handle lwpolylines, splines and ellipses
+class DRW_Hatch : public DRW_Point
+{
+public:
+    DRW_Hatch()
+    {
+        eType   = DRW::HATCH;
+        angle   = scale = 0.0;
+        basePoint.x = basePoint.y = basePoint.z = 0.0;
+        loopsnum = hstyle = associative = 0;
+        solid = hpattern = 1;
+        deflines = doubleflag = 0;
+        loop = NULL;
+        clearEntities();
+        ispol = false;
+    }
+
+    ~DRW_Hatch()
+    {
+        while( !looplist.empty() )
+        {
+            looplist.pop_back();
+        }
+    }
+
+    void appendLoop( DRW_HatchLoop* v )
+    {
+        looplist.push_back( v );
+    }
+
+    virtual void applyExtrusion() {}
+    void parseCode( int code, dxfReader* reader );
+
+public:
+    UTF8STRING name;                        /*!< hatch pattern name, code 2 */
+    int solid;                              /*!< solid fill flag, code 70, solid=1, pattern=0 */
+    int associative;                        /*!< associativity, code 71, associatve=1, non-assoc.=0 */
+    int hstyle;                             /*!< hatch style, code 75 */
+    int hpattern;                           /*!< hatch pattern type, code 76 */
+    int doubleflag;                         /*!< hatch pattern double flag, code 77, double=1, single=0 */
+    int loopsnum;                           /*!< namber of boundary paths (loops), code 91 */
+    double  angle;                          /*!< hatch pattern angle, code 52 */
+    double  scale;                          /*!< hatch pattern scale, code 41 */
+    int deflines;                           /*!< number of pattern definition lines, code 78 */
+
+    std::vector<DRW_HatchLoop*> looplist;   /*!< polyline list */
+
+private:
+    void clearEntities()
+    {
+        pt = line = NULL;
+        pline = NULL;
+        arc = NULL;
+        ellipse = NULL;
+        spline  = NULL;
+        plvert  = NULL;
+    }
+
+    void addLine()
+    {
+        clearEntities();
+
+        if( loop )
+        {
+            pt = line = new DRW_Line;
+            loop->objlist.push_back( line );
+        }
+    }
+
+    void addArc()
+    {
+        clearEntities();
+
+        if( loop )
+        {
+            pt = arc = new DRW_Arc;
+            loop->objlist.push_back( arc );
+        }
+    }
+
+    void addEllipse()
+    {
+        clearEntities();
+
+        if( loop )
+        {
+            pt = ellipse = new DRW_Ellipse;
+            loop->objlist.push_back( ellipse );
+        }
+    }
+
+    void addSpline()
+    {
+        clearEntities();
+
+        if( loop )
+        {
+            pt = NULL;
+            spline = new DRW_Spline;
+            loop->objlist.push_back( spline );
+        }
+    }
+
+    DRW_HatchLoop* loop;       /*!< current loop to add data */
+    DRW_Line*   line;
+    DRW_Arc*    arc;
+    DRW_Ellipse*    ellipse;
+    DRW_Spline*     spline;
+    DRW_LWPolyline* pline;
+    DRW_Point* pt;
+    DRW_Vertex2D* plvert;
+    bool ispol;
+};
+
+// ! Class to handle image entity
+/*!
+ *  Class to handle image entity
+ *  @author Rallaz
+ */
+class DRW_Image : public DRW_Line
+{
+public:
+    DRW_Image()
+    {
+        eType = DRW::IMAGE;
+        vz = fade = clip = 0;
+        brightness = contrast = 50;
+        vx = vy = sizeu = sizev = dz = 0.0;
+    }
+
+    void parseCode( int code, dxfReader* reader );
+
+public:
+    std::string ref;            /*!< Hard reference to imagedef object, code 340 */
+    double  vx;                 /*!< V-vector of single pixel, x coordinate, code 12 */
+    double  vy;                 /*!< V-vector of single pixel, y coordinate, code 22 */
+    double  vz;                 /*!< V-vector of single pixel, z coordinate, code 32 */
+    double  sizeu;              /*!< image size in pixels, U value, code 13 */
+    double  sizev;              /*!< image size in pixels, V value, code 23 */
+    double  dz;                 /*!< z coordinate, code 33 */
+    int clip;                   /*!< Clipping state, code 280, 0=off 1=on */
+    int brightness;             /*!< Brightness value, code 281, (0-100) default 50 */
+    int contrast;               /*!< Brightness value, code 282, (0-100) default 50 */
+    int fade;                   /*!< Brightness value, code 283, (0-100) default 0 */
+};
+
+
+// ! Base class for dimension entity
+/*!
+ *  Base class for dimension entity
+ *  @author Rallaz
+ */
+class DRW_Dimension : public DRW_Entity
+{
+public:
+    DRW_Dimension()
+    {
+        eType = DRW::DIMENSION;
+        linesty = 1;
+        linefactor = extPoint.z = 1.0;
+        angle   = oblique = rot = 0.0;
+        align   = 5;
+        style   = "STANDARD";
+        defPoint.z      = extPoint.x = extPoint.y = 0;
+        textPoint.z     = rot = 0;
+        clonePoint.x    = clonePoint.y = clonePoint.z = 0;
+        type = 0;
+        length = 0.0;
+    }
+
+    DRW_Dimension( const DRW_Dimension& d ) : DRW_Entity( d )
+    {
+        eType   = DRW::DIMENSION;
+        type    = d.type;
+        name    = d.name;
+        defPoint    = d.defPoint;
+        textPoint   = d.textPoint;
+        text    = d.text;
+        style   = d.style;
+        align   = d.align;
+        linesty = d.linesty;
+        linefactor = d.linefactor;
+        rot = d.rot;
+        extPoint = d.extPoint;
+        clonePoint = d.clonePoint;
+        def1    = d.def1;
+        def2    = d.def2;
+        angle   = d.angle;
+        oblique     = d.oblique;
+        arcPoint    = d.arcPoint;
+        circlePoint = d.circlePoint;
+        length = d.length;
+    }
+
+    virtual ~DRW_Dimension() {}
+
+    void parseCode( int code, dxfReader* reader );
+
+    virtual void applyExtrusion() {}
+
+    DRW_Coord getDefPoint() const { return defPoint; }      /*!< Definition point, code 10, 20 & 30 */
+    void setDefPoint( const DRW_Coord& p ) { defPoint = p; }
+    DRW_Coord getTextPoint() const { return textPoint; }    /*!< Middle point of text, code 11, 21 & 31 */
+    void setTextPoint( const DRW_Coord& p ) { textPoint = p; }
+    std::string getStyle() const { return style; }          /*!< Dimension style, code 3 */
+    void setStyle( const std::string& s ) { style = s; }
+    int getAlign() const { return align; }                  /*!< attachment point, code 71 */
+    void setAlign( const int a ) { align = a; }
+    int getTextLineStyle() const { return linesty; }        /*!< Dimension text line spacing style, code 72, default 1 */
+    void setTextLineStyle( const int l ) { linesty = l; }
+    std::string getText() const { return text; }            /*!< Dimension text explicitly entered by the user, code 1 */
+    void setText( const std::string& t ) { text = t; }
+    double getTextLineFactor() const { return linefactor; } /*!< Dimension text line spacing factor, code 41, default 1? */
+    void setTextLineFactor( const double l ) { linefactor = l; }
+    double getDir() const { return rot; }                   /*!< rotation angle of the dimension text, code 53 (optional) default 0 */
+    void setDir( const double d ) { rot = d; }
+
+    DRW_Coord getExtrusion() { return extPoint; }               /*!< extrusion, code 210, 220 & 230 */
+    void setExtrusion( const DRW_Coord& p ) { extPoint = p; }
+    std::string getName() { return name; }                      /*!< Name of the block that contains the entities, code 2 */
+    void setName( const std::string& s ) { name = s; }
+// int getType(){ return type;}                      /*!< Dimension type, code 70 */
+
+protected:
+    DRW_Coord getPt2() const { return clonePoint; }
+    void setPt2( const DRW_Coord& p ) { clonePoint = p; }
+    DRW_Coord getPt3() const { return def1; }
+    void setPt3( const DRW_Coord& p ) { def1 = p; }
+    DRW_Coord getPt4() const { return def2; }
+    void setPt4( const DRW_Coord& p ) { def2 = p; }
+    DRW_Coord getPt5() const { return circlePoint; }
+    void setPt5( const DRW_Coord& p ) { circlePoint = p; }
+    DRW_Coord getPt6() const { return arcPoint; }
+    void setPt6( const DRW_Coord& p ) { arcPoint = p; }
+    double getAn50() const { return angle; }        /*!< Angle of rotated, horizontal, or vertical dimensions, code 50 */
+    void setAn50( const double d ) { angle = d; }
+    double getOb52() const { return oblique; }      /*!< oblique angle, code 52 */
+    void setOb52( const double d ) { oblique = d; }
+    double getRa40() const { return length; }       /*!< Leader length, code 40 */
+    void setRa40( const double d ) { length = d; }
+
+public:
+    int type;                  /*!< Dimension type, code 70 */
+
+private:
+    std::string name;           /*!< Name of the block that contains the entities, code 2 */
+    DRW_Coord   defPoint;       /*!<  definition point, code 10, 20 & 30 (WCS) */
+    DRW_Coord   textPoint;      /*!< Middle point of text, code 11, 21 & 31 (OCS) */
+    UTF8STRING  text;           /*!< Dimension text explicitly entered by the user, code 1 */
+    UTF8STRING  style;          /*!< Dimension style, code 3 */
+    int align;                  /*!< attachment point, code 71 */
+    int linesty;                /*!< Dimension text line spacing style, code 72, default 1 */
+    double  linefactor;         /*!< Dimension text line spacing factor, code 41, default 1? (value range 0.25 to 4.00*/
+    double  rot;                /*!< rotation angle of the dimension text, code 53 */
+    DRW_Coord extPoint;         /*!<  extrusion normal vector, code 210, 220 & 230 */
+
+    // double hdir;               /*!< horizontal direction for the dimension, code 51, default ? */
+    DRW_Coord   clonePoint;     /*!< Insertion point for clones (Baseline & Continue), code 12, 22 & 32 (OCS) */
+    DRW_Coord   def1;           /*!< Definition point 1for linear & angular, code 13, 23 & 33 (WCS) */
+    DRW_Coord   def2;           /*!< Definition point 2, code 14, 24 & 34 (WCS) */
+    double  angle;              /*!< Angle of rotated, horizontal, or vertical dimensions, code 50 */
+    double  oblique;            /*!< oblique angle, code 52 */
+
+    DRW_Coord   circlePoint;    /*!< Definition point for diameter, radius & angular dims code 15, 25 & 35 (WCS) */
+    DRW_Coord   arcPoint;       /*!< Point defining dimension arc, x coordinate, code 16, 26 & 36 (OCS) */
+    double length;              /*!< Leader length, code 40 */
+};
+
+
+// ! Class to handle  aligned dimension entity
+/*!
+ *  Class to handle aligned dimension entity
+ *  @author Rallaz
+ */
+class DRW_DimAligned : public DRW_Dimension
+{
+public:
+    DRW_DimAligned()
+    {
+        eType = DRW::DIMALIGNED;
+    }
+
+    DRW_DimAligned( const DRW_Dimension& d ) : DRW_Dimension( d )
+    {
+        eType = DRW::DIMALIGNED;
+    }
+
+    DRW_Coord getClonepoint() const { return getPt2(); }      /*!< Insertion for clones (Baseline & Continue), 12, 22 & 32 */
+    void setClonePoint( DRW_Coord& c ) { setPt2( c ); }
+
+    DRW_Coord getDimPoint() const { return getDefPoint(); }     /*!< dim line location point, code 10, 20 & 30 */
+    void setDimPoint( const DRW_Coord& p ) { setDefPoint( p ); }
+    DRW_Coord getDef1Point() const { return getPt3(); }         /*!< Definition point 1, code 13, 23 & 33 */
+    void setDef1Point( const DRW_Coord& p ) { setPt3( p ); }
+    DRW_Coord getDef2Point() const { return getPt4(); }         /*!< Definition point 2, code 14, 24 & 34 */
+    void setDef2Point( const DRW_Coord& p ) { setPt4( p ); }
+};
+
+// ! Class to handle  linear or rotated dimension entity
+/*!
+ *  Class to handle linear or rotated dimension entity
+ *  @author Rallaz
+ */
+class DRW_DimLinear : public DRW_DimAligned
+{
+public:
+    DRW_DimLinear()
+    {
+        eType = DRW::DIMLINEAR;
+    }
+
+    DRW_DimLinear( const DRW_Dimension& d ) : DRW_DimAligned( d )
+    {
+        eType = DRW::DIMLINEAR;
+    }
+
+    double getAngle() const { return getAn50(); }           /*!< Angle of rotated, horizontal, or vertical dimensions, code 50 */
+    void setAngle( const double d ) { setAn50( d ); }
+    double getOblique() const { return getOb52(); }         /*!< oblique angle, code 52 */
+    void setOblique( const double d ) { setOb52( d ); }
+};
+
+// ! Class to handle radial dimension entity
+/*!
+ *  Class to handle aligned, linear or rotated dimension entity
+ *  @author Rallaz
+ */
+class DRW_DimRadial : public DRW_Dimension
+{
+public:
+    DRW_DimRadial()
+    {
+        eType = DRW::DIMRADIAL;
+    }
+
+    DRW_DimRadial( const DRW_Dimension& d ) : DRW_Dimension( d )
+    {
+        eType = DRW::DIMRADIAL;
+    }
+
+    DRW_Coord getCenterPoint() const { return getDefPoint(); }      /*!< center point, code 10, 20 & 30 */
+    void setCenterPoint( const DRW_Coord& p ) { setDefPoint( p ); }
+    DRW_Coord getDiameterPoint() const { return getPt5(); }         /*!< Definition point for radius, code 15, 25 & 35 */
+    void setDiameterPoint( const DRW_Coord& p ) { setPt5( p ); }
+    double getLeaderLength() const { return getRa40(); }            /*!< Leader length, code 40 */
+    void setLeaderLength( const double d ) { setRa40( d ); }
+};
+
+// ! Class to handle radial dimension entity
+/*!
+ *  Class to handle aligned, linear or rotated dimension entity
+ *  @author Rallaz
+ */
+class DRW_DimDiametric : public DRW_Dimension
+{
+public:
+    DRW_DimDiametric()
+    {
+        eType = DRW::DIMDIAMETRIC;
+    }
+
+    DRW_DimDiametric( const DRW_Dimension& d ) : DRW_Dimension( d )
+    {
+        eType = DRW::DIMDIAMETRIC;
+    }
+
+    DRW_Coord getDiameter1Point() const { return getPt5(); }        /*!< First definition point for diameter, code 15, 25 & 35 */
+    void setDiameter1Point( const DRW_Coord& p ) { setPt5( p ); }
+    DRW_Coord getDiameter2Point() const { return getDefPoint(); }   /*!< Oposite point for diameter, code 10, 20 & 30 */
+    void setDiameter2Point( const DRW_Coord& p ) { setDefPoint( p ); }
+    double getLeaderLength() const { return getRa40(); }            /*!< Leader length, code 40 */
+    void setLeaderLength( const double d ) { setRa40( d ); }
+};
+
+// ! Class to handle angular dimension entity
+/*!
+ *  Class to handle angular dimension entity
+ *  @author Rallaz
+ */
+class DRW_DimAngular : public DRW_Dimension
+{
+public:
+    DRW_DimAngular()
+    {
+        eType = DRW::DIMANGULAR;
+    }
+
+    DRW_DimAngular( const DRW_Dimension& d ) : DRW_Dimension( d )
+    {
+        eType = DRW::DIMANGULAR;
+    }
+
+    DRW_Coord getFirstLine1() const { return getPt3(); }        /*!< Definition point line 1-1, code 13, 23 & 33 */
+    void setFirstLine1( const DRW_Coord& p ) { setPt3( p ); }
+    DRW_Coord getFirstLine2() const { return getPt4(); }        /*!< Definition point line 1-2, code 14, 24 & 34 */
+    void setFirstLine2( const DRW_Coord& p ) { setPt4( p ); }
+    DRW_Coord getSecondLine1() const { return getPt5(); }       /*!< Definition point line 2-1, code 15, 25 & 35 */
+    void setSecondLine1( const DRW_Coord& p ) { setPt5( p ); }
+    DRW_Coord getSecondLine2() const { return getDefPoint(); }  /*!< Definition point line 2-2, code 10, 20 & 30 */
+    void setSecondLine2( const DRW_Coord& p ) { setDefPoint( p ); }
+    DRW_Coord getDimPoint() const { return getPt6(); }          /*!< Dimension definition point, code 16, 26 & 36 */
+    void setDimPoint( const DRW_Coord& p ) { setPt6( p ); }
+};
+
+
+// ! Class to handle angular 3p dimension entity
+/*!
+ *  Class to handle angular 3p dimension entity
+ *  @author Rallaz
+ */
+class DRW_DimAngular3p : public DRW_Dimension
+{
+public:
+    DRW_DimAngular3p()
+    {
+        eType = DRW::DIMANGULAR3P;
+    }
+
+    DRW_DimAngular3p( const DRW_Dimension& d ) : DRW_Dimension( d )
+    {
+        eType = DRW::DIMANGULAR3P;
+    }
+
+    DRW_Coord getFirstLine() const { return getPt3(); }         /*!< Definition point line 1, code 13, 23 & 33 */
+    void setFirstLine( const DRW_Coord& p ) { setPt3( p ); }
+    DRW_Coord getSecondLine() const { return getPt4(); }        /*!< Definition point line 2, code 14, 24 & 34 */
+    void setSecondLine( const DRW_Coord& p ) { setPt4( p ); }
+    DRW_Coord getVertexPoint() const { return getPt5(); }       /*!< Vertex point, code 15, 25 & 35 */
+    void SetVertexPoint( const DRW_Coord& p ) { setPt5( p ); }
+    DRW_Coord getDimPoint() const { return getDefPoint(); }     /*!< Dimension definition point, code 10, 20 & 30 */
+    void setDimPoint( const DRW_Coord& p ) { setDefPoint( p ); }
+};
+
+// ! Class to handle ordinate dimension entity
+/*!
+ *  Class to handle ordinate dimension entity
+ *  @author Rallaz
+ */
+class DRW_DimOrdinate : public DRW_Dimension
+{
+public:
+    DRW_DimOrdinate()
+    {
+        eType = DRW::DIMORDINATE;
+    }
+
+    DRW_DimOrdinate( const DRW_Dimension& d ) : DRW_Dimension( d )
+    {
+        eType = DRW::DIMORDINATE;
+    }
+
+    DRW_Coord getOriginPoint() const { return getDefPoint(); }      /*!< Origin definition point, code 10, 20 & 30 */
+    void setOriginPoint( const DRW_Coord& p ) { setDefPoint( p ); }
+    DRW_Coord getFirstLine() const { return getPt3(); }             /*!< Feature location point, code 13, 23 & 33 */
+    void setFirstLine( const DRW_Coord& p ) { setPt3( p ); }
+    DRW_Coord getSecondLine() const { return getPt4(); }            /*!< Leader end point, code 14, 24 & 34 */
+    void setSecondLine( const DRW_Coord& p ) { setPt4( p ); }
+};
+
+
+// ! Class to handle leader entity
+/*!
+ *  Class to handle leader entity
+ *  @author Rallaz
+ */
+class DRW_Leader : public DRW_Entity
+{
+public:
+    DRW_Leader()
+    {
+        eType   = DRW::LEADER;
+        flag    = 3;
+        hookflag = vertnum = leadertype = 0;
+        extrusionPoint.x = extrusionPoint.y = 0.0;
+        arrow = 1;
+        extrusionPoint.z = 1.0;
+        hookline = 0;
+        textheight = textwidth = 0.0;
+        coloruse = 0;
+        vertexpoint = NULL;
+    }
+
+    ~DRW_Leader()
+    {
+        while( !vertexlist.empty() )
+        {
+            vertexlist.pop_back();
+        }
+    }
+
+    virtual void applyExtrusion() {}
+    void parseCode( int code, dxfReader* reader );
+
+public:
+    UTF8STRING style;                   /*!< Dimension style name, code 3 */
+    int arrow;                          /*!< Arrowhead flag, code 71, 0=Disabled; 1=Enabled */
+    int leadertype;                     /*!< Leader path type, code 72, 0=Straight line segments; 1=Spline */
+    int flag;                           /*!< Leader creation flag, code 73, default 3 */
+    int hookline;                       /*!< Hook line direction flag, code 74, default 1 */
+    int hookflag;                       /*!< Hook line flag, code 75 */
+    double  textheight;                 /*!< Text annotation height, code 40 */
+    double  textwidth;                  /*!< Text annotation width, code 41 */
+    int vertnum;                        /*!< Number of vertices, code 76 */
+    int coloruse;                       /*!< Color to use if leader's DIMCLRD = BYBLOCK, code 77 */
+    std::string handle;                 /*!< Hard reference to associated annotation, code 340 */
+    DRW_Coord   extrusionPoint;         /*!< Normal vector, code 210, 220 & 230 */
+    DRW_Coord   horizdir;               /*!< "Horizontal" direction for leader, code 211, 221 & 231 */
+    DRW_Coord   offsetblock;            /*!< Offset of last leader vertex from block, code 212, 222 & 232 */
+    DRW_Coord   offsettext;             /*!< Offset of last leader vertex from annotation, code 213, 223 & 233 */
+
+    std::vector<DRW_Coord*> vertexlist; /*!< vertex points list, code 10, 20 & 30 */
+
+private:
+    DRW_Coord* vertexpoint;    /*!< current control point to add data */
+};
+
+// ! Class to handle viewport entity
+/*!
+ *  Class to handle viewport entity
+ *  @author Rallaz
+ */
+class DRW_Viewport : public DRW_Point
+{
+public:
+    DRW_Viewport()
+    {
+        eType   = DRW::VIEWPORT;
+        vpID    = vpstatus = 0;
+        pswidth     = 205;
+        psheight    = 156;
+        centerPX    = 128.5;
+        centerPY    = 97.5;
+    }
+
+    virtual void applyExtrusion() {}
+    void parseCode( int code, dxfReader* reader );
+
+public:
+    double  pswidth;            /*!< Width in paper space units, code 40 */
+    double  psheight;           /*!< Height in paper space units, code 41 */
+    int vpstatus;               /*!< Viewport status, code 68 */
+    int vpID;                   /*!< Viewport ID, code 69 */
+    double  centerPX;           /*!< view center piont X, code 12 */
+    double  centerPY;           /*!< view center piont Y, code 22 */
+};
+
+
+#endif
+
+// EOF