Pcbnew: First work to add a DXF file import to create board outlines. The DXF...

Pcbnew: First work to add a DXF file import to create board outlines. The DXF import is based on DXF lib import/export  from LibreCad.

CMakeLists.txt

@@ -360,6 +360,7 @@ add_subdirectory( cvpcb )
 add_subdirectory( eeschema )
 add_subdirectory( gerbview )
 add_subdirectory( kicad )
+add_subdirectory( lib_dxf )
 add_subdirectory( pcbnew )
 add_subdirectory( polygon )
 add_subdirectory( pagelayout_editor )

lib_dxf/CMakeLists.txt

+include_directories(intern)
+
+set(LIBDXF_SRCS
+    libdxfrw.cpp
+    intern/dxfwriter.cpp
+	intern/drw_textcodec.cpp
+	intern/dxfreader.cpp
+	drw_objects.cpp
+	drw_entities.cpp
+    )
+
+add_library(lib_dxf STATIC ${LIBDXF_SRCS})

lib_dxf/CREDITS.txt

+This library comes from the LibreCAD project, a 2D CAD program.
+see http://sourceforge.net/projects/libdxfrw/
+the latest sources are on:
+https://github.com/LibreCAD/LibreCAD/tree/master/libraries/libdxfrw/src

lib_dxf/drw_base.h

+/******************************************************************************
+**  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_BASE_H
+#define DRW_BASE_H
+
+#define DRW_VERSION "0.5.10"
+
+#include <string>
+#include <cmath>
+
+using std::string;
+
+#define UTF8STRING std::string
+#define DRW_UNUSED( x ) (void) x
+
+#if defined(WIN64) || defined(_WIN64) || defined(__WIN64__)
+#  define DRW_WIN
+#elif defined(WIN32) || defined(_WIN32) || defined(__WIN32__) || defined(__NT__)
+#    define DRW_WIN
+#elif defined(__MWERKS__) && defined(__INTEL__)
+#  define DRW_WIN
+#else
+#  define DRW_POSIX
+#endif
+
+#ifndef M_PI
+ #define M_PI 3.141592653589793238462643
+#endif
+#ifndef M_PI_2
+ #define M_PI_2 1.57079632679489661923
+#endif
+#define M_PIx2  6.283185307179586     // 2*PI
+#define ARAD    57.29577951308232
+
+namespace DRW {
+// ! Version numbers for the DXF Format.
+enum Version {
+    UNKNOWNV,       /*!< UNKNOWN VERSION. */
+    AC1006,         /*!< R10. */
+    AC1009,         /*!< R11 & R12. */
+    AC1012,         /*!< R13. */
+    AC1014,         /*!< R14. */
+    AC1015,         /*!< ACAD 2000. */
+    AC1018,         /*!< ACAD 2004. */
+    AC1021,         /*!< ACAD 2007. */
+    AC1024          /*!< ACAD 2010. */
+};
+
+enum error {
+    BAD_NONE,               /*!< No error. */
+    BAD_UNKNOWN,            /*!< UNKNOWN. */
+    BAD_OPEN,               /*!< error opening file. */
+    BAD_VERSION,            /*!< unsupported version. */
+    BAD_READ_FILE_HEADER,   /*!< error in file header read process. */
+    BAD_READ_HEADER,        /*!< error in header vars read process. */
+    BAD_READ_OFFSETS,       /*!< error in object map read process. */
+    BAD_READ_CLASSES,       /*!< error in classes read process. */
+    BAD_READ_TABLES,        /*!< error in tables read process. */
+    BAD_READ_ENTITIES       /*!< error in entities read process. */
+};
+}
+
+// ! Class to handle 3D coordinate point
+/*!
+ *  Class to handle 3D coordinate point
+ *  @author Rallaz
+ */
+class DRW_Coord
+{
+public:
+    DRW_Coord() { x = 0; y = 0; z = 0; }
+    DRW_Coord( double ix, double iy, double iz )
+    {
+        x = ix; y = iy; z = iz;
+    }
+
+    DRW_Coord operator =( const DRW_Coord& data )
+    {
+        x = data.x;  y = data.y;  z = data.z;
+        return *this;
+    }
+
+/*!< convert to unitary vector */
+    void unitize()
+    {
+        double dist;
+
+        dist = sqrt( x * x + y * y + z * z );
+
+        if( dist > 0.0 )
+        {
+            x   = x / dist;
+            y   = y / dist;
+            z   = z / dist;
+        }
+    }
+
+public:
+    double  x;
+    double  y;
+    double  z;
+};
+
+
+// ! Class to handle vertex
+/*!
+ *  Class to handle vertex for lwpolyline entity
+ *  @author Rallaz
+ */
+class DRW_Vertex2D
+{
+public:
+    DRW_Vertex2D()
+    {
+// eType = DRW::LWPOLYLINE;
+        stawidth = endwidth = bulge = 0;
+    }
+
+    DRW_Vertex2D( double sx, double sy, double b )
+    {
+        stawidth = endwidth = 0;
+        x       = sx;
+        y       = sy;
+        bulge   = b;
+    }
+
+public:
+    double  x;                  /*!< x coordinate, code 10 */
+    double  y;                  /*!< y coordinate, code 20 */
+    double  stawidth;           /*!< Start width, code 40 */
+    double  endwidth;           /*!< End width, code 41 */
+    double  bulge;              /*!< bulge, code 42 */
+};
+
+
+// ! Class to handle header vars
+/*!
+ *  Class to handle header vars
+ *  @author Rallaz
+ */
+class DRW_Variant
+{
+public:
+    enum TYPE {
+        STRING,
+        INTEGER,
+        DOUBLE,
+        COORD,
+        INVALID
+    };
+
+    DRW_Variant()
+    {
+        type = INVALID;
+    }
+
+    ~DRW_Variant()
+    {
+        if( type == COORD )
+            delete content.v;
+    }
+
+    enum TYPE type;
+
+    void addString( UTF8STRING s ) { setType( STRING ); data = s; content.s = &data; }
+    void addInt( int i ) { setType( INTEGER ); content.i = i; }
+    void addDouble( double d ) { setType( DOUBLE ); content.d = d; }
+    void addCoord( DRW_Coord* v ) { setType( COORD ); content.v = v; }
+    void setType( enum TYPE t )
+    {
+        if( type == COORD )
+            delete content.v;
+
+        type = t;
+    }
+
+    void setCoordX( double d ) { if( type == COORD ) content.v->x = d; }
+    void setCoordY( double d ) { if( type == COORD ) content.v->y = d; }
+    void setCoordZ( double d ) { if( type == COORD ) content.v->z = d; }
+private:
+    typedef union
+    {
+        UTF8STRING* s;
+        int         i;
+        double      d;
+        DRW_Coord*  v;
+    } DRW_VarContent;
+public:
+    DRW_VarContent  content;
+public:
+    int             code;
+// string version;
+// string codepage;
+private:
+// DRW_VarContent content;
+    string data;
+};
+
+
+// ! Class to convert between line width and integer
+/*!
+ *  Class to convert between line width and integer
+ *  verifing valid values, if value is not valid
+ *  returns widthDefault.
+ *  @author Rallaz
+ */
+class DRW_LW_Conv
+{
+public:
+    enum lineWidth {
+        width00 = 0,            /*!< 0.00mm (dxf 0)*/
+        width01 = 1,            /*!< 0.05mm (dxf 5)*/
+        width02 = 2,            /*!< 0.09mm (dxf 9)*/
+        width03 = 3,            /*!< 0.13mm (dxf 13)*/
+        width04 = 4,            /*!< 0.15mm (dxf 15)*/
+        width05 = 5,            /*!< 0.18mm (dxf 18)*/
+        width06 = 6,            /*!< 0.20mm (dxf 20)*/
+        width07 = 7,            /*!< 0.25mm (dxf 25)*/
+        width08 = 8,            /*!< 0.30mm (dxf 30)*/
+        width09 = 9,            /*!< 0.35mm (dxf 35)*/
+        width10 = 10,           /*!< 0.40mm (dxf 40)*/
+        width11 = 11,           /*!< 0.50mm (dxf 50)*/
+        width12 = 12,           /*!< 0.53mm (dxf 53)*/
+        width13 = 13,           /*!< 0.60mm (dxf 60)*/
+        width14 = 14,           /*!< 0.70mm (dxf 70)*/
+        width15 = 15,           /*!< 0.80mm (dxf 80)*/
+        width16 = 16,           /*!< 0.90mm (dxf 90)*/
+        width17 = 17,           /*!< 1.00mm (dxf 100)*/
+        width18 = 18,           /*!< 1.06mm (dxf 106)*/
+        width19 = 19,           /*!< 1.20mm (dxf 120)*/
+        width20 = 20,           /*!< 1.40mm (dxf 140)*/
+        width21 = 21,           /*!< 1.58mm (dxf 158)*/
+        width22 = 22,           /*!< 2.00mm (dxf 200)*/
+        width23 = 23,           /*!< 2.11mm (dxf 211)*/
+        widthByLayer    = 29,   /*!< by layer (dxf -1) */
+        widthByBlock    = 30,   /*!< by block (dxf -2) */
+        widthDefault    = 31    /*!< by default (dxf -3) */
+    };
+
+    static int lineWidth2dxfInt( enum lineWidth lw )
+    {
+        switch( lw )
+        {
+        case widthByLayer:
+            return -1;
+
+        case widthByBlock:
+            return -2;
+
+        case widthDefault:
+            return -3;
+
+        case width00:
+            return 0;
+
+        case width01:
+            return 5;
+
+        case width02:
+            return 9;
+
+        case width03:
+            return 13;
+
+        case width04:
+            return 15;
+
+        case width05:
+            return 18;
+
+        case width06:
+            return 20;
+
+        case width07:
+            return 25;
+
+        case width08:
+            return 30;
+
+        case width09:
+            return 35;
+
+        case width10:
+            return 40;
+
+        case width11:
+            return 50;
+
+        case width12:
+            return 53;
+
+        case width13:
+            return 60;
+
+        case width14:
+            return 70;
+
+        case width15:
+            return 80;
+
+        case width16:
+            return 90;
+
+        case width17:
+            return 100;
+
+        case width18:
+            return 106;
+
+        case width19:
+            return 120;
+
+        case width20:
+            return 140;
+
+        case width21:
+            return 158;
+
+        case width22:
+            return 200;
+
+        case width23:
+            return 211;
+
+        default:
+            return -3;
+        }
+
+        return static_cast<int> (lw);
+    }
+
+    static int lineWidth2dwgInt( enum lineWidth lw )
+    {
+        return static_cast<int> (lw);
+    }
+
+    static enum lineWidth dxfInt2lineWidth( int i )
+    {
+        if( i<0 )
+        {
+            if( i==-1 )
+                return widthByLayer;
+            else if( i==-2 )
+                return widthByBlock;
+            else if( i==-3 )
+                return widthDefault;
+        }
+        else if( i<3 )
+        {
+            return width00;
+        }
+        else if( i<7 )
+        {
+            return width01;
+        }
+        else if( i<11 )
+        {
+            return width02;
+        }
+        else if( i<14 )
+        {
+            return width03;
+        }
+        else if( i<16 )
+        {
+            return width04;
+        }
+        else if( i<19 )
+        {
+            return width05;
+        }
+        else if( i<22 )
+        {
+            return width06;
+        }
+        else if( i<27 )
+        {
+            return width07;
+        }
+        else if( i<32 )
+        {
+            return width08;
+        }
+        else if( i<37 )
+        {
+            return width09;
+        }
+        else if( i<45 )
+        {
+            return width10;
+        }
+        else if( i<52 )
+        {
+            return width11;
+        }
+        else if( i<57 )
+        {
+            return width12;
+        }
+        else if( i<65 )
+        {
+            return width13;
+        }
+        else if( i<75 )
+        {
+            return width14;
+        }
+        else if( i<85 )
+        {
+            return width15;
+        }
+        else if( i<95 )
+        {
+            return width16;
+        }
+        else if( i<103 )
+        {
+            return width17;
+        }
+        else if( i<112 )
+        {
+            return width18;
+        }
+        else if( i<130 )
+        {
+            return width19;
+        }
+        else if( i<149 )
+        {
+            return width20;
+        }
+        else if( i<180 )
+        {
+            return width21;
+        }
+        else if( i<205 )
+        {
+            return width22;
+        }
+        else
+        {
+            return width23;
+        }
+
+        // default by default
+        return widthDefault;
+    }
+
+    static enum lineWidth dwgInt2lineWidth( int i )
+    {
+        if( (i>-1 && i<24) || (i>28 && i<32) )
+        {
+            return static_cast<lineWidth> (i);
+        }
+
+        // default by default
+        return widthDefault;
+    }
+};
+
+#endif
+
+// EOF

lib_dxf/drw_entities.cpp

+/******************************************************************************
+**  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/>.    **
+******************************************************************************/
+
+#include <cstdlib>
+#include "drw_entities.h"
+#include "intern/dxfreader.h"
+
+
+// ! Calculate arbitary axis
+/*!
+ *   Calculate arbitary axis for apply extrusions
+ *  @author Rallaz
+ */
+void DRW_Entity::calculateAxis( DRW_Coord extPoint )
+{
+    if( fabs( extPoint.x ) < 0.015625 && fabs( extPoint.y ) < 0.015625 )
+    {
+        extAxisX.x  = extPoint.z;
+        extAxisX.y  = 0;
+        extAxisX.z  = -extPoint.x;
+    }
+    else
+    {
+        extAxisX.x  = -extPoint.y;
+        extAxisX.y  = extPoint.x;
+        extAxisX.z  = 0;
+    }
+
+    extAxisX.unitize();
+    extAxisY.x  = (extPoint.y * extAxisX.z) - (extAxisX.y * extPoint.z);
+    extAxisY.y  = (extPoint.z * extAxisX.x) - (extAxisX.z * extPoint.x);
+    extAxisY.z  = (extPoint.x * extAxisX.y) - (extAxisX.x * extPoint.y);
+    extAxisY.unitize();
+}
+
+
+// ! Extrude a point using arbitary axis
+/*!
+ *   apply extrusion in a point using arbitary axis (previous calculated)
+ *  @author Rallaz
+ */
+void DRW_Entity::extrudePoint( DRW_Coord extPoint, DRW_Coord* point )
+{
+    double px, py, pz;
+
+    px  = (extAxisX.x * point->x) + (extAxisY.x * point->y) + (extPoint.x * point->z);
+    py  = (extAxisX.y * point->x) + (extAxisY.y * point->y) + (extPoint.y * point->z);
+    pz  = (extAxisX.z * point->x) + (extAxisY.z * point->y) + (extPoint.z * point->z);
+
+    point->x    = px;
+    point->y    = py;
+    point->z    = pz;
+}
+
+
+void DRW_Entity::parseCode( int code, dxfReader* reader )
+{
+    switch( code )
+    {
+    case 5:
+        handle = reader->getHandleString();
+        break;
+
+    case 330:
+        handleBlock = reader->getHandleString();
+        break;
+
+    case 8:
+        layer = reader->getUtf8String();
+        break;
+
+    case 6:
+        lineType = reader->getUtf8String();
+        break;
+
+    case 62:
+        color = reader->getInt32();
+        break;
+
+    case 370:
+        lWeight = DRW_LW_Conv::dxfInt2lineWidth( reader->getInt32() );
+        break;
+
+    case 48:
+        ltypeScale = reader->getDouble();
+        break;
+
+    case 60:
+        visible = reader->getBool();
+        break;
+
+    case 420:
+        color24 = reader->getInt32();
+        break;
+
+    case 430:
+        colorName = reader->getString();
+        break;
+
+    case 67:
+        space = reader->getInt32();
+        break;
+
+    default:
+        break;
+    }
+}
+
+
+void DRW_Point::parseCode( int code, dxfReader* reader )
+{
+    switch( code )
+    {
+    case 10:
+        basePoint.x = reader->getDouble();
+        break;
+
+    case 20:
+        basePoint.y = reader->getDouble();
+        break;
+
+    case 30:
+        basePoint.z = reader->getDouble();
+        break;
+
+    case 39:
+        thickness = reader->getDouble();
+        break;
+
+    case 210:
+        haveExtrusion   = true;
+        extPoint.x      = reader->getDouble();
+        break;
+
+    case 220:
+        extPoint.y = reader->getDouble();
+        break;
+
+    case 230:
+        extPoint.z = reader->getDouble();
+        break;
+
+    default:
+        DRW_Entity::parseCode( code, reader );
+        break;
+    }
+}
+
+
+void DRW_Line::parseCode( int code, dxfReader* reader )
+{
+    switch( code )
+    {
+    case 11:
+        secPoint.x = reader->getDouble();
+        break;
+
+    case 21:
+        secPoint.y = reader->getDouble();
+        break;
+
+    case 31:
+        secPoint.z = reader->getDouble();
+        break;
+
+    default:
+        DRW_Point::parseCode( code, reader );
+        break;
+    }
+}
+
+
+void DRW_Circle::applyExtrusion()
+{
+    if( haveExtrusion )
+    {
+        calculateAxis( extPoint );
+        extrudePoint( extPoint, &basePoint );
+    }
+}
+
+
+void DRW_Circle::parseCode( int code, dxfReader* reader )
+{
+    switch( code )
+    {
+    case 40:
+        radious = reader->getDouble();
+        break;
+
+    default:
+        DRW_Point::parseCode( code, reader );
+        break;
+    }
+}
+
+
+void DRW_Arc::parseCode( int code, dxfReader* reader )
+{
+    switch( code )
+    {
+    case 50:
+        staangle = reader->getDouble() / ARAD;
+        break;
+
+    case 51:
+        endangle = reader->getDouble() / ARAD;
+        break;
+
+    default:
+        DRW_Circle::parseCode( code, reader );
+        break;
+    }
+}
+
+
+void DRW_Ellipse::parseCode( int code, dxfReader* reader )
+{
+    switch( code )
+    {
+    case 40:
+        ratio = reader->getDouble();
+        break;
+
+    case 41:
+        staparam = reader->getDouble();
+        break;
+
+    case 42:
+        endparam = reader->getDouble();
+        break;
+
+    default:
+        DRW_Line::parseCode( code, reader );
+        break;
+    }
+}
+
+
+void DRW_Ellipse::applyExtrusion()
+{
+    if( haveExtrusion )
+    {
+        calculateAxis( extPoint );
+        extrudePoint( extPoint, &secPoint );
+        double intialparam = staparam;
+
+        if( extPoint.z < 0. )
+        {
+            staparam    = M_PIx2 - endparam;
+            endparam    = M_PIx2 - intialparam;
+        }
+    }
+}
+
+
+// if ratio > 1 minor axis are greather than major axis, correct it
+void DRW_Ellipse::correctAxis()
+{
+    bool complete = false;
+
+    if( staparam == endparam )
+    {
+        staparam    = 0.0;
+        endparam    = M_PIx2; // 2*M_PI;
+        complete    = true;
+    }
+
+    if( ratio > 1 )
+    {
+        if( fabs( endparam - staparam - M_PIx2 ) < 1.0e-10 )
+            complete = true;
+
+        double incX = secPoint.x;
+        secPoint.x  = -(secPoint.y * ratio);
+        secPoint.y  = incX * ratio;
+        ratio = 1 / ratio;
+
+        if( !complete )
+        {
+            if( staparam < M_PI_2 )
+                staparam += M_PI * 2;
+
+            if( endparam < M_PI_2 )
+                endparam += M_PI * 2;
+
+            endparam    -= M_PI_2;
+            staparam    -= M_PI_2;
+        }
+    }
+}
+
+
+// parts are the number of vertex to split polyline, default 128
+void DRW_Ellipse::toPolyline( DRW_Polyline* pol, int parts )
+{
+    double  radMajor, radMinor, cosRot, sinRot, incAngle, curAngle;
+    double  cosCurr, sinCurr;
+
+    radMajor    = sqrt( secPoint.x * secPoint.x + secPoint.y * secPoint.y );
+    radMinor    = radMajor * ratio;
+    // calculate sin & cos of included angle
+    incAngle    = atan2( secPoint.y, secPoint.x );
+    cosRot      = cos( incAngle );
+    sinRot      = sin( incAngle );
+    incAngle    = M_PIx2 / parts;
+    curAngle    = staparam;
+    int i = curAngle / incAngle;
+
+    do {
+        if( curAngle > endparam )
+        {
+            curAngle = endparam;
+            i = parts + 2;
+        }
+
+        cosCurr = cos( curAngle );
+        sinCurr = sin( curAngle );
+        double  x   = basePoint.x + (cosCurr * cosRot * radMajor) - (sinCurr * sinRot * radMinor);
+        double  y   = basePoint.y + (cosCurr * sinRot * radMajor) + (sinCurr * cosRot * radMinor);
+        pol->addVertex( DRW_Vertex( x, y, 0.0, 0.0 ) );
+        curAngle = (++i) * incAngle;
+    } while( i<parts );
+
+    if( fabs( endparam - staparam - M_PIx2 ) < 1.0e-10 )
+    {
+        pol->flags = 1;
+    }
+
+    pol->layer      = this->layer;
+    pol->lineType   = this->lineType;
+    pol->color      = this->color;
+    pol->lWeight    = this->lWeight;
+    pol->extPoint   = this->extPoint;
+}
+
+
+void DRW_Trace::applyExtrusion()
+{
+    if( haveExtrusion )
+    {
+        calculateAxis( extPoint );
+        extrudePoint( extPoint, &basePoint );
+        extrudePoint( extPoint, &secPoint );
+        extrudePoint( extPoint, &thirdPoint );
+        extrudePoint( extPoint, &fourPoint );
+    }
+}
+
+
+void DRW_Trace::parseCode( int code, dxfReader* reader )
+{
+    switch( code )
+    {
+    case 12:
+        thirdPoint.x = reader->getDouble();
+        break;
+
+    case 22:
+        thirdPoint.y = reader->getDouble();
+        break;
+
+    case 32:
+        thirdPoint.z = reader->getDouble();
+        break;
+
+    case 13:
+        fourPoint.x = reader->getDouble();
+        break;
+
+    case 23:
+        fourPoint.y = reader->getDouble();
+        break;
+
+    case 33:
+        fourPoint.z = reader->getDouble();
+        break;
+
+    default:
+        DRW_Line::parseCode( code, reader );
+        break;
+    }
+}
+
+
+void DRW_Solid::parseCode( int code, dxfReader* reader )
+{
+    DRW_Trace::parseCode( code, reader );
+}
+
+
+void DRW_3Dface::parseCode( int code, dxfReader* reader )
+{
+    switch( code )
+    {
+    case 70:
+        invisibleflag = reader->getInt32();
+        break;
+
+    default:
+        DRW_Trace::parseCode( code, reader );
+        break;
+    }
+}
+
+
+void DRW_Block::parseCode( int code, dxfReader* reader )
+{
+    switch( code )
+    {
+    case 2:
+        name = reader->getUtf8String();
+        break;
+
+    case 70:
+        flags = reader->getInt32();
+        break;
+
+    default:
+        DRW_Point::parseCode( code, reader );
+        break;
+    }
+}
+
+
+void DRW_Insert::parseCode( int code, dxfReader* reader )
+{
+    switch( code )
+    {
+    case 2:
+        name = reader->getUtf8String();
+        break;
+
+    case 41:
+        xscale = reader->getDouble();
+        break;
+
+    case 42:
+        yscale = reader->getDouble();
+        break;
+
+    case 43:
+        zscale = reader->getDouble();
+        break;
+
+    case 50:
+        angle = reader->getDouble();
+        break;
+
+    case 70:
+        colcount = reader->getInt32();
+        break;
+
+    case 71:
+        rowcount = reader->getInt32();
+        break;
+
+    case 44:
+        colspace = reader->getDouble();
+        break;
+
+    case 45:
+        rowspace = reader->getDouble();
+        break;
+
+    default:
+        DRW_Point::parseCode( code, reader );
+        break;
+    }
+}
+
+
+void DRW_LWPolyline::applyExtrusion()
+{
+    if( haveExtrusion )
+    {
+        calculateAxis( extPoint );
+
+        for( unsigned int i = 0; i<vertlist.size(); i++ )
+        {
+            DRW_Vertex2D*   vert = vertlist.at( i );
+            DRW_Coord       v( vert->x, vert->y, elevation );
+            extrudePoint( extPoint, &v );
+            vert->x = v.x;
+            vert->y = v.y;
+        }
+    }
+}
+
+
+void DRW_LWPolyline::parseCode( int code, dxfReader* reader )
+{
+    switch( code )
+    {
+    case 10:
+        {
+            vertex = new DRW_Vertex2D();
+            vertlist.push_back( vertex );
+            vertex->x = reader->getDouble();
+            break;
+        }
+
+    case 20:
+
+        if( vertex != NULL )
+            vertex->y = reader->getDouble();
+
+        break;
+
+    case 40:
+
+        if( vertex != NULL )
+            vertex->stawidth = reader->getDouble();
+
+        break;
+
+    case 41:
+
+        if( vertex != NULL )
+            vertex->endwidth = reader->getDouble();
+
+        break;
+
+    case 42:
+
+        if( vertex != NULL )
+            vertex->bulge = reader->getDouble();
+
+        break;
+
+    case 38:
+        elevation = reader->getDouble();
+        break;
+
+    case 39:
+        thickness = reader->getDouble();
+        break;
+
+    case 43:
+        width = reader->getDouble();
+        break;
+
+    case 70:
+        flags = reader->getInt32();
+        break;
+
+    case 90:
+        vertexnum = reader->getInt32();
+        vertlist.reserve( vertexnum );
+        break;
+
+    case 210:
+        haveExtrusion   = true;
+        extPoint.x      = reader->getDouble();
+        break;
+
+    case 220:
+        extPoint.y = reader->getDouble();
+        break;
+
+    case 230:
+        extPoint.z = reader->getDouble();
+        break;
+
+    default:
+        DRW_Entity::parseCode( code, reader );
+        break;
+    }
+}
+
+
+void DRW_Text::parseCode( int code, dxfReader* reader )
+{
+    switch( code )
+    {
+    case 40:
+        height = reader->getDouble();
+        break;
+
+    case 41:
+        widthscale = reader->getDouble();
+        break;
+
+    case 50:
+        angle = reader->getDouble();
+        break;
+
+    case 51:
+        oblique = reader->getDouble();
+        break;
+
+    case 71:
+        textgen = reader->getInt32();
+        break;
+
+    case 72:
+        alignH = (HAlign) reader->getInt32();
+        break;
+
+    case 73:
+        alignV = (VAlign) reader->getInt32();
+        break;
+
+    case 1:
+        text = reader->getUtf8String();
+        break;
+
+    case 7:
+        style = reader->getUtf8String();
+        break;
+
+    default:
+        DRW_Line::parseCode( code, reader );
+        break;
+    }
+}
+
+
+void DRW_MText::parseCode( int code, dxfReader* reader )
+{
+    switch( code )
+    {
+    case 1:
+        text    += reader->getString();
+        text    = reader->toUtf8String( text );
+        break;
+
+    case 11:
+        haveXAxis = true;
+        DRW_Text::parseCode( code, reader );
+        break;
+
+    case 3:
+        text += reader->getString();
+        break;
+
+    case 44:
+        interlin = reader->getDouble();
+        break;
+
+    default:
+        DRW_Text::parseCode( code, reader );
+        break;
+    }
+}
+
+
+void DRW_MText::updateAngle()
+{
+    if( haveXAxis )
+    {
+        angle = atan2( secPoint.y, secPoint.x ) * 180 / M_PI;
+    }
+}
+
+
+void DRW_Polyline::parseCode( int code, dxfReader* reader )
+{
+    switch( code )
+    {
+    case 70:
+        flags = reader->getInt32();
+        break;
+
+    case 40:
+        defstawidth = reader->getDouble();
+        break;
+
+    case 41:
+        defendwidth = reader->getDouble();
+        break;
+
+    case 71:
+        vertexcount = reader->getInt32();
+        break;
+
+    case 72:
+        facecount = reader->getInt32();
+        break;
+
+    case 73:
+        smoothM = reader->getInt32();
+        break;
+
+    case 74:
+        smoothN = reader->getInt32();
+        break;
+
+    case 75:
+        curvetype = reader->getInt32();
+        break;
+
+    default:
+        DRW_Point::parseCode( code, reader );
+        break;
+    }
+}
+
+
+void DRW_Vertex::parseCode( int code, dxfReader* reader )
+{
+    switch( code )
+    {
+    case 70:
+        flags = reader->getInt32();
+        break;
+
+    case 40:
+        stawidth = reader->getDouble();
+        break;
+
+    case 41:
+        endwidth = reader->getDouble();
+        break;
+
+    case 42:
+        bulge = reader->getDouble();
+        break;
+
+    case 50:
+        tgdir = reader->getDouble();
+        break;
+
+    case 71:
+        vindex1 = reader->getInt32();
+        break;
+
+    case 72:
+        vindex2 = reader->getInt32();
+        break;
+
+    case 73:
+        vindex3 = reader->getInt32();
+        break;
+
+    case 74:
+        vindex4 = reader->getInt32();
+        break;
+
+    case 91:
+        identifier = reader->getInt32();
+        break;
+
+    default:
+        DRW_Point::parseCode( code, reader );
+        break;
+    }
+}
+
+
+void DRW_Hatch::parseCode( int code, dxfReader* reader )
+{
+    switch( code )
+    {
+    case 2:
+        name = reader->getUtf8String();
+        break;
+
+    case 70:
+        solid = reader->getInt32();
+        break;
+
+    case 71:
+        associative = reader->getInt32();
+        break;
+
+    case 72:        /*edge type*/
+
+        if( ispol ) // if is polyline is a as_bulge flag
+        {
+            break;
+        }
+        else if( reader->getInt32() == 1 )   // line
+        {
+            addLine();
+        }
+        else if( reader->getInt32() == 2 )   // arc
+        {
+            addArc();
+        }
+        else if( reader->getInt32() == 3 )   // elliptic arc
+        {
+            addEllipse();
+        }
+        else if( reader->getInt32() == 4 )   // spline
+        {
+            addSpline();
+        }
+
+        break;
+
+    case 10:
+
+        if( pt )
+            pt->basePoint.x = reader->getDouble();
+        else if( pline )
+        {
+            plvert      = pline->addVertex();
+            plvert->x   = reader->getDouble();
+        }
+
+        break;
+
+    case 20:
+
+        if( pt )
+            pt->basePoint.y = reader->getDouble();
+        else if( plvert )
+            plvert->y = reader->getDouble();
+
+        break;
+
+    case 11:
+
+        if( line )
+            line->secPoint.x = reader->getDouble();
+        else if( ellipse )
+            ellipse->secPoint.x = reader->getDouble();
+
+        break;
+
+    case 21:
+
+        if( line )
+            line->secPoint.y = reader->getDouble();
+        else if( ellipse )
+            ellipse->secPoint.y = reader->getDouble();
+
+        break;
+
+    case 40:
+
+        if( arc )
+            arc->radious = reader->getDouble();
+        else if( ellipse )
+            ellipse->ratio = reader->getDouble();
+
+        break;
+
+    case 41:
+        scale = reader->getDouble();
+        break;
+
+    case 42:
+
+        if( plvert )
+            plvert->bulge = reader->getDouble();
+
+        break;
+
+    case 50:
+
+        if( arc )
+            arc->staangle = reader->getDouble() / ARAD;
+        else if( ellipse )
+            ellipse->staparam = reader->getDouble() / ARAD;
+
+        break;
+
+    case 51:
+
+        if( arc )
+            arc->endangle = reader->getDouble() / ARAD;
+        else if( ellipse )
+            ellipse->endparam = reader->getDouble() / ARAD;
+
+        break;
+
+    case 52:
+        angle = reader->getDouble();
+        break;
+
+    case 73:
+
+        if( arc )
+            arc->isccw = reader->getInt32();
+        else if( pline )
+            pline->flags = reader->getInt32();
+
+        break;
+
+    case 75:
+        hstyle = reader->getInt32();
+        break;
+
+    case 76:
+        hpattern = reader->getInt32();
+        break;
+
+    case 77:
+        doubleflag = reader->getInt32();
+        break;
+
+    case 78:
+        deflines = reader->getInt32();
+        break;
+
+    case 91:
+        loopsnum = reader->getInt32();
+        looplist.reserve( loopsnum );
+        break;
+
+    case 92:
+        loop = new DRW_HatchLoop( reader->getInt32() );
+        looplist.push_back( loop );
+
+        if( reader->getInt32() & 2 )
+        {
+            ispol = true;
+            clearEntities();
+            pline = new DRW_LWPolyline;
+            loop->objlist.push_back( pline );
+        }
+        else
+            ispol = false;
+
+        break;
+
+    case 93:
+
+        if( pline )
+            pline->vertexnum = reader->getInt32();
+        else
+            loop->numedges = reader->getInt32(); // aqui reserve
+
+        break;
+
+    case 98:    // seed points ??
+        clearEntities();
+        break;
+
+    default:
+        DRW_Point::parseCode( code, reader );
+        break;
+    }
+}
+
+
+void DRW_Spline::parseCode( int code, dxfReader* reader )
+{
+    switch( code )
+    {
+    case 210:
+        ex = reader->getDouble();
+        break;
+
+    case 220:
+        ey = reader->getDouble();
+        break;
+
+    case 230:
+        ez = reader->getDouble();
+        break;
+
+    case 12:
+        tgsx = reader->getDouble();
+        break;
+
+    case 22:
+        tgsy = reader->getDouble();
+        break;
+
+    case 32:
+        tgsz = reader->getDouble();
+        break;
+
+    case 13:
+        tgex = reader->getDouble();
+        break;
+
+    case 23:
+        tgey = reader->getDouble();
+        break;
+
+    case 33:
+        tgez = reader->getDouble();
+        break;
+
+    case 70:
+        flags = reader->getInt32();
+        break;
+
+    case 71:
+        degree = reader->getInt32();
+        break;
+
+    case 72:
+        nknots = reader->getInt32();
+        break;
+
+    case 73:
+        ncontrol = reader->getInt32();
+        break;
+
+    case 74:
+        nfit = reader->getInt32();
+        break;
+
+    case 42:
+        tolknot = reader->getDouble();
+        break;
+
+    case 43:
+        tolcontrol = reader->getDouble();
+        break;
+
+    case 44:
+        tolfit = reader->getDouble();
+        break;
+
+    case 10:
+        {
+            controlpoint = new DRW_Coord();
+            controllist.push_back( controlpoint );
+            controlpoint->x = reader->getDouble();
+            break;
+        }
+
+    case 20:
+
+        if( controlpoint != NULL )
+            controlpoint->y = reader->getDouble();
+
+        break;
+
+    case 30:
+
+        if( controlpoint != NULL )
+            controlpoint->z = reader->getDouble();
+
+        break;
+
+    case 11:
+        {
+            fitpoint = new DRW_Coord();
+            fitlist.push_back( fitpoint );
+            fitpoint->x = reader->getDouble();
+            break;
+        }
+
+    case 21:
+
+        if( fitpoint != NULL )
+            fitpoint->y = reader->getDouble();
+
+        break;
+
+    case 31:
+
+        if( fitpoint != NULL )
+            fitpoint->z = reader->getDouble();
+
+        break;
+
+    case 40:
+        knotslist.push_back( reader->getDouble() );
+        break;
+
+// case 41:
+// break;
+    default:
+        DRW_Entity::parseCode( code, reader );
+        break;
+    }
+}
+
+
+void DRW_Image::parseCode( int code, dxfReader* reader )
+{
+    switch( code )
+    {
+    case 12:
+        vx = reader->getDouble();
+        break;
+
+    case 22:
+        vy = reader->getDouble();
+        break;
+
+    case 32:
+        vz = reader->getDouble();
+        break;
+
+    case 13:
+        sizeu = reader->getDouble();
+        break;
+
+    case 23:
+        sizev = reader->getDouble();
+        break;
+
+    case 340:
+        ref = reader->getString();
+        break;
+
+    case 280:
+        clip = reader->getInt32();
+        break;
+
+    case 281:
+        brightness = reader->getInt32();
+        break;
+
+    case 282:
+        contrast = reader->getInt32();
+        break;
+
+    case 283:
+        fade = reader->getInt32();
+        break;
+
+    default:
+        DRW_Line::parseCode( code, reader );
+        break;
+    }
+}
+
+
+void DRW_Dimension::parseCode( int code, dxfReader* reader )
+{
+    switch( code )
+    {
+    case 1:
+        text = reader->getUtf8String();
+        break;
+
+    case 2:
+        name = reader->getString();
+        break;
+
+    case 3:
+        style = reader->getUtf8String();
+        break;
+
+    case 70:
+        type = reader->getInt32();
+        break;
+
+    case 71:
+        align = reader->getInt32();
+        break;
+
+    case 72:
+        linesty = reader->getInt32();
+        break;
+
+    case 10:
+        defPoint.x = reader->getDouble();
+        break;
+
+    case 20:
+        defPoint.y = reader->getDouble();
+        break;
+
+    case 30:
+        defPoint.z = reader->getDouble();
+        break;
+
+    case 11:
+        textPoint.x = reader->getDouble();
+        break;
+
+    case 21:
+        textPoint.y = reader->getDouble();
+        break;
+
+    case 31:
+        textPoint.z = reader->getDouble();
+        break;
+
+    case 12:
+        clonePoint.x = reader->getDouble();
+        break;
+
+    case 22:
+        clonePoint.y = reader->getDouble();
+        break;
+
+    case 32:
+        clonePoint.z = reader->getDouble();
+        break;
+
+    case 13:
+        def1.x = reader->getDouble();
+        break;
+
+    case 23:
+        def1.y = reader->getDouble();
+        break;
+
+    case 33:
+        def1.z = reader->getDouble();
+        break;
+
+    case 14:
+        def2.x = reader->getDouble();
+        break;
+
+    case 24:
+        def2.y = reader->getDouble();
+        break;
+
+    case 34:
+        def2.z = reader->getDouble();
+        break;
+
+    case 15:
+        circlePoint.x = reader->getDouble();
+        break;
+
+    case 25:
+        circlePoint.y = reader->getDouble();
+        break;
+
+    case 35:
+        circlePoint.z = reader->getDouble();
+        break;
+
+    case 16:
+        arcPoint.x = reader->getDouble();
+        break;
+
+    case 26:
+        arcPoint.y = reader->getDouble();
+        break;
+
+    case 36:
+        arcPoint.z = reader->getDouble();
+        break;
+
+    case 41:
+        linefactor = reader->getDouble();
+        break;
+
+    case 53:
+        rot = reader->getDouble();
+        break;
+
+    case 50:
+        angle = reader->getDouble();
+        break;
+
+    case 52:
+        oblique = reader->getDouble();
+        break;
+
+    case 40:
+        length = reader->getDouble();
+        break;
+
+/*    case 51:
+ *       hdir = reader->getDouble();
+ *       break;*/
+    default:
+        DRW_Entity::parseCode( code, reader );
+        break;
+    }
+}
+
+
+void DRW_Leader::parseCode( int code, dxfReader* reader )
+{
+    switch( code )
+    {
+    case 3:
+        style = reader->getUtf8String();
+        break;
+
+    case 71:
+        arrow = reader->getInt32();
+        break;
+
+    case 72:
+        leadertype = reader->getInt32();
+        break;
+
+    case 73:
+        flag = reader->getInt32();
+        break;
+
+    case 74:
+        hookline = reader->getInt32();
+        break;
+
+    case 75:
+        hookflag = reader->getInt32();
+        break;
+
+    case 76:
+        vertnum = reader->getInt32();
+        break;
+
+    case 77:
+        coloruse = reader->getInt32();
+        break;
+
+    case 40:
+        textheight = reader->getDouble();
+        break;
+
+    case 41:
+        textwidth = reader->getDouble();
+        break;
+
+    case 10:
+        {
+            vertexpoint = new DRW_Coord();
+            vertexlist.push_back( vertexpoint );
+            vertexpoint->x = reader->getDouble();
+            break;
+        }
+
+    case 20:
+
+        if( vertexpoint != NULL )
+            vertexpoint->y = reader->getDouble();
+
+        break;
+
+    case 30:
+
+        if( vertexpoint != NULL )
+            vertexpoint->z = reader->getDouble();
+
+        break;
+
+    case 340:
+        handle = reader->getString();
+        break;
+
+    case 210:
+        extrusionPoint.x = reader->getDouble();
+        break;
+
+    case 220:
+        extrusionPoint.y = reader->getDouble();
+        break;
+
+    case 230:
+        extrusionPoint.z = reader->getDouble();
+        break;
+
+    case 211:
+        horizdir.x = reader->getDouble();
+        break;
+
+    case 221:
+        horizdir.y = reader->getDouble();
+        break;
+
+    case 231:
+        horizdir.z = reader->getDouble();
+        break;
+
+    case 212:
+        offsetblock.x = reader->getDouble();
+        break;
+
+    case 222:
+        offsetblock.y = reader->getDouble();
+        break;
+
+    case 232:
+        offsetblock.z = reader->getDouble();
+        break;
+
+    case 213:
+        offsettext.x = reader->getDouble();
+        break;
+
+    case 223:
+        offsettext.y = reader->getDouble();
+        break;
+
+    case 233:
+        offsettext.z = reader->getDouble();
+        break;
+
+    default:
+        DRW_Entity::parseCode( code, reader );
+        break;
+    }
+}
+
+
+void DRW_Viewport::parseCode( int code, dxfReader* reader )
+{
+    switch( code )
+    {
+    case 40:
+        pswidth = reader->getDouble();
+        break;
+
+    case 41:
+        psheight = reader->getDouble();
+        break;
+
+    case 68:
+        vpstatus = reader->getInt32();
+        break;
+
+    case 69:
+        vpID = reader->getInt32();
+        break;
+
+    case 12:
+        {
+            centerPX = reader->getDouble();
+            break;
+        }
+
+    case 22:
+        centerPY = reader->getDouble();
+        break;
+
+    default:
+        DRW_Point::parseCode( code, reader );
+        break;
+    }
+}

lib_dxf/drw_entities.h

+/******************************************************************************
+**  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;
+
+using std::string;
+
+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
+    }
+
+    virtual ~DRW_Entity() {}
+
+    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;
+    }
+
+    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 */
+    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*/
+private:
+    DRW_Coord                   extAxisX;
+    DRW_Coord                   extAxisY;
+};
+
+
+// ! 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;
+    }
+
+    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;
+    }
+
+    virtual void applyExtrusion() { DRW_Circle::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;
+    }
+
+    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;
+    }
+
+    ~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;
+    }
+
+    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;
+    }
+
+    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;
+    }
+
+    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;
+    }
+
+    ~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();
+    }
+
+    ~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;
+    }
+
+    void parseCode( int code, dxfReader* reader );
+
+public:
+    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;
+    }
+
+    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; }
+    string getStyle() const { return style; }               /*!< Dimension style, code 3 */
+    void setStyle( const 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; }
+    string getText() const { return text; }                 /*!< Dimension text explicitly entered by the user, code 1 */
+    void setText( const 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; }
+    string getName() { return name; }                           /*!< Name of the block that contains the entities, code 2 */
+    void setName( const 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:
+    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;
+    }
+
+    ~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 */
+    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;
+        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

lib_dxf/drw_interface.h

+/******************************************************************************
+**  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_INTERFACE_H
+#define DRW_INTERFACE_H
+
+#include <string.h>
+
+#include "drw_entities.h"
+#include "drw_objects.h"
+// #include "dl_extrusion.h"
+
+/**
+ * Abstract class (interface) for comunicate dxfReader with the application.
+ * Inherit your class which takes care of the entities in the
+ * processed DXF file from this interface.
+ *
+ * @author Rallaz
+ */
+class DRW_Interface
+{
+public:
+    DRW_Interface()
+    {
+// extrusion = new DL_Extrusion;
+    }
+
+    virtual ~DRW_Interface()
+    {
+// delete extrusion;
+    }
+
+    /** Called when header is parsed.  */
+    virtual void    addHeader( const DRW_Header* data ) = 0;
+
+    /** Called for every line Type.  */
+    virtual void    addLType( const DRW_LType& data ) = 0;
+
+    /** Called for every layer. */
+    virtual void    addLayer( const DRW_Layer& data ) = 0;
+
+    /** Called for every dim style. */
+    virtual void    addDimStyle( const DRW_Dimstyle& data ) = 0;
+
+    /** Called for every VPORT table. */
+    virtual void    addVport( const DRW_Vport& data ) = 0;
+
+    /** Called for every text style. */
+    virtual void    addTextStyle( const DRW_Textstyle& data ) = 0;
+
+    /**
+     * Called for every block. Note: all entities added after this
+     * command go into this block until endBlock() is called.
+     *
+     * @see endBlock()
+     */
+    virtual void    addBlock( const DRW_Block& data ) = 0;
+
+    /**
+     * In DWG called when the following entities corresponding to a
+     * block different from the current. Note: all entities added after this
+     * command go into this block until setBlock() is called already.
+     *
+     * int handle are the value of DRW_Block::handleBlock added with addBlock()
+     */
+    virtual void    setBlock( const int handle ) = 0;
+
+    /** Called to end the current block */
+    virtual void    endBlock() = 0;
+
+    /** Called for every point */
+    virtual void    addPoint( const DRW_Point& data ) = 0;
+
+    /** Called for every line */
+    virtual void    addLine( const DRW_Line& data ) = 0;
+
+    /** Called for every ray */
+    virtual void    addRay( const DRW_Ray& data ) = 0;
+
+    /** Called for every xline */
+    virtual void    addXline( const DRW_Xline& data ) = 0;
+
+    /** Called for every arc */
+    virtual void    addArc( const DRW_Arc& data ) = 0;
+
+    /** Called for every circle */
+    virtual void    addCircle( const DRW_Circle& data ) = 0;
+
+    /** Called for every ellipse */
+    virtual void    addEllipse( const DRW_Ellipse& data ) = 0;
+
+    /** Called for every lwpolyline */
+    virtual void    addLWPolyline( const DRW_LWPolyline& data ) = 0;
+
+    /** Called for every polyline start */
+    virtual void    addPolyline( const DRW_Polyline& data ) = 0;
+
+    /** Called for every spline */
+    virtual void    addSpline( const DRW_Spline* data ) = 0;
+
+    /** Called for every spline knot value */
+    virtual void    addKnot( const DRW_Entity& data ) = 0;
+
+    /** Called for every insert. */
+    virtual void    addInsert( const DRW_Insert& data ) = 0;
+
+    /** Called for every trace start */
+    virtual void    addTrace( const DRW_Trace& data ) = 0;
+
+    /** Called for every 3dface start */
+    virtual void    add3dFace( const DRW_3Dface& data ) = 0;
+
+    /** Called for every solid start */
+    virtual void    addSolid( const DRW_Solid& data ) = 0;
+
+
+    /** Called for every Multi Text entity. */
+    virtual void    addMText( const DRW_MText& data ) = 0;
+
+    /** Called for every Text entity. */
+    virtual void    addText( const DRW_Text& data ) = 0;
+
+    /**
+     * Called for every aligned dimension entity.
+     */
+    virtual void    addDimAlign( const DRW_DimAligned* data ) = 0;
+
+    /**
+     * Called for every linear or rotated dimension entity.
+     */
+    virtual void    addDimLinear( const DRW_DimLinear* data ) = 0;
+
+    /**
+     * Called for every radial dimension entity.
+     */
+    virtual void    addDimRadial( const DRW_DimRadial* data ) = 0;
+
+    /**
+     * Called for every diametric dimension entity.
+     */
+    virtual void    addDimDiametric( const DRW_DimDiametric* data ) = 0;
+
+    /**
+     * Called for every angular dimension (2 lines version) entity.
+     */
+    virtual void    addDimAngular( const DRW_DimAngular* data ) = 0;
+
+    /**
+     * Called for every angular dimension (3 points version) entity.
+     */
+    virtual void    addDimAngular3P( const DRW_DimAngular3p* data ) = 0;
+
+    /**
+     * Called for every ordinate dimension entity.
+     */
+    virtual void    addDimOrdinate( const DRW_DimOrdinate* data ) = 0;
+
+    /**
+     * Called for every leader start.
+     */
+    virtual void    addLeader( const DRW_Leader* data ) = 0;
+
+    /**
+     * Called for every hatch entity.
+     */
+    virtual void    addHatch( const DRW_Hatch* data ) = 0;
+
+    /**
+     * Called for every viewport entity.
+     */
+    virtual void    addViewport( const DRW_Viewport& data ) = 0;
+
+    /**
+     * Called for every image entity.
+     */
+    virtual void    addImage( const DRW_Image* data ) = 0;
+
+    /**
+     * Called for every image definition.
+     */
+    virtual void    linkImage( const DRW_ImageDef* data ) = 0;
+
+    /**
+     * Called for every comment in the DXF file (code 999).
+     */
+    virtual void    addComment( const char* comment ) = 0;
+
+    /** Sets the current attributes for entities. */
+/*    void setExtrusion(double dx, double dy, double dz, double elevation) {
+ *       extrusion->setDirection(dx, dy, dz);
+ *       extrusion->setElevation(elevation);
+ *   }*/
+
+    /** @return the current attributes used for new entities. */
+// DL_Extrusion* getExtrusion() {
+// return extrusion;
+// }
+
+    virtual void    writeHeader( DRW_Header& data ) = 0;
+    virtual void    writeBlocks() = 0;
+    virtual void    writeBlockRecords() = 0;
+    virtual void    writeEntities()     = 0;
+    virtual void    writeLTypes()       = 0;
+    virtual void    writeLayers()       = 0;
+    virtual void    writeTextstyles()   = 0;
+    virtual void    writeVports()       = 0;
+    virtual void    writeDimstyles()    = 0;
+
+protected:
+// DL_Attributes attributes;
+// DL_Extrusion *extrusion;
+};
+
+#endif

lib_dxf/drw_objects.cpp

+/******************************************************************************
+**  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/>.    **
+******************************************************************************/
+
+#include <iostream>
+#include <math.h>
+#include "drw_objects.h"
+#include "intern/dxfreader.h"
+#include "intern/dxfwriter.h"
+
+// ! Base class for tables entries
+/*!
+ *  Base class for tables entries
+ *  @author Rallaz
+ */
+void DRW_TableEntry::parseCode( int code, dxfReader* reader )
+{
+    switch( code )
+    {
+    case 5:
+        handle = reader->getHandleString();
+        break;
+
+    case 330:
+        handleBlock = reader->getHandleString();
+        break;
+
+    case 2:
+        name = reader->getUtf8String();
+        break;
+
+    case 70:
+        flags = reader->getInt32();
+        break;
+
+    default:
+        break;
+    }
+}
+
+
+// ! Class to handle dimstyle entries
+/*!
+ *  Class to handle ldim style symbol table entries
+ *  @author Rallaz
+ */
+void DRW_Dimstyle::parseCode( int code, dxfReader* reader )
+{
+    switch( code )
+    {
+    case 105:
+        handle = reader->getHandleString();
+        break;
+
+    case 3:
+        dimpost = reader->getUtf8String();
+        break;
+
+    case 4:
+        dimapost = reader->getUtf8String();
+        break;
+
+    case 5:
+        dimblk = reader->getUtf8String();
+        break;
+
+    case 6:
+        dimblk1 = reader->getUtf8String();
+        break;
+
+    case 7:
+        dimblk2 = reader->getUtf8String();
+        break;
+
+    case 40:
+        dimscale = reader->getDouble();
+        break;
+
+    case 41:
+        dimasz = reader->getDouble();
+        break;
+
+    case 42:
+        dimexo = reader->getDouble();
+        break;
+
+    case 43:
+        dimdli = reader->getDouble();
+        break;
+
+    case 44:
+        dimexe = reader->getDouble();
+        break;
+
+    case 45:
+        dimrnd = reader->getDouble();
+        break;
+
+    case 46:
+        dimdle = reader->getDouble();
+        break;
+
+    case 47:
+        dimtp = reader->getDouble();
+        break;
+
+    case 48:
+        dimtm = reader->getDouble();
+        break;
+
+    case 140:
+        dimtxt = reader->getDouble();
+        break;
+
+    case 141:
+        dimcen = reader->getDouble();
+        break;
+
+    case 142:
+        dimtsz = reader->getDouble();
+        break;
+
+    case 143:
+        dimaltf = reader->getDouble();
+        break;
+
+    case 144:
+        dimlfac = reader->getDouble();
+        break;
+
+    case 145:
+        dimtvp = reader->getDouble();
+        break;
+
+    case 146:
+        dimtfac = reader->getDouble();
+        break;
+
+    case 147:
+        dimgap = reader->getDouble();
+        break;
+
+    case 148:
+        dimaltrnd = reader->getDouble();
+        break;
+
+    case 71:
+        dimtol = reader->getInt32();
+        break;
+
+    case 72:
+        dimlim = reader->getInt32();
+        break;
+
+    case 73:
+        dimtih = reader->getInt32();
+        break;
+
+    case 74:
+        dimtoh = reader->getInt32();
+        break;
+
+    case 75:
+        dimse1 = reader->getInt32();
+        break;
+
+    case 76:
+        dimse2 = reader->getInt32();
+        break;
+
+    case 77:
+        dimtad = reader->getInt32();
+        break;
+
+    case 78:
+        dimzin = reader->getInt32();
+        break;
+
+    case 79:
+        dimazin = reader->getInt32();
+        break;
+
+    case 170:
+        dimalt = reader->getInt32();
+        break;
+
+    case 171:
+        dimaltd = reader->getInt32();
+        break;
+
+    case 172:
+        dimtofl = reader->getInt32();
+        break;
+
+    case 173:
+        dimsah = reader->getInt32();
+        break;
+
+    case 174:
+        dimtix = reader->getInt32();
+        break;
+
+    case 175:
+        dimsoxd = reader->getInt32();
+        break;
+
+    case 176:
+        dimclrd = reader->getInt32();
+        break;
+
+    case 177:
+        dimclre = reader->getInt32();
+        break;
+
+    case 178:
+        dimclrt = reader->getInt32();
+        break;
+
+    case 179:
+        dimadec = reader->getInt32();
+        break;
+
+    case 270:
+        dimunit = reader->getInt32();
+        break;
+
+    case 271:
+        dimdec = reader->getInt32();
+        break;
+
+    case 272:
+        dimtdec = reader->getInt32();
+        break;
+
+    case 273:
+        dimaltu = reader->getInt32();
+        break;
+
+    case 274:
+        dimalttd = reader->getInt32();
+        break;
+
+    case 275:
+        dimaunit = reader->getInt32();
+        break;
+
+    case 276:
+        dimfrac = reader->getInt32();
+        break;
+
+    case 277:
+        dimlunit = reader->getInt32();
+        break;
+
+    case 278:
+        dimdsep = reader->getInt32();
+        break;
+
+    case 279:
+        dimtmove = reader->getInt32();
+        break;
+
+    case 280:
+        dimjust = reader->getInt32();
+        break;
+
+    case 281:
+        dimsd1 = reader->getInt32();
+        break;
+
+    case 282:
+        dimsd2 = reader->getInt32();
+        break;
+
+    case 283:
+        dimtolj = reader->getInt32();
+        break;
+
+    case 284:
+        dimtzin = reader->getInt32();
+        break;
+
+    case 285:
+        dimaltz = reader->getInt32();
+        break;
+
+    case 286:
+        dimaltttz = reader->getInt32();
+        break;
+
+    case 287:
+        dimfit = reader->getInt32();
+        break;
+
+    case 288:
+        dimupt = reader->getInt32();
+        break;
+
+    case 289:
+        dimatfit = reader->getInt32();
+        break;
+
+    case 340:
+        dimtxsty = reader->getUtf8String();
+        break;
+
+    case 341:
+        dimldrblk = reader->getUtf8String();
+        break;
+
+    case 342:
+        dimblk = reader->getUtf8String();
+        break;
+
+    case 343:
+        dimblk1 = reader->getUtf8String();
+        break;
+
+    case 344:
+        dimblk2 = reader->getUtf8String();
+        break;
+
+    default:
+        DRW_TableEntry::parseCode( code, reader );
+        break;
+    }
+}
+
+
+// ! Class to handle line type entries
+/*!
+ *  Class to handle line type symbol table entries
+ *  @author Rallaz
+ */
+void DRW_LType::parseCode( int code, dxfReader* reader )
+{
+    switch( code )
+    {
+    case 3:
+        desc = reader->getUtf8String();
+        break;
+
+    case 73:
+        size = reader->getInt32();
+        path.reserve( size );
+        break;
+
+    case 40:
+        length = reader->getDouble();
+        break;
+
+    case 49:
+        path.push_back( reader->getDouble() );
+        pathIdx++;
+        break;
+
+/*    case 74:
+ *       haveShape = reader->getInt32();
+ *       break;*/
+    default:
+        DRW_TableEntry::parseCode( code, reader );
+        break;
+    }
+}
+
+
+// ! Update line type
+/*!
+ *  Update the size and length of line type acording to the path
+ *  @author Rallaz
+ */
+/*TODO: control max length permited */
+void DRW_LType::update()
+{
+    double d = 0;
+
+    size = path.size();
+
+    for( int i = 0; i< size; i++ )
+    {
+        d += fabs( path.at( i ) );
+    }
+
+    length = d;
+}
+
+
+// ! Class to handle layer entries
+/*!
+ *  Class to handle layer symbol table entries
+ *  @author Rallaz
+ */
+void DRW_Layer::parseCode( int code, dxfReader* reader )
+{
+    switch( code )
+    {
+    case 6:
+        lineType = reader->getUtf8String();
+        break;
+
+    case 62:
+        color = reader->getInt32();
+        break;
+
+    case 290:
+        plotF = reader->getBool();
+        break;
+
+    case 370:
+        lWeight = DRW_LW_Conv::dxfInt2lineWidth( reader->getInt32() );
+        break;
+
+    case 390:
+        handlePlotS = reader->getString();
+        break;
+
+    case 347:
+        handlePlotM = reader->getString();
+        break;
+
+    case 420:
+        color24 = reader->getInt32();
+        break;
+
+    default:
+        DRW_TableEntry::parseCode( code, reader );
+        break;
+    }
+}
+
+
+// ! Class to handle text style entries
+/*!
+ *  Class to handle text style symbol table entries
+ *  @author Rallaz
+ */
+void DRW_Textstyle::parseCode( int code, dxfReader* reader )
+{
+    switch( code )
+    {
+    case 3:
+        font = reader->getUtf8String();
+        break;
+
+    case 4:
+        bigFont = reader->getUtf8String();
+        break;
+
+    case 40:
+        height = reader->getDouble();
+        break;
+
+    case 41:
+        width = reader->getDouble();
+        break;
+
+    case 50:
+        oblique = reader->getDouble();
+        break;
+
+    case 42:
+        lastHeight = reader->getDouble();
+        break;
+
+    case 71:
+        genFlag = reader->getInt32();
+        break;
+
+    case 1071:
+        fontFamily = reader->getInt32();
+        break;
+
+    default:
+        DRW_TableEntry::parseCode( code, reader );
+        break;
+    }
+}
+
+
+// ! Class to handle vport entries
+/*!
+ *  Class to handle vport symbol table entries
+ *  @author Rallaz
+ */
+void DRW_Vport::parseCode( int code, dxfReader* reader )
+{
+    switch( code )
+    {
+    case 10:
+        lowerLeft.x = reader->getDouble();
+        break;
+
+    case 20:
+        lowerLeft.y = reader->getDouble();
+        break;
+
+    case 11:
+        UpperRight.x = reader->getDouble();
+        break;
+
+    case 21:
+        UpperRight.y = reader->getDouble();
+        break;
+
+    case 12:
+        center.x = reader->getDouble();
+        break;
+
+    case 22:
+        center.y = reader->getDouble();
+        break;
+
+    case 13:
+        snapBase.x = reader->getDouble();
+        break;
+
+    case 23:
+        snapBase.y = reader->getDouble();
+        break;
+
+    case 14:
+        snapSpacing.x = reader->getDouble();
+        break;
+
+    case 24:
+        snapSpacing.y = reader->getDouble();
+        break;
+
+    case 15:
+        gridSpacing.x = reader->getDouble();
+        break;
+
+    case 25:
+        gridSpacing.y = reader->getDouble();
+        break;
+
+    case 16:
+        viewDir.x = reader->getDouble();
+        break;
+
+    case 26:
+        viewDir.y = reader->getDouble();
+        break;
+
+    case 36:
+        viewDir.z = reader->getDouble();
+        break;
+
+    case 17:
+        viewTarget.x = reader->getDouble();
+        break;
+
+    case 27:
+        viewTarget.y = reader->getDouble();
+        break;
+
+    case 37:
+        viewTarget.z = reader->getDouble();
+        break;
+
+    case 40:
+        height = reader->getDouble();
+        break;
+
+    case 41:
+        ratio = reader->getDouble();
+        break;
+
+    case 42:
+        lensHeight = reader->getDouble();
+        break;
+
+    case 43:
+        frontClip = reader->getDouble();
+        break;
+
+    case 44:
+        backClip = reader->getDouble();
+        break;
+
+    case 50:
+        snapAngle = reader->getDouble();
+        break;
+
+    case 51:
+        twistAngle = reader->getDouble();
+        break;
+
+    case 71:
+        viewMode = reader->getInt32();
+        break;
+
+    case 72:
+        circleZoom = reader->getInt32();
+        break;
+
+    case 73:
+        fastZoom = reader->getInt32();
+        break;
+
+    case 74:
+        ucsIcon = reader->getInt32();
+        break;
+
+    case 75:
+        snap = reader->getInt32();
+        break;
+
+    case 76:
+        grid = reader->getInt32();
+        break;
+
+    case 77:
+        snapStyle = reader->getInt32();
+        break;
+
+    case 78:
+        snapIsopair = reader->getInt32();
+        break;
+
+    default:
+        DRW_TableEntry::parseCode( code, reader );
+        break;
+    }
+}
+
+
+void DRW_ImageDef::parseCode( int code, dxfReader* reader )
+{
+    switch( code )
+    {
+    case 1:
+        name = reader->getUtf8String();
+        break;
+
+    case 5:
+        handle = reader->getString();
+        break;
+
+    case 10:
+        u = reader->getDouble();
+        break;
+
+    case 20:
+        v = reader->getDouble();
+        break;
+
+    case 11:
+        up = reader->getDouble();
+        break;
+
+    case 12:
+        vp = reader->getDouble();
+        break;
+
+    case 21:
+        vp = reader->getDouble();
+        break;
+
+    case 280:
+        loaded = reader->getInt32();
+        break;
+
+    case 281:
+        resolution = reader->getInt32();
+        break;
+
+    default:
+        break;
+    }
+}
+
+
+void DRW_Header::addComment( string c )
+{
+    if( !comments.empty() )
+        comments += '\n';
+
+    comments += c;
+}
+
+
+void DRW_Header::parseCode( int code, dxfReader* reader )
+{
+    switch( code )
+    {
+    case 9:
+        curr    = new DRW_Variant();
+        name    = reader->getString();
+
+        if( version < DRW::AC1015 && name == "$DIMUNIT" )
+            name = "$DIMLUNIT";
+
+        vars[name] = curr;
+        break;
+
+    case 1:
+        curr->addString( reader->getUtf8String() );
+
+        if( name =="$ACADVER" )
+        {
+            reader->setVersion( curr->content.s );
+            version = reader->getVersion();
+        }
+
+        curr->code = code;
+        break;
+
+    case 2:
+        curr->addString( reader->getUtf8String() );
+        curr->code = code;
+        break;
+
+    case 3:
+        curr->addString( reader->getUtf8String() );
+
+        if( name =="$DWGCODEPAGE" )
+        {
+            reader->setCodePage( curr->content.s );
+            curr->addString( reader->getCodePage() );
+        }
+
+        curr->code = code;
+        break;
+
+    case 6:
+        curr->addString( reader->getUtf8String() );
+        curr->code = code;
+        break;
+
+    case 7:
+        curr->addString( reader->getUtf8String() );
+        curr->code = code;
+        break;
+
+    case 8:
+        curr->addString( reader->getUtf8String() );
+        curr->code = code;
+        break;
+
+    case 10:
+        curr->addCoord( new DRW_Coord() );
+        curr->setCoordX( reader->getDouble() );
+        curr->code = code;
+        break;
+
+    case 20:
+        curr->setCoordY( reader->getDouble() );
+        break;
+
+    case 30:
+        curr->setCoordZ( reader->getDouble() );
+        curr->code = code;
+        break;
+
+    case 40:
+        curr->addDouble( reader->getDouble() );
+        curr->code = code;
+        break;
+
+    case 50:
+        curr->addDouble( reader->getDouble() );
+        curr->code = code;
+        break;
+
+    case 62:
+        curr->addInt( reader->getInt32() );
+        curr->code = code;
+        break;
+
+    case 70:
+        curr->addInt( reader->getInt32() );
+        curr->code = code;
+        break;
+
+    case 280:
+        curr->addInt( reader->getInt32() );
+        curr->code = code;
+        break;
+
+    case 290:
+        curr->addInt( reader->getInt32() );
+        curr->code = code;
+        break;
+
+    case 370:
+        curr->addInt( reader->getInt32() );
+        curr->code = code;
+        break;
+
+    case 380:
+        curr->addInt( reader->getInt32() );
+        curr->code = code;
+        break;
+
+    case 390:
+        curr->addString( reader->getUtf8String() );
+        curr->code = code;
+        break;
+
+    default:
+        break;
+    }
+}
+
+
+void DRW_Header::write( dxfWriter* writer, DRW::Version ver )
+{
+/*RLZ: TODO complete all vars to AC1024*/
+    double      varDouble;
+    int         varInt;
+    std::string varStr;
+    DRW_Coord   varCoord;
+
+    writer->writeString( 2, "HEADER" );
+    writer->writeString( 9, "$ACADVER" );
+
+    switch( ver )
+    {
+    case DRW::AC1006:       // unsupported version acad 10
+    case DRW::AC1009:       // acad 11 & 12
+        varStr = "AC1009";
+        break;
+
+    case DRW::AC1012:       // unsupported version acad 13
+    case DRW::AC1014:       // acad 14
+        varStr = "AC1014";
+        break;
+
+    case DRW::AC1015:    // acad 2000
+        varStr = "AC1015";
+        break;
+
+    case DRW::AC1018:    // acad 2004
+        varStr = "AC1018";
+        break;
+
+/*    case DRW::AC1021: //acad 2007
+ *       varStr = "AC1021";
+ *       break;*/
+    case DRW::AC1024:    // acad 2010
+        varStr = "AC1024";
+        break;
+
+    default:    // acad 2007 default version
+        varStr = "AC1021";
+        break;
+    }
+
+    writer->writeString( 1, varStr );
+    writer->setVersion( &varStr );
+
+    if( ver > DRW::AC1012 )
+    {
+        writer->writeString( 9, "$HANDSEED" );
+// RLZ        dxfHex(5, 0xFFFF);
+        writer->writeString( 5, "20000" );
+    }
+
+    if( !getStr( "$DWGCODEPAGE", &varStr ) )
+    {
+        varStr = "ANSI_1252";
+    }
+
+    writer->writeString( 9, "$DWGCODEPAGE" );
+    writer->setCodePage( &varStr );
+    writer->writeString( 3, writer->getCodePage() );
+    writer->writeString( 9, "$INSBASE" );
+
+    if( getCoord( "$INSBASE", &varCoord ) )
+    {
+        writer->writeDouble( 10, varCoord.x );
+        writer->writeDouble( 20, varCoord.y );
+        writer->writeDouble( 30, varCoord.z );
+    }
+    else
+    {
+        writer->writeDouble( 10, 0.0 );
+        writer->writeDouble( 20, 0.0 );
+        writer->writeDouble( 30, 0.0 );
+    }
+
+    writer->writeString( 9, "$EXTMIN" );
+
+    if( getCoord( "$EXTMIN", &varCoord ) )
+    {
+        writer->writeDouble( 10, varCoord.x );
+        writer->writeDouble( 20, varCoord.y );
+        writer->writeDouble( 30, varCoord.z );
+    }
+    else
+    {
+        writer->writeDouble( 10, 1.0000000000000000E+020 );
+        writer->writeDouble( 20, 1.0000000000000000E+020 );
+        writer->writeDouble( 30, 1.0000000000000000E+020 );
+    }
+
+    writer->writeString( 9, "$EXTMAX" );
+
+    if( getCoord( "$EXTMAX", &varCoord ) )
+    {
+        writer->writeDouble( 10, varCoord.x );
+        writer->writeDouble( 20, varCoord.y );
+        writer->writeDouble( 30, varCoord.z );
+    }
+    else
+    {
+        writer->writeDouble( 10, -1.0000000000000000E+020 );
+        writer->writeDouble( 20, -1.0000000000000000E+020 );
+        writer->writeDouble( 30, -1.0000000000000000E+020 );
+    }
+
+    writer->writeString( 9, "$LIMMIN" );
+
+    if( getCoord( "$LIMMIN", &varCoord ) )
+    {
+        writer->writeDouble( 10, varCoord.x );
+        writer->writeDouble( 20, varCoord.y );
+    }
+    else
+    {
+        writer->writeDouble( 10, 0.0 );
+        writer->writeDouble( 20, 0.0 );
+    }
+
+    writer->writeString( 9, "$LIMMAX" );
+
+    if( getCoord( "$LIMMAX", &varCoord ) )
+    {
+        writer->writeDouble( 10, varCoord.x );
+        writer->writeDouble( 20, varCoord.y );
+    }
+    else
+    {
+        writer->writeDouble( 10, 420.0 );
+        writer->writeDouble( 20, 297.0 );
+    }
+
+    writer->writeString( 9, "$ORTHOMODE" );
+
+    if( getInt( "$ORTHOMODE", &varInt ) )
+        writer->writeInt16( 70, varInt );
+    else
+        writer->writeInt16( 70, 0 );
+
+    writer->writeString( 9, "$LTSCALE" );
+
+    if( getDouble( "$LTSCALE", &varDouble ) )
+        writer->writeDouble( 40, varDouble );
+    else
+        writer->writeDouble( 40, 1.0 );
+
+    writer->writeString( 9, "$TEXTSTYLE" );
+
+    if( getStr( "$TEXTSTYLE", &varStr ) )
+        if( ver == DRW::AC1009 )
+            writer->writeUtf8Caps( 7, varStr );
+        else
+            writer->writeUtf8String( 7, varStr );
+
+
+    else
+        writer->writeString( 7, "STANDARD" );
+
+    writer->writeString( 9, "$DIMASZ" );
+
+    if( getDouble( "$DIMASZ", &varDouble ) )
+        writer->writeDouble( 40, varDouble );
+    else
+        writer->writeDouble( 40, 2.5 );
+
+    writer->writeString( 9, "$DIMSCALE" );
+
+    if( getDouble( "$DIMSCALE", &varDouble ) )
+        writer->writeDouble( 40, varDouble );
+    else
+        writer->writeDouble( 40, 1.0 );
+
+    writer->writeString( 9, "$DIMEXO" );
+
+    if( getDouble( "$DIMEXO", &varDouble ) )
+        writer->writeDouble( 40, varDouble );
+    else
+        writer->writeDouble( 40, 0.625 );
+
+    writer->writeString( 9, "$DIMEXE" );
+
+    if( getDouble( "$DIMEXE", &varDouble ) )
+        writer->writeDouble( 40, varDouble );
+    else
+        writer->writeDouble( 40, 1.25 );
+
+    writer->writeString( 9, "$DIMTXT" );
+
+    if( getDouble( "$DIMTXT", &varDouble ) )
+        writer->writeDouble( 40, varDouble );
+    else
+        writer->writeDouble( 40, 2.5 );
+
+    writer->writeString( 9, "$DIMTSZ" );
+
+    if( getDouble( "$DIMTSZ", &varDouble ) )
+        writer->writeDouble( 40, varDouble );
+    else
+        writer->writeDouble( 40, 0.0 );
+
+    if( ver > DRW::AC1009 )
+    {
+        writer->writeString( 9, "$DIMAUNIT" );
+
+        if( getInt( "$DIMAUNIT", &varInt ) )
+            writer->writeInt16( 70, varInt );
+        else
+            writer->writeInt16( 70, 0 );
+
+        writer->writeString( 9, "$DIMADEC" );
+
+        if( getInt( "$DIMADEC", &varInt ) )
+            writer->writeInt16( 70, varInt );
+        else
+            writer->writeInt16( 70, 0 );
+    }
+
+    // verify if exist "$DIMLUNIT" or obsolete "$DIMUNIT" (pre v2000)
+    if( !getInt( "$DIMLUNIT", &varInt ) )
+    {
+        if( !getInt( "$DIMUNIT", &varInt ) )
+            varInt = 2;
+    }
+
+    // verify valid values from 1 to 6
+    if( varInt<1 || varInt>6 )
+        varInt = 2;
+
+    if( ver > DRW::AC1014 )
+    {
+        writer->writeString( 9, "$DIMLUNIT" );
+        writer->writeInt16( 70, varInt );
+    }
+    else
+    {
+        writer->writeString( 9, "$DIMUNIT" );
+        writer->writeInt16( 70, varInt );
+    }
+
+    writer->writeString( 9, "$DIMSTYLE" );
+
+    if( getStr( "$DIMSTYLE", &varStr ) )
+        if( ver == DRW::AC1009 )
+            writer->writeUtf8Caps( 2, varStr );
+        else
+            writer->writeUtf8String( 2, varStr );
+
+
+    else
+        writer->writeString( 2, "STANDARD" );
+
+    writer->writeString( 9, "$DIMGAP" );
+
+    if( getDouble( "$DIMGAP", &varDouble ) )
+        writer->writeDouble( 40, varDouble );
+    else
+        writer->writeDouble( 40, 0.625 );
+
+    writer->writeString( 9, "$DIMTIH" );
+
+    if( getInt( "$DIMTIH", &varInt ) )
+        writer->writeInt16( 70, varInt );
+    else
+        writer->writeInt16( 70, 0 );
+
+    writer->writeString( 9, "$LUNITS" );
+
+    if( getInt( "$LUNITS", &varInt ) )
+        writer->writeInt16( 70, varInt );
+    else
+        writer->writeInt16( 70, 2 );
+
+    writer->writeString( 9, "$LUPREC" );
+
+    if( getInt( "$LUPREC", &varInt ) )
+        writer->writeInt16( 70, varInt );
+    else
+        writer->writeInt16( 70, 4 );
+
+    writer->writeString( 9, "$AUNITS" );
+
+    if( getInt( "$AUNITS", &varInt ) )
+        writer->writeInt16( 70, varInt );
+    else
+        writer->writeInt16( 70, 0 );
+
+    writer->writeString( 9, "$AUPREC" );
+
+    if( getInt( "$AUPREC", &varInt ) )
+        writer->writeInt16( 70, varInt );
+    else
+        writer->writeInt16( 70, 2 );
+
+    if( ver > DRW::AC1009 )
+    {
+        writer->writeString( 9, "$SPLINESEGS" );
+
+        if( getInt( "$SPLINESEGS", &varInt ) )
+        {
+            writer->writeInt16( 70, varInt );
+        }
+        else
+            writer->writeInt16( 70, 8 );
+    }
+
+/* RLZ: moved to active VPORT, but can write in header if present*/
+    if( getInt( "$GRIDMODE", &varInt ) )
+    {
+        writer->writeString( 9, "$GRIDMODE" );
+        writer->writeInt16( 70, varInt );
+    }
+
+    if( getInt( "$SNAPSTYLE", &varInt ) )
+    {
+        writer->writeString( 9, "$SNAPSTYLE" );
+        writer->writeInt16( 70, varInt );
+    }
+
+    if( getCoord( "$GRIDUNIT", &varCoord ) )
+    {
+        writer->writeString( 9, "$GRIDUNIT" );
+        writer->writeDouble( 10, varCoord.x );
+        writer->writeDouble( 20, varCoord.y );
+    }
+
+    if( getCoord( "$VIEWCTR", &varCoord ) )
+    {
+        writer->writeString( 9, "$VIEWCTR" );
+        writer->writeDouble( 10, varCoord.x );
+        writer->writeDouble( 20, varCoord.y );
+    }
+
+/* RLZ: moved to active VPORT, but can write in header if present*/
+
+    if( ver > DRW::AC1009 )
+    {
+        writer->writeString( 9, "$PINSBASE" );
+
+        if( getCoord( "$PINSBASE", &varCoord ) )
+        {
+            writer->writeDouble( 10, varCoord.x );
+            writer->writeDouble( 20, varCoord.y );
+            writer->writeDouble( 30, varCoord.z );
+        }
+        else
+        {
+            writer->writeDouble( 10, 0.0 );
+            writer->writeDouble( 20, 0.0 );
+            writer->writeDouble( 30, 0.0 );
+        }
+    }
+
+    writer->writeString( 9, "$PLIMMIN" );
+
+    if( getCoord( "$PLIMMIN", &varCoord ) )
+    {
+        writer->writeDouble( 10, varCoord.x );
+        writer->writeDouble( 20, varCoord.y );
+    }
+    else
+    {
+        writer->writeDouble( 10, 0.0 );
+        writer->writeDouble( 20, 0.0 );
+    }
+
+    writer->writeString( 9, "$PLIMMAX" );
+
+    if( getCoord( "$PLIMMAX", &varCoord ) )
+    {
+        writer->writeDouble( 10, varCoord.x );
+        writer->writeDouble( 20, varCoord.y );
+    }
+    else
+    {
+        writer->writeDouble( 10, 297.0 );
+        writer->writeDouble( 20, 210.0 );
+    }
+
+    if( ver > DRW::AC1014 )
+    {
+        writer->writeString( 9, "$INSUNITS" );
+
+        if( getInt( "$INSUNITS", &varInt ) )
+            writer->writeInt16( 70, varInt );
+        else
+            writer->writeInt16( 70, 0 );
+    }
+
+    if( ver > DRW::AC1009 )
+    {
+        writer->writeString( 9, "$PSVPSCALE" );
+
+        if( getDouble( "$PSVPSCALE", &varDouble ) )
+            writer->writeDouble( 40, varDouble );
+        else
+            writer->writeDouble( 40, 0.0 );
+    }
+
+    std::map<std::string, DRW_Variant*>::const_iterator it;
+
+    for( it = vars.begin(); it != vars.end(); it++ )
+    {
+        std::cerr << (*it).first << std::endl;
+    }
+}
+
+
+bool DRW_Header::getDouble( string key, double* varDouble )
+{
+    bool result = false;
+    std::map<std::string, DRW_Variant*>::iterator it;
+
+    it = vars.find( key );
+
+    if( it != vars.end() )
+    {
+        DRW_Variant* var = (*it).second;
+
+        if( var->type == DRW_Variant::DOUBLE )
+        {
+            *varDouble  = var->content.d;
+            result      = true;
+        }
+
+        vars.erase( it );
+    }
+
+    return result;
+}
+
+
+bool DRW_Header::getInt( string key, int* varInt )
+{
+    bool result = false;
+    std::map<std::string, DRW_Variant*>::iterator it;
+
+    it = vars.find( key );
+
+    if( it != vars.end() )
+    {
+        DRW_Variant* var = (*it).second;
+
+        if( var->type == DRW_Variant::INTEGER )
+        {
+            *varInt = var->content.i;
+            result  = true;
+        }
+
+        vars.erase( it );
+    }
+
+    return result;
+}
+
+
+bool DRW_Header::getStr( string key, std::string* varStr )
+{
+    bool result = false;
+    std::map<std::string, DRW_Variant*>::iterator it;
+
+    it = vars.find( key );
+
+    if( it != vars.end() )
+    {
+        DRW_Variant* var = (*it).second;
+
+        if( var->type == DRW_Variant::STRING )
+        {
+            *varStr = *var->content.s;
+            result  = true;
+        }
+
+        vars.erase( it );
+    }
+
+    return result;
+}
+
+
+bool DRW_Header::getCoord( string key, DRW_Coord* varCoord )
+{
+    bool result = false;
+    std::map<std::string, DRW_Variant*>::iterator it;
+
+    it = vars.find( key );
+
+    if( it != vars.end() )
+    {
+        DRW_Variant* var = (*it).second;
+
+        if( var->type == DRW_Variant::COORD )
+        {
+            *varCoord   = *var->content.v;
+            result      = true;
+        }
+
+        vars.erase( it );
+    }
+
+    return result;
+}

lib_dxf/drw_objects.h

+/******************************************************************************
+**  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_OBJECTS_H
+#define DRW_OBJECTS_H
+
+
+#include <string>
+#include <vector>
+#include <map>
+#include "drw_base.h"
+
+class dxfReader;
+class dxfWriter;
+
+using std::string;
+
+namespace DRW {
+// ! Table entries type.
+enum TTYPE {
+    UNKNOWNT,
+    LTYPE,
+    LAYER,
+    STYLE,
+    DIMSTYLE,
+    VPORT,
+    BLOCK_RECORD
+};
+}
+
+// ! Base class for tables entries
+/*!
+ *  Base class for tables entries
+ *  @author Rallaz
+ */
+class DRW_TableEntry
+{
+public:
+    // initializes default values
+    DRW_TableEntry()
+    {
+        tType   = DRW::UNKNOWNT;
+        flags   = 0;
+    }
+
+    virtual ~DRW_TableEntry() {}
+protected:
+    void parseCode( int code, dxfReader* reader );
+
+public:
+    enum DRW::TTYPE tType;          /*!< 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      name;           /*!< entry name, code 2 */
+    int             flags;          /*!< Flags relevant to entry, code 70 */
+};
+
+
+// ! Class to handle dimstyle entries
+/*!
+ *  Class to handle dim style symbol table entries
+ *  @author Rallaz
+ */
+class DRW_Dimstyle : public DRW_TableEntry
+{
+public:
+    DRW_Dimstyle() { reset(); }
+
+    void reset()
+    {
+        tType       = DRW::DIMSTYLE;
+        dimasz      = dimtxt = dimexe = 0.18;
+        dimexo      = 0.0625;
+        dimgap      = dimcen = 0.09;
+        dimtxsty    = "Standard";
+        dimscale    = dimlfac = dimtfac = 1.0;
+        dimdli      = 0.38;
+        dimrnd      = dimdle = dimtp = dimtm = dimtsz = dimtvp = 0.0;
+        dimaltf     = 25.4;
+        dimtol      = dimlim = dimse1 = dimse2 = dimtad = dimzin = 0;
+        dimtoh      = dimtolj = 1;
+        dimalt      = dimtofl = dimsah = dimtix = dimsoxd = 0;
+        dimaltd     = dimunit = dimaltu = dimalttd = dimlunit = 2;
+        dimclrd     = dimclre = dimclrt = dimjust = dimupt = 0;
+        dimazin     = dimaltz = dimaltttz = dimtzin = dimfrac = 0;
+        dimtih      = dimadec = dimaunit = dimsd1 = dimsd2 = dimtmove = 0;
+        dimaltrnd   = 0.0;
+        dimdec      = dimtdec = 4;
+        dimfit      = dimatfit = 3;
+        dimdsep     = '.';
+        dimlwd      = dimlwe = -2;
+    }
+
+    void parseCode( int code, dxfReader* reader );
+
+public:
+    // V12
+    UTF8STRING  dimpost;        /*!< code 3 */
+    UTF8STRING  dimapost;       /*!< code 4 */
+/* handle are code 105 */
+    UTF8STRING  dimblk;         /*!< code 5, code 342 V2000+ */
+    UTF8STRING  dimblk1;        /*!< code 6, code 343 V2000+ */
+    UTF8STRING  dimblk2;        /*!< code 7, code 344 V2000+ */
+    double      dimscale;       /*!< code 40 */
+    double      dimasz;         /*!< code 41 */
+    double      dimexo;         /*!< code 42 */
+    double      dimdli;         /*!< code 43 */
+    double      dimexe;         /*!< code 44 */
+    double      dimrnd;         /*!< code 45 */
+    double      dimdle;         /*!< code 46 */
+    double      dimtp;          /*!< code 47 */
+    double      dimtm;          /*!< code 48 */
+    double      dimtxt;         /*!< code 140 */
+    double      dimcen;         /*!< code 141 */
+    double      dimtsz;         /*!< code 142 */
+    double      dimaltf;        /*!< code 143 */
+    double      dimlfac;        /*!< code 144 */
+    double      dimtvp;         /*!< code 145 */
+    double      dimtfac;        /*!< code 146 */
+    double      dimgap;         /*!< code 147 */
+    double      dimaltrnd;      /*!< code 148 V2000+ */
+    int         dimtol;         /*!< code 71 */
+    int         dimlim;         /*!< code 72 */
+    int         dimtih;         /*!< code 73 */
+    int         dimtoh;         /*!< code 74 */
+    int         dimse1;         /*!< code 75 */
+    int         dimse2;         /*!< code 76 */
+    int         dimtad;         /*!< code 77 */
+    int         dimzin;         /*!< code 78 */
+    int         dimazin;        /*!< code 79 V2000+ */
+    int         dimalt;         /*!< code 170 */
+    int         dimaltd;        /*!< code 171 */
+    int         dimtofl;        /*!< code 172 */
+    int         dimsah;         /*!< code 173 */
+    int         dimtix;         /*!< code 174 */
+    int         dimsoxd;        /*!< code 175 */
+    int         dimclrd;        /*!< code 176 */
+    int         dimclre;        /*!< code 177 */
+    int         dimclrt;        /*!< code 178 */
+    int         dimadec;        /*!< code 179 V2000+ */
+    int         dimunit;        /*!< code 270 R13+ (obsolete 2000+, use dimlunit & dimfrac) */
+    int         dimdec;         /*!< code 271 R13+ */
+    int         dimtdec;        /*!< code 272 R13+ */
+    int         dimaltu;        /*!< code 273 R13+ */
+    int         dimalttd;       /*!< code 274 R13+ */
+    int         dimaunit;       /*!< code 275 R13+ */
+    int         dimfrac;        /*!< code 276 V2000+ */
+    int         dimlunit;       /*!< code 277 V2000+ */
+    int         dimdsep;        /*!< code 278 V2000+ */
+    int         dimtmove;       /*!< code 279 V2000+ */
+    int         dimjust;        /*!< code 280 R13+ */
+    int         dimsd1;         /*!< code 281 R13+ */
+    int         dimsd2;         /*!< code 282 R13+ */
+    int         dimtolj;        /*!< code 283 R13+ */
+    int         dimtzin;        /*!< code 284 R13+ */
+    int         dimaltz;        /*!< code 285 R13+ */
+    int         dimaltttz;      /*!< code 286 R13+ */
+    int         dimfit;         /*!< code 287 R13+  (obsolete 2000+, use dimatfit & dimtmove)*/
+    int         dimupt;         /*!< code 288 R13+ */
+    int         dimatfit;       /*!< code 289 V2000+ */
+    UTF8STRING  dimtxsty;       /*!< code 340 R13+ */
+    UTF8STRING  dimldrblk;      /*!< code 341 V2000+ */
+    int         dimlwd;         /*!< code 371 V2000+ */
+    int         dimlwe;         /*!< code 372 V2000+ */
+};
+
+
+// ! Class to handle line type entries
+/*!
+ *  Class to handle line type symbol table entries
+ *  @author Rallaz
+ */
+/*TODO: handle complex lineType*/
+class DRW_LType : public DRW_TableEntry
+{
+public:
+    DRW_LType() { reset(); }
+
+    void reset()
+    {
+        tType   = DRW::LTYPE;
+        desc    = "";
+        size    = 0;
+        length  = 0.0;
+        pathIdx = 0;
+/*        color = 256; // default BYLAYER (256)
+ *       plotF = true; // default TRUE (plot yes)
+ *       lWeight = -1; // default BYLAYER (-1)*/
+// align = 65; //always 65
+    }
+
+    void    parseCode( int code, dxfReader* reader );
+    void    update();
+
+public:
+    UTF8STRING          desc;   /*!< descriptive string, code 3 */
+// int align;               /*!< align code, always 65 ('A') code 72 */
+    int                 size;   /*!< element number, code 73 */
+    double              length; /*!< total length of pattern, code 40 */
+// int haveShape;      /*!< complex linetype type, code 74 */
+    std::vector<double> path;   /*!< trace, point or space length sequence, code 49 */
+private:
+    int                 pathIdx;
+};
+
+
+// ! Class to handle layer entries
+/*!
+ *  Class to handle layer symbol table entries
+ *  @author Rallaz
+ */
+class DRW_Layer : public DRW_TableEntry
+{
+public:
+    DRW_Layer() { reset(); }
+
+    void reset()
+    {
+        tType       = DRW::LAYER;
+        lineType    = "CONTINUOUS";
+        color       = 7;                            // default BYLAYER (256)
+        plotF       = true;                         // default TRUE (plot yes)
+        lWeight     = DRW_LW_Conv::widthDefault;    // default BYDEFAULT (dxf -3, dwg 31)
+        color24     = -1;                           // default -1 not set
+    }
+
+    void parseCode( int code, dxfReader* reader );
+
+public:
+    UTF8STRING  lineType;                   /*!< line type, code 6 */
+    int         color;                      /*!< layer color, code 62 */
+    int         color24;                    /*!< 24-bit color, code 420 */
+    bool        plotF;                      /*!< Plot flag, code 290 */
+    enum DRW_LW_Conv::lineWidth lWeight;    /*!< layer lineweight, code 370 */
+    string      handlePlotS;                /*!< Hard-pointer ID/handle of plotstyle, code 390 */
+    string      handlePlotM;                /*!< Hard-pointer ID/handle of materialstyle, code 347 */
+};
+
+// ! Class to handle text style entries
+/*!
+ *  Class to handle text style symbol table entries
+ *  @author Rallaz
+ */
+class DRW_Textstyle : public DRW_TableEntry
+{
+public:
+    DRW_Textstyle() { reset(); }
+
+    void reset()
+    {
+        tType       = DRW::STYLE;
+        height      = oblique = 0.0;
+        width       = lastHeight = 1.0;
+        font        = "txt";
+        genFlag     = 0; // 2= X mirror, 4= Y mirror
+        fontFamily  = 0;
+    }
+
+    void parseCode( int code, dxfReader* reader );
+
+public:
+    double      height;     /*!< Fixed text height (0 not set), code 40 */
+    double      width;      /*!< Width factor, code 41 */
+    double      oblique;    /*!< Oblique angle, code 50 */
+    int         genFlag;    /*!< Text generation flags, code 71 */
+    double      lastHeight; /*!< Last height used, code 42 */
+    UTF8STRING  font;       /*!< primary font file name, code 3 */
+    UTF8STRING  bigFont;    /*!< bigfont file name or blank if none, code 4 */
+    int         fontFamily; /*!< ttf font family, italic and bold flags, code 1071 */
+};
+
+// ! Class to handle vport entries
+/*!
+ *  Class to handle vport symbol table entries
+ *  @author Rallaz
+ */
+class DRW_Vport : public DRW_TableEntry
+{
+public:
+    DRW_Vport() { reset(); }
+
+    void reset()
+    {
+        UpperRight.x    = UpperRight.y = 1.0;
+        snapSpacing.x   = snapSpacing.y = 10.0;
+        gridSpacing     = snapSpacing;
+        center.x        = 0.651828;
+        center.y        = -0.16;
+        viewDir.z       = 1;
+        height          = 5.13732;
+        ratio           = 2.4426877;
+        lensHeight      = 50;
+        frontClip       = backClip = snapAngle = twistAngle = 0.0;
+        viewMode        = snap = grid = snapStyle = snapIsopair = 0;
+        fastZoom        = 1;
+        circleZoom      = 100;
+        ucsIcon         = 3;
+        gridBehavior    = 7;
+    }
+
+    void parseCode( int code, dxfReader* reader );
+
+public:
+    DRW_Coord   lowerLeft;      /*!< Lower left corner, code 10 & 20 */
+    DRW_Coord   UpperRight;     /*!< Upper right corner, code 11 & 21 */
+    DRW_Coord   center;         /*!< center point in WCS, code 12 & 22 */
+    DRW_Coord   snapBase;       /*!< snap base point in DCS, code 13 & 23 */
+    DRW_Coord   snapSpacing;    /*!< snap Spacing, code 14 & 24 */
+    DRW_Coord   gridSpacing;    /*!< grid Spacing, code 15 & 25 */
+    DRW_Coord   viewDir;        /*!< view direction from target point, code 16, 26 & 36 */
+    DRW_Coord   viewTarget;     /*!< view target point, code 17, 27 & 37 */
+    double      height;         /*!< view height, code 40 */
+    double      ratio;          /*!< viewport aspect ratio, code 41 */
+    double      lensHeight;     /*!< lens height, code 42 */
+    double      frontClip;      /*!< front clipping plane, code 43 */
+    double      backClip;       /*!< back clipping plane, code 44 */
+    double      snapAngle;      /*!< snap rotation angle, code 50 */
+    double      twistAngle;     /*!< view twist angle, code 51 */
+    int         viewMode;       /*!< view mode, code 71 */
+    int         circleZoom;     /*!< circle zoom percent, code 72 */
+    int         fastZoom;       /*!< fast zoom setting, code 73 */
+    int         ucsIcon;        /*!< UCSICON setting, code 74 */
+    int         snap;           /*!< snap on/off, code 75 */
+    int         grid;           /*!< grid on/off, code 76 */
+    int         snapStyle;      /*!< snap style, code 77 */
+    int         snapIsopair;    /*!< snap isopair, code 78 */
+    int         gridBehavior;   /*!< grid behavior, code 60, undocummented */
+    /** code 60, bit coded possible value are
+     * bit 1 (1) show out of limits
+     * bit 2 (2) adaptive grid
+     * bit 3 (4) allow subdivision
+     * bit 4 (8) follow dinamic SCP
+     **/
+};
+
+
+// ! Class to handle imagedef entries
+/*!
+ *  Class to handle image definitions object entries
+ *  @author Rallaz
+ */
+class DRW_ImageDef
+{
+public:
+    DRW_ImageDef()
+    {
+        version = 0;
+    }
+
+    void parseCode( int code, dxfReader* reader );
+
+public:
+    string      handle;         /*!< entity identifier, code 5 */
+    UTF8STRING  name;           /*!< File name of image, code 1 */
+    int         version;        /*!< class version, code 90, 0=R14 version */
+    double      u;              /*!< image size in pixels U value, code 10 */
+    double      v;              /*!< image size in pixels V value, code 20 */
+    double      up;             /*!< default size of one pixel U value, code 11 */
+    double      vp;             /*!< default size of one pixel V value, code 12 really is 21*/
+    int         loaded;         /*!< image is loaded flag, code 280, 0=unloaded, 1=loaded */
+    int         resolution;     /*!< resolution units, code 281, 0=no, 2=centimeters, 5=inch */
+
+    std::map<string, string> reactors;
+};
+
+
+// ! Class to handle header entries
+/*!
+ *  Class to handle layer symbol table entries
+ *  @author Rallaz
+ */
+class DRW_Header
+{
+public:
+    DRW_Header()
+    {
+    }
+
+    ~DRW_Header()
+    {
+        vars.clear();
+    }
+
+    void    parseCode( int code, dxfReader* reader );
+    void    write( dxfWriter* writer, DRW::Version ver );
+    void    addComment( string c );
+
+    string getComments() const { return comments; }
+private:
+    bool    getDouble( string key, double* varDouble );
+    bool    getInt( string key, int* varInt );
+    bool    getStr( string key, string* varStr );
+    bool    getCoord( string key, DRW_Coord* varStr );
+
+public:
+    std::map<string, DRW_Variant*> vars;
+private:
+    string          comments;
+    string          name;
+    DRW_Variant*    curr;
+    int             version; // to use on read
+};
+
+namespace DRW {
+// Extended color palette:
+// The first entry is only for direct indexing starting with [1]
+// Color 1 is red (1,0,0)
+const unsigned char dxfColors[][3] =
+{
+    {   0,   0,   0 },  // unused
+    { 255,   0,   0 },  // 1 red
+    { 255, 255,   0 },  // 2 yellow
+    {   0, 255,   0 },  // 3 green
+    {   0, 255, 255 },  // 4 cyan
+    {   0,   0, 255 },  // 5 blue
+    { 255,   0, 255 },  // 6 magenta
+    {   0,   0,   0 },  // 7 black or white
+    { 128, 128, 128 },  // 8 50% gray
+    { 192, 192, 192 },  // 9 75% gray
+    { 255,   0,   0 },  // 10
+    { 255, 127, 127 },
+    { 204,   0,   0 },
+    { 204, 102, 102 },
+    { 153,   0,   0 },
+    { 153,  76,  76 }, // 15
+    { 127,   0,   0 },
+    { 127,  63,  63 },
+    {  76,   0,   0 },
+    {  76,  38,  38 },
+    { 255,  63,   0 }, // 20
+    { 255, 159, 127 },
+    { 204,  51,   0 },
+    { 204, 127, 102 },
+    { 153,  38,   0 },
+    { 153,  95,  76 }, // 25
+    { 127,  31,   0 },
+    { 127,  79,  63 },
+    {  76,  19,   0 },
+    {  76,  47,  38 },
+    { 255, 127,   0 }, // 30
+    { 255, 191, 127 },
+    { 204, 102,   0 },
+    { 204, 153, 102 },
+    { 153,  76,   0 },
+    { 153, 114,  76 }, // 35
+    { 127,  63,   0 },
+    { 127,  95,  63 },
+    {  76,  38,   0 },
+    {  76,  57,  38 },
+    { 255, 191,   0 }, // 40
+    { 255, 223, 127 },
+    { 204, 153,   0 },
+    { 204, 178, 102 },
+    { 153, 114,   0 },
+    { 153, 133,  76 }, // 45
+    { 127,  95,   0 },
+    { 127, 111,  63 },
+    {  76,  57,   0 },
+    {  76,  66,  38 },
+    { 255, 255,   0 }, // 50
+    { 255, 255, 127 },
+    { 204, 204,   0 },
+    { 204, 204, 102 },
+    { 153, 153,   0 },
+    { 153, 153,  76 }, // 55
+    { 127, 127,   0 },
+    { 127, 127,  63 },
+    {  76,  76,   0 },
+    {  76,  76,  38 },
+    { 191, 255,   0 }, // 60
+    { 223, 255, 127 },
+    { 153, 204,   0 },
+    { 178, 204, 102 },
+    { 114, 153,   0 },
+    { 133, 153,  76 }, // 65
+    {  95, 127,   0 },
+    { 111, 127,  63 },
+    {  57,  76,   0 },
+    {  66,  76,  38 },
+    { 127, 255,   0 }, // 70
+    { 191, 255, 127 },
+    { 102, 204,   0 },
+    { 153, 204, 102 },
+    {  76, 153,   0 },
+    { 114, 153,  76 }, // 75
+    {  63, 127,   0 },
+    {  95, 127,  63 },
+    {  38,  76,   0 },
+    {  57,  76,  38 },
+    {  63, 255,   0 }, // 80
+    { 159, 255, 127 },
+    {  51, 204,   0 },
+    { 127, 204, 102 },
+    {  38, 153,   0 },
+    {  95, 153,  76 }, // 85
+    {  31, 127,   0 },
+    {  79, 127,  63 },
+    {  19,  76,   0 },
+    {  47,  76,  38 },
+    {   0, 255,   0 }, // 90
+    { 127, 255, 127 },
+    {   0, 204,   0 },
+    { 102, 204, 102 },
+    {   0, 153,   0 },
+    {  76, 153,  76 }, // 95
+    {   0, 127,   0 },
+    {  63, 127,  63 },
+    {   0,  76,   0 },
+    {  38,  76,  38 },
+    {   0, 255,  63 }, // 100
+    { 127, 255, 159 },
+    {   0, 204,  51 },
+    { 102, 204, 127 },
+    {   0, 153,  38 },
+    {  76, 153,  95 }, // 105
+    {   0, 127,  31 },
+    {  63, 127,  79 },
+    {   0,  76,  19 },
+    {  38,  76,  47 },
+    {   0, 255, 127 }, // 110
+    { 127, 255, 191 },
+    {   0, 204, 102 },
+    { 102, 204, 153 },
+    {   0, 153,  76 },
+    {  76, 153, 114 }, // 115
+    {   0, 127,  63 },
+    {  63, 127,  95 },
+    {   0,  76,  38 },
+    {  38,  76,  57 },
+    {   0, 255, 191 }, // 120
+    { 127, 255, 223 },
+    {   0, 204, 153 },
+    { 102, 204, 178 },
+    {   0, 153, 114 },
+    {  76, 153, 133 }, // 125
+    {   0, 127,  95 },
+    {  63, 127, 111 },
+    {   0,  76,  57 },
+    {  38,  76,  66 },
+    {   0, 255, 255 }, // 130
+    { 127, 255, 255 },
+    {   0, 204, 204 },
+    { 102, 204, 204 },
+    {   0, 153, 153 },
+    {  76, 153, 153 }, // 135
+    {   0, 127, 127 },
+    {  63, 127, 127 },
+    {   0,  76,  76 },
+    {  38,  76,  76 },
+    {   0, 191, 255 }, // 140
+    { 127, 223, 255 },
+    {   0, 153, 204 },
+    { 102, 178, 204 },
+    {   0, 114, 153 },
+    {  76, 133, 153 }, // 145
+    {   0,  95, 127 },
+    {  63, 111, 127 },
+    {   0,  57,  76 },
+    {  38,  66,  76 },
+    {   0, 127, 255 }, // 150
+    { 127, 191, 255 },
+    {   0, 102, 204 },
+    { 102, 153, 204 },
+    {   0,  76, 153 },
+    {  76, 114, 153 }, // 155
+    {   0,  63, 127 },
+    {  63,  95, 127 },
+    {   0,  38,  76 },
+    {  38,  57,  76 },
+    {   0,  66, 255 }, // 160
+    { 127, 159, 255 },
+    {   0,  51, 204 },
+    { 102, 127, 204 },
+    {   0,  38, 153 },
+    {  76,  95, 153 }, // 165
+    {   0,  31, 127 },
+    {  63,  79, 127 },
+    {   0,  19,  76 },
+    {  38,  47,  76 },
+    {   0,   0, 255 }, // 170
+    { 127, 127, 255 },
+    {   0,   0, 204 },
+    { 102, 102, 204 },
+    {   0,   0, 153 },
+    {  76,  76, 153 }, // 175
+    {   0,   0, 127 },
+    {  63,  63, 127 },
+    {   0,   0,  76 },
+    {  38,  38,  76 },
+    {  63,   0, 255 }, // 180
+    { 159, 127, 255 },
+    {  50,   0, 204 },
+    { 127, 102, 204 },
+    {  38,   0, 153 },
+    {  95,  76, 153 }, // 185
+    {  31,   0, 127 },
+    {  79,  63, 127 },
+    {  19,   0,  76 },
+    {  47,  38,  76 },
+    { 127,   0, 255 }, // 190
+    { 191, 127, 255 },
+    { 102,   0, 204 },
+    { 153, 102, 204 },
+    {  76,   0, 153 },
+    { 114,  76, 153 }, // 195
+    {  63,   0, 127 },
+    {  95,  63, 127 },
+    {  38,   0,  76 },
+    {  57,  38,  76 },
+    { 191,   0, 255 }, // 200
+    { 223, 127, 255 },
+    { 153,   0, 204 },
+    { 178, 102, 204 },
+    { 114,   0, 153 },
+    { 133,  76, 153 }, // 205
+    {  95,   0, 127 },
+    { 111,  63, 127 },
+    {  57,   0,  76 },
+    {  66,  38,  76 },
+    { 255,   0, 255 }, // 210
+    { 255, 127, 255 },
+    { 204,   0, 204 },
+    { 204, 102, 204 },
+    { 153,   0, 153 },
+    { 153,  76, 153 }, // 215
+    { 127,   0, 127 },
+    { 127,  63, 127 },
+    {  76,   0,  76 },
+    {  76,  38,  76 },
+    { 255,   0, 191 }, // 220
+    { 255, 127, 223 },
+    { 204,   0, 153 },
+    { 204, 102, 178 },
+    { 153,   0, 114 },
+    { 153,  76, 133 }, // 225
+    { 127,   0,  95 },
+    { 127,  63,  11 },
+    {  76,   0,  57 },
+    {  76,  38,  66 },
+    { 255,   0, 127 }, // 230
+    { 255, 127, 191 },
+    { 204,   0, 102 },
+    { 204, 102, 153 },
+    { 153,   0,  76 },
+    { 153,  76, 114 }, // 235
+    { 127,   0,  63 },
+    { 127,  63,  95 },
+    {  76,   0,  38 },
+    {  76,  38,  57 },
+    { 255,   0,  63 }, // 240
+    { 255, 127, 159 },
+    { 204,   0,  51 },
+    { 204, 102, 127 },
+    { 153,   0,  38 },
+    { 153,  76,  95 }, // 245
+    { 127,   0,  31 },
+    { 127,  63,  79 },
+    {  76,   0,  19 },
+    {  76,  38,  47 },
+    {  51,  51,  51 }, // 250
+    {  91,  91,  91 },
+    { 132, 132, 132 },
+    { 173, 173, 173 },
+    { 214, 214, 214 },
+    { 255, 255, 255 }    // 255
+};
+}
+
+#endif
+
+// EOF

lib_dxf/intern/drw_cptables.h

+#ifndef DRW_CPTABLES_H
+#define DRW_CPTABLES_H
+
+//first entry in all tables are 0x80
+#define CPOFFSET 0x80
+#define CPLENGHTCOMMON 128
+
+//Table 874
+static const int DRW_Table874[] = {
+    0x20AC, //1 #EURO SIGN
+    0x00  , //2 #UNDEFINED
+    0x00  , //3 #UNDEFINED
+    0x00  , //4 #UNDEFINED
+    0x00  , //5 #UNDEFINED
+    0x2026, //6 #HORIZONTAL ELLIPSIS
+    0x00  , //7 #UNDEFINED
+    0x00  , //8 #UNDEFINED
+    0x00  , //9 #UNDEFINED
+    0x00  , //10 #UNDEFINED
+    0x00  , //11 #UNDEFINED
+    0x00  , //12 #UNDEFINED
+    0x00  , //13 #UNDEFINED
+    0x00  , //14 #UNDEFINED
+    0x00  , //15 #UNDEFINED
+    0x00  , //16 #UNDEFINED
+    0x00  , //17 #UNDEFINED
+    0x2018, //18 #LEFT SINGLE QUOTATION MARK
+    0x2019, //19 #RIGHT SINGLE QUOTATION MARK
+    0x201C, //20 #LEFT DOUBLE QUOTATION MARK
+    0x201D, //21 #RIGHT DOUBLE QUOTATION MARK
+    0x2022, //22 #BULLET
+    0x2013, //23 #EN DASH
+    0x2014, //24 #EM DASH
+    0x00  , //25 #UNDEFINED
+    0x00  , //26 #UNDEFINED
+    0x00  , //27 #UNDEFINED
+    0x00  , //28 #UNDEFINED
+    0x00  , //29 #UNDEFINED
+    0x00  , //30 #UNDEFINED
+    0x00  , //31 #UNDEFINED
+    0x00  , //32 #UNDEFINED
+    0x00A0, //33 #NO-BREAK SPACE
+    0x0E01, //34 #THAI CHARACTER KO KAI
+    0x0E02, //35 #THAI CHARACTER KHO KHAI
+    0x0E03, //36 #THAI CHARACTER KHO KHUAT
+    0x0E04, //37 #THAI CHARACTER KHO KHWAI
+    0x0E05, //38 #THAI CHARACTER KHO KHON
+    0x0E06, //39 #THAI CHARACTER KHO RAKHANG
+    0x0E07, //40 #THAI CHARACTER NGO NGU
+    0x0E08, //41 #THAI CHARACTER CHO CHAN
+    0x0E09, //42 #THAI CHARACTER CHO CHING
+    0x0E0A, //43 #THAI CHARACTER CHO CHANG
+    0x0E0B, //44 #THAI CHARACTER SO SO
+    0x0E0C, //45 #THAI CHARACTER CHO CHOE
+    0x0E0D, //46 #THAI CHARACTER YO YING
+    0x0E0E, //47 #THAI CHARACTER DO CHADA
+    0x0E0F, //48 #THAI CHARACTER TO PATAK
+    0x0E10, //49 #THAI CHARACTER THO THAN
+    0x0E11, //50 #THAI CHARACTER THO NANGMONTHO
+    0x0E12, //51 #THAI CHARACTER THO PHUTHAO
+    0x0E13, //52 #THAI CHARACTER NO NEN
+    0x0E14, //53 #THAI CHARACTER DO DEK
+    0x0E15, //54 #THAI CHARACTER TO TAO
+    0x0E16, //55 #THAI CHARACTER THO THUNG
+    0x0E17, //56 #THAI CHARACTER THO THAHAN
+    0x0E18, //57 #THAI CHARACTER THO THONG
+    0x0E19, //58 #THAI CHARACTER NO NU
+    0x0E1A, //59 #THAI CHARACTER BO BAIMAI
+    0x0E1B, //60 #THAI CHARACTER PO PLA
+    0x0E1C, //61 #THAI CHARACTER PHO PHUNG
+    0x0E1D, //62 #THAI CHARACTER FO FA
+    0x0E1E, //63 #THAI CHARACTER PHO PHAN
+    0x0E1F, //64 #THAI CHARACTER FO FAN
+    0x0E20, //65 #THAI CHARACTER PHO SAMPHAO
+    0x0E21, //66 #THAI CHARACTER MO MA
+    0x0E22, //67 #THAI CHARACTER YO YAK
+    0x0E23, //68 #THAI CHARACTER RO RUA
+    0x0E24, //69 #THAI CHARACTER RU
+    0x0E25, //70 #THAI CHARACTER LO LING
+    0x0E26, //71 #THAI CHARACTER LU
+    0x0E27, //72 #THAI CHARACTER WO WAEN
+    0x0E28, //73 #THAI CHARACTER SO SALA
+    0x0E29, //74 #THAI CHARACTER SO RUSI
+    0x0E2A, //75 #THAI CHARACTER SO SUA
+    0x0E2B, //76 #THAI CHARACTER HO HIP
+    0x0E2C, //77 #THAI CHARACTER LO CHULA
+    0x0E2D, //78 #THAI CHARACTER O ANG
+    0x0E2E, //79 #THAI CHARACTER HO NOKHUK
+    0x0E2F, //80 #THAI CHARACTER PAIYANNOI
+    0x0E30, //81 #THAI CHARACTER SARA A
+    0x0E31, //82 #THAI CHARACTER MAI HAN-AKAT
+    0x0E32, //83 #THAI CHARACTER SARA AA
+    0x0E33, //84 #THAI CHARACTER SARA AM
+    0x0E34, //85 #THAI CHARACTER SARA I
+    0x0E35, //86 #THAI CHARACTER SARA II
+    0x0E36, //87 #THAI CHARACTER SARA UE
+    0x0E37, //88 #THAI CHARACTER SARA UEE
+    0x0E38, //89 #THAI CHARACTER SARA U
+    0x0E39, //90 #THAI CHARACTER SARA UU
+    0x0E3A, //91 #THAI CHARACTER PHINTHU
+    0x00  , //92 #UNDEFINED
+    0x00  , //93 #UNDEFINED
+    0x00  , //94 #UNDEFINED
+    0x00  , //95 #UNDEFINED
+    0x0E3F, //96 #THAI CURRENCY SYMBOL BAHT
+    0x0E40, //97 #THAI CHARACTER SARA E
+    0x0E41, //98 #THAI CHARACTER SARA AE
+    0x0E42, //99 #THAI CHARACTER SARA O
+    0x0E43, //100 #THAI CHARACTER SARA AI MAIMUAN
+    0x0E44, //101 #THAI CHARACTER SARA AI MAIMALAI
+    0x0E45, //102 #THAI CHARACTER LAKKHANGYAO
+    0x0E46, //103 #THAI CHARACTER MAIYAMOK
+    0x0E47, //104 #THAI CHARACTER MAITAIKHU
+    0x0E48, //105 #THAI CHARACTER MAI EK
+    0x0E49, //106 #THAI CHARACTER MAI THO
+    0x0E4A, //107 #THAI CHARACTER MAI TRI
+    0x0E4B, //108 #THAI CHARACTER MAI CHATTAWA
+    0x0E4C, //109 #THAI CHARACTER THANTHAKHAT
+    0x0E4D, //110 #THAI CHARACTER NIKHAHIT
+    0x0E4E, //111 #THAI CHARACTER YAMAKKAN
+    0x0E4F, //112 #THAI CHARACTER FONGMAN
+    0x0E50, //113 #THAI DIGIT ZERO
+    0x0E51, //114 #THAI DIGIT ONE
+    0x0E52, //115 #THAI DIGIT TWO
+    0x0E53, //116 #THAI DIGIT THREE
+    0x0E54, //117 #THAI DIGIT FOUR
+    0x0E55, //118 #THAI DIGIT FIVE
+    0x0E56, //119 #THAI DIGIT SIX
+    0x0E57, //120 #THAI DIGIT SEVEN
+    0x0E58, //121 #THAI DIGIT EIGHT
+    0x0E59, //122 #THAI DIGIT NINE
+    0x0E5A, //123 #THAI CHARACTER ANGKHANKHU
+    0x0E5B, //124 #THAI CHARACTER KHOMUT
+    0x00  , //125 #UNDEFINED
+    0x00  , //126 #UNDEFINED
+    0x00  , //127 #UNDEFINED
+    0x00    //128 #UNDEFINED
+};
+
+//Table 1250
+static const int DRW_Table1250[] = {
+0x20AC, //1 #EURO SIGN
+0x00,   //2 #UNDEFINED
+0x201A, //3 #SINGLE LOW-9 QUOTATION MARK
+0x00,   //4 #UNDEFINED
+0x201E, //5 #DOUBLE LOW-9 QUOTATION MARK
+0x2026, //6 #HORIZONTAL ELLIPSIS
+0x2020, //7 #DAGGER
+0x2021, //8 #DOUBLE DAGGER
+0x00,   //9 #UNDEFINED
+0x2030, //10 #PER MILLE SIGN
+0x0160, //11 #LATIN CAPITAL LETTER S WITH CARON
+0x2039, //12 #SINGLE LEFT-POINTING ANGLE QUOTATION MARK
+0x015A, //13 #LATIN CAPITAL LETTER S WITH ACUTE
+0x0164, //14 #LATIN CAPITAL LETTER T WITH CARON
+0x017D, //15 #LATIN CAPITAL LETTER Z WITH CARON
+0x0179, //16 #LATIN CAPITAL LETTER Z WITH ACUTE
+0x00,   //17 #UNDEFINED
+0x2018, //18 #LEFT SINGLE QUOTATION MARK
+0x2019, //19 #RIGHT SINGLE QUOTATION MARK
+0x201C, //20 #LEFT DOUBLE QUOTATION MARK
+0x201D, //21 #RIGHT DOUBLE QUOTATION MARK
+0x2022, //22 #BULLET
+0x2013, //23 #EN DASH
+0x2014, //24 #EM DASH
+0x00,   //25 #UNDEFINED
+0x2122, //26 #TRADE MARK SIGN
+0x0161, //27 #LATIN SMALL LETTER S WITH CARON
+0x203A, //28 #SINGLE RIGHT-POINTING ANGLE QUOTATION MARK
+0x015B, //29 #LATIN SMALL LETTER S WITH ACUTE
+0x0165, //30 #LATIN SMALL LETTER T WITH CARON
+0x017E, //31 #LATIN SMALL LETTER Z WITH CARON
+0x017A, //32 #LATIN SMALL LETTER Z WITH ACUTE
+0x00A0, //33 #NO-BREAK SPACE
+0x02C7, //34 #CARON
+0x02D8, //35 #BREVE
+0x0141, //36 #LATIN CAPITAL LETTER L WITH STROKE
+0x00A4, //37 #CURRENCY SIGN
+0x0104, //38 #LATIN CAPITAL LETTER A WITH OGONEK
+0x00A6, //39 #BROKEN BAR
+0x00A7, //40 #SECTION SIGN
+0x00A8, //41 #DIAERESIS
+0x00A9, //42 #COPYRIGHT SIGN
+0x015E, //43 #LATIN CAPITAL LETTER S WITH CEDILLA
+0x00AB, //44 #LEFT-POINTING DOUBLE ANGLE QUOTATION MARK
+0x00AC, //45 #NOT SIGN
+0x00AD, //46 #SOFT HYPHEN
+0x00AE, //47 #REGISTERED SIGN
+0x017B, //48 #LATIN CAPITAL LETTER Z WITH DOT ABOVE
+0x00B0, //49 #DEGREE SIGN
+0x00B1, //50 #PLUS-MINUS SIGN
+0x02DB, //51 #OGONEK
+0x0142, //52 #LATIN SMALL LETTER L WITH STROKE
+0x00B4, //53 #ACUTE ACCENT
+0x00B5, //54 #MICRO SIGN
+0x00B6, //55 #PILCROW SIGN
+0x00B7, //56 #MIDDLE DOT
+0x00B8, //57 #CEDILLA
+0x0105, //58 #LATIN SMALL LETTER A WITH OGONEK
+0x015F, //59 #LATIN SMALL LETTER S WITH CEDILLA
+0x00BB, //60 #RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK
+0x013D, //61 #LATIN CAPITAL LETTER L WITH CARON
+0x02DD, //62 #DOUBLE ACUTE ACCENT
+0x013E, //63 #LATIN SMALL LETTER L WITH CARON
+0x017C, //64 #LATIN SMALL LETTER Z WITH DOT ABOVE
+0x0154, //65 #LATIN CAPITAL LETTER R WITH ACUTE
+0x00C1, //66 #LATIN CAPITAL LETTER A WITH ACUTE
+0x00C2, //67 #LATIN CAPITAL LETTER A WITH CIRCUMFLEX
+0x0102, //68 #LATIN CAPITAL LETTER A WITH BREVE
+0x00C4, //69 #LATIN CAPITAL LETTER A WITH DIAERESIS
+0x0139, //70 #LATIN CAPITAL LETTER L WITH ACUTE
+0x0106, //71 #LATIN CAPITAL LETTER C WITH ACUTE
+0x00C7, //72 #LATIN CAPITAL LETTER C WITH CEDILLA
+0x010C, //73 #LATIN CAPITAL LETTER C WITH CARON
+0x00C9, //74 #LATIN CAPITAL LETTER E WITH ACUTE
+0x0118, //75 #LATIN CAPITAL LETTER E WITH OGONEK
+0x00CB, //76 #LATIN CAPITAL LETTER E WITH DIAERESIS
+0x011A, //77 #LATIN CAPITAL LETTER E WITH CARON
+0x00CD, //78 #LATIN CAPITAL LETTER I WITH ACUTE
+0x00CE, //79 #LATIN CAPITAL LETTER I WITH CIRCUMFLEX
+0x010E, //80 #LATIN CAPITAL LETTER D WITH CARON
+0x0110, //81 #LATIN CAPITAL LETTER D WITH STROKE
+0x0143, //82 #LATIN CAPITAL LETTER N WITH ACUTE
+0x0147, //83 #LATIN CAPITAL LETTER N WITH CARON
+0x00D3, //84 #LATIN CAPITAL LETTER O WITH ACUTE
+0x00D4, //85 #LATIN CAPITAL LETTER O WITH CIRCUMFLEX
+0x0150, //86 #LATIN CAPITAL LETTER O WITH DOUBLE ACUTE
+0x00D6, //87 #LATIN CAPITAL LETTER O WITH DIAERESIS
+0x00D7, //88 #MULTIPLICATION SIGN
+0x0158, //89 #LATIN CAPITAL LETTER R WITH CARON
+0x016E, //90 #LATIN CAPITAL LETTER U WITH RING ABOVE
+0x00DA, //91 #LATIN CAPITAL LETTER U WITH ACUTE
+0x0170, //92 #LATIN CAPITAL LETTER U WITH DOUBLE ACUTE
+0x00DC, //93 #LATIN CAPITAL LETTER U WITH DIAERESIS
+0x00DD, //94 #LATIN CAPITAL LETTER Y WITH ACUTE
+0x0162, //95 #LATIN CAPITAL LETTER T WITH CEDILLA
+0x00DF, //96 #LATIN SMALL LETTER SHARP S
+0x0155, //97 #LATIN SMALL LETTER R WITH ACUTE
+0x00E1, //98 #LATIN SMALL LETTER A WITH ACUTE
+0x00E2, //99 #LATIN SMALL LETTER A WITH CIRCUMFLEX
+0x0103, //100 #LATIN SMALL LETTER A WITH BREVE
+0x00E4, //101 #LATIN SMALL LETTER A WITH DIAERESIS
+0x013A, //102 #LATIN SMALL LETTER L WITH ACUTE
+0x0107, //103 #LATIN SMALL LETTER C WITH ACUTE
+0x00E7, //104 #LATIN SMALL LETTER C WITH CEDILLA
+0x010D, //105 #LATIN SMALL LETTER C WITH CARON
+0x00E9, //106 #LATIN SMALL LETTER E WITH ACUTE
+0x0119, //107 #LATIN SMALL LETTER E WITH OGONEK
+0x00EB, //108 #LATIN SMALL LETTER E WITH DIAERESIS
+0x011B, //109 #LATIN SMALL LETTER E WITH CARON
+0x00ED, //110 #LATIN SMALL LETTER I WITH ACUTE
+0x00EE, //111 #LATIN SMALL LETTER I WITH CIRCUMFLEX
+0x010F, //112 #LATIN SMALL LETTER D WITH CARON
+0x0111, //113 #LATIN SMALL LETTER D WITH STROKE
+0x0144, //114 #LATIN SMALL LETTER N WITH ACUTE
+0x0148, //115 #LATIN SMALL LETTER N WITH CARON
+0x00F3, //116 #LATIN SMALL LETTER O WITH ACUTE
+0x00F4, //117 #LATIN SMALL LETTER O WITH CIRCUMFLEX
+0x0151, //118 #LATIN SMALL LETTER O WITH DOUBLE ACUTE
+0x00F6, //119 #LATIN SMALL LETTER O WITH DIAERESIS
+0x00F7, //120 #DIVISION SIGN
+0x0159, //121 #LATIN SMALL LETTER R WITH CARON
+0x016F, //122 #LATIN SMALL LETTER U WITH RING ABOVE
+0x00FA, //123 #LATIN SMALL LETTER U WITH ACUTE
+0x0171, //124 #LATIN SMALL LETTER U WITH DOUBLE ACUTE
+0x00FC, //125 #LATIN SMALL LETTER U WITH DIAERESIS
+0x00FD, //126 #LATIN SMALL LETTER Y WITH ACUTE
+0x0163, //127 #LATIN SMALL LETTER T WITH CEDILLA
+0x02D9 //128 #DOT ABOVE
+};
+
+
+//Table 1251
+static const int DRW_Table1251[] = {
+    0x0402, //1 #CYRILLIC CAPITAL LETTER DJE
+    0x0403, //2 #CYRILLIC CAPITAL LETTER GJE
+    0x201A, //3 #SINGLE LOW-9 QUOTATION MARK
+    0x0453, //4 #CYRILLIC SMALL LETTER GJE
+    0x201E, //5 #DOUBLE LOW-9 QUOTATION MARK
+    0x2026, //6 #HORIZONTAL ELLIPSIS
+    0x2020, //7 #DAGGER
+    0x2021, //8 #DOUBLE DAGGER
+    0x20AC, //9 #EURO SIGN
+    0x2030, //10 #PER MILLE SIGN
+    0x0409, //11 #CYRILLIC CAPITAL LETTER LJE
+    0x2039, //12 #SINGLE LEFT-POINTING ANGLE QUOTATION MARK
+    0x040A, //13 #CYRILLIC CAPITAL LETTER NJE
+    0x040C, //14 #CYRILLIC CAPITAL LETTER KJE
+    0x040B, //15 #CYRILLIC CAPITAL LETTER TSHE
+    0x040F, //16 #CYRILLIC CAPITAL LETTER DZHE
+    0x0452, //17 #CYRILLIC SMALL LETTER DJE
+    0x2018, //18 #LEFT SINGLE QUOTATION MARK
+    0x2019, //19 #RIGHT SINGLE QUOTATION MARK
+    0x201C, //20 #LEFT DOUBLE QUOTATION MARK
+    0x201D, //21 #RIGHT DOUBLE QUOTATION MARK
+    0x2022, //22 #BULLET
+    0x2013, //23 #EN DASH
+    0x2014, //24 #EM DASH
+    0x00,   //25 #UNDEFINED
+    0x2122, //26 #TRADE MARK SIGN
+    0x0459, //27 #CYRILLIC SMALL LETTER LJE
+    0x203A, //28 #SINGLE RIGHT-POINTING ANGLE QUOTATION MARK
+    0x045A, //29 #CYRILLIC SMALL LETTER NJE
+    0x045C, //30 #CYRILLIC SMALL LETTER KJE
+    0x045B, //31 #CYRILLIC SMALL LETTER TSHE
+    0x045F, //32 #CYRILLIC SMALL LETTER DZHE
+    0x00A0, //33 #NO-BREAK SPACE
+    0x040E, //34 #CYRILLIC CAPITAL LETTER SHORT U
+    0x045E, //35 #CYRILLIC SMALL LETTER SHORT U
+    0x0408, //36 #CYRILLIC CAPITAL LETTER JE
+    0x00A4, //37 #CURRENCY SIGN
+    0x0490, //38 #CYRILLIC CAPITAL LETTER GHE WITH UPTURN
+    0x00A6, //39 #BROKEN BAR
+    0x00A7, //40 #SECTION SIGN
+    0x0401, //41 #CYRILLIC CAPITAL LETTER IO
+    0x00A9, //42 #COPYRIGHT SIGN
+    0x0404, //43 #CYRILLIC CAPITAL LETTER UKRAINIAN IE
+    0x00AB, //44 #LEFT-POINTING DOUBLE ANGLE QUOTATION MARK
+    0x00AC, //45 #NOT SIGN
+    0x00AD, //46 #SOFT HYPHEN
+    0x00AE, //47 #REGISTERED SIGN
+    0x0407, //48 #CYRILLIC CAPITAL LETTER YI
+    0x00B0, //49 #DEGREE SIGN
+    0x00B1, //50 #PLUS-MINUS SIGN
+    0x0406, //51 #CYRILLIC CAPITAL LETTER BYELORUSSIAN-UKRAINIAN I
+    0x0456, //52 #CYRILLIC SMALL LETTER BYELORUSSIAN-UKRAINIAN I
+    0x0491, //53 #CYRILLIC SMALL LETTER GHE WITH UPTURN
+    0x00B5, //54 #MICRO SIGN
+    0x00B6, //55 #PILCROW SIGN
+    0x00B7, //56 #MIDDLE DOT
+    0x0451, //57 #CYRILLIC SMALL LETTER IO
+    0x2116, //58 #NUMERO SIGN
+    0x0454, //59 #CYRILLIC SMALL LETTER UKRAINIAN IE
+    0x00BB, //60 #RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK
+    0x0458, //61 #CYRILLIC SMALL LETTER JE
+    0x0405, //62 #CYRILLIC CAPITAL LETTER DZE
+    0x0455, //63 #CYRILLIC SMALL LETTER DZE
+    0x0457, //64 #CYRILLIC SMALL LETTER YI
+    0x0410, //65 #CYRILLIC CAPITAL LETTER A
+    0x0411, //66 #CYRILLIC CAPITAL LETTER BE
+    0x0412, //67 #CYRILLIC CAPITAL LETTER VE
+    0x0413, //68 #CYRILLIC CAPITAL LETTER GHE
+    0x0414, //69 #CYRILLIC CAPITAL LETTER DE
+    0x0415, //70 #CYRILLIC CAPITAL LETTER IE
+    0x0416, //71 #CYRILLIC CAPITAL LETTER ZHE
+    0x0417, //72 #CYRILLIC CAPITAL LETTER ZE
+    0x0418, //73 #CYRILLIC CAPITAL LETTER I
+    0x0419, //74 #CYRILLIC CAPITAL LETTER SHORT I
+    0x041A, //75 #CYRILLIC CAPITAL LETTER KA
+    0x041B, //76 #CYRILLIC CAPITAL LETTER EL
+    0x041C, //77 #CYRILLIC CAPITAL LETTER EM
+    0x041D, //78 #CYRILLIC CAPITAL LETTER EN
+    0x041E, //79 #CYRILLIC CAPITAL LETTER O
+    0x041F, //80 #CYRILLIC CAPITAL LETTER PE
+    0x0420, //81 #CYRILLIC CAPITAL LETTER ER
+    0x0421, //82 #CYRILLIC CAPITAL LETTER ES
+    0x0422, //83 #CYRILLIC CAPITAL LETTER TE
+    0x0423, //84 #CYRILLIC CAPITAL LETTER U
+    0x0424, //85 #CYRILLIC CAPITAL LETTER EF
+    0x0425, //86 #CYRILLIC CAPITAL LETTER HA
+    0x0426, //87 #CYRILLIC CAPITAL LETTER TSE
+    0x0427, //88 #CYRILLIC CAPITAL LETTER CHE
+    0x0428, //89 #CYRILLIC CAPITAL LETTER SHA
+    0x0429, //90 #CYRILLIC CAPITAL LETTER SHCHA
+    0x042A, //91 #CYRILLIC CAPITAL LETTER HARD SIGN
+    0x042B, //92 #CYRILLIC CAPITAL LETTER YERU
+    0x042C, //93 #CYRILLIC CAPITAL LETTER SOFT SIGN
+    0x042D, //94 #CYRILLIC CAPITAL LETTER E
+    0x042E, //95 #CYRILLIC CAPITAL LETTER YU
+    0x042F, //96 #CYRILLIC CAPITAL LETTER YA
+    0x0430, //97 #CYRILLIC SMALL LETTER A
+    0x0431, //98 #CYRILLIC SMALL LETTER BE
+    0x0432, //99 #CYRILLIC SMALL LETTER VE
+    0x0433, //100 #CYRILLIC SMALL LETTER GHE
+    0x0434, //101 #CYRILLIC SMALL LETTER DE
+    0x0435, //102 #CYRILLIC SMALL LETTER IE
+    0x0436, //103 #CYRILLIC SMALL LETTER ZHE
+    0x0437, //104 #CYRILLIC SMALL LETTER ZE
+    0x0438, //105 #CYRILLIC SMALL LETTER I
+    0x0439, //106 #CYRILLIC SMALL LETTER SHORT I
+    0x043A, //107 #CYRILLIC SMALL LETTER KA
+    0x043B, //108 #CYRILLIC SMALL LETTER EL
+    0x043C, //109 #CYRILLIC SMALL LETTER EM
+    0x043D, //110 #CYRILLIC SMALL LETTER EN
+    0x043E, //111 #CYRILLIC SMALL LETTER O
+    0x043F, //112 #CYRILLIC SMALL LETTER PE
+    0x0440, //113 #CYRILLIC SMALL LETTER ER
+    0x0441, //114 #CYRILLIC SMALL LETTER ES
+    0x0442, //115 #CYRILLIC SMALL LETTER TE
+    0x0443, //116 #CYRILLIC SMALL LETTER U
+    0x0444, //117 #CYRILLIC SMALL LETTER EF
+    0x0445, //118 #CYRILLIC SMALL LETTER HA
+    0x0446, //119 #CYRILLIC SMALL LETTER TSE
+    0x0447, //120 #CYRILLIC SMALL LETTER CHE
+    0x0448, //121 #CYRILLIC SMALL LETTER SHA
+    0x0449, //122 #CYRILLIC SMALL LETTER SHCHA
+    0x044A, //123 #CYRILLIC SMALL LETTER HARD SIGN
+    0x044B, //124 #CYRILLIC SMALL LETTER YERU
+    0x044C, //125 #CYRILLIC SMALL LETTER SOFT SIGN
+    0x044D, //126 #CYRILLIC SMALL LETTER E
+    0x044E, //127 #CYRILLIC SMALL LETTER YU
+    0x044F  //128 #CYRILLIC SMALL LETTER YA
+};
+
+
+//Table 1252
+static const int DRW_Table1252[] = {
+    0x20AC, //1 #EURO SIGN
+    0x00,   //2 #UNDEFINED
+    0x201A, //3 #SINGLE LOW-9 QUOTATION MARK
+    0x0192, //4 #LATIN SMALL LETTER F WITH HOOK
+    0x201E, //5 #DOUBLE LOW-9 QUOTATION MARK
+    0x2026, //6 #HORIZONTAL ELLIPSIS
+    0x2020, //7 #DAGGER
+    0x2021, //8 #DOUBLE DAGGER
+    0x02C6, //9 #MODIFIER LETTER CIRCUMFLEX ACCENT
+    0x2030, //10 #PER MILLE SIGN
+    0x0160, //11 #LATIN CAPITAL LETTER S WITH CARON
+    0x2039, //12 #SINGLE LEFT-POINTING ANGLE QUOTATION MARK
+    0x0152, //13 #LATIN CAPITAL LIGATURE OE
+    0x00,   //14 #UNDEFINED
+    0x017D, //15 #LATIN CAPITAL LETTER Z WITH CARON
+    0x00,   //16 #UNDEFINED
+    0x00,   //17 #UNDEFINED
+    0x2018, //18 #LEFT SINGLE QUOTATION MARK
+    0x2019, //19 #RIGHT SINGLE QUOTATION MARK
+    0x201C, //20 #LEFT DOUBLE QUOTATION MARK
+    0x201D, //21 #RIGHT DOUBLE QUOTATION MARK
+    0x2022, //22 #BULLET
+    0x2013, //23 #EN DASH
+    0x2014, //24 #EM DASH
+    0x02DC, //25 #SMALL TILDE
+    0x2122, //26 #TRADE MARK SIGN
+    0x0161, //27 #LATIN SMALL LETTER S WITH CARON
+    0x203A, //28 #SINGLE RIGHT-POINTING ANGLE QUOTATION MARK
+    0x0153, //29 #LATIN SMALL LIGATURE OE
+    0x00,   //30 #UNDEFINED
+    0x017E, //31 #LATIN SMALL LETTER Z WITH CARON
+    0x0178, //32 #LATIN CAPITAL LETTER Y WITH DIAERESIS
+    0x00A0, //33 #NO-BREAK SPACE
+    0x00A1, //34 #INVERTED EXCLAMATION MARK
+    0x00A2, //35 #CENT SIGN
+    0x00A3, //36 #POUND SIGN
+    0x00A4, //37 #CURRENCY SIGN
+    0x00A5, //38 #YEN SIGN
+    0x00A6, //39 #BROKEN BAR
+    0x00A7, //40 #SECTION SIGN
+    0x00A8, //41 #DIAERESIS
+    0x00A9, //42 #COPYRIGHT SIGN
+    0x00AA, //43 #FEMININE ORDINAL INDICATOR
+    0x00AB, //44 #LEFT-POINTING DOUBLE ANGLE QUOTATION MARK
+    0x00AC, //45 #NOT SIGN
+    0x00AD, //46 #SOFT HYPHEN
+    0x00AE, //47 #REGISTERED SIGN
+    0x00AF, //48 #MACRON
+    0x00B0, //49 #DEGREE SIGN
+    0x00B1, //50 #PLUS-MINUS SIGN
+    0x00B2, //51 #SUPERSCRIPT TWO
+    0x00B3, //52 #SUPERSCRIPT THREE
+    0x00B4, //53 #ACUTE ACCENT
+    0x00B5, //54 #MICRO SIGN
+    0x00B6, //55 #PILCROW SIGN
+    0x00B7, //56 #MIDDLE DOT
+    0x00B8, //57 #CEDILLA
+    0x00B9, //58 #SUPERSCRIPT ONE
+    0x00BA, //59 #MASCULINE ORDINAL INDICATOR
+    0x00BB, //60 #RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK
+    0x00BC, //61 #VULGAR FRACTION ONE QUARTER
+    0x00BD, //62 #VULGAR FRACTION ONE HALF
+    0x00BE, //63 #VULGAR FRACTION THREE QUARTERS
+    0x00BF, //64 #INVERTED QUESTION MARK
+    0x00C0, //65 #LATIN CAPITAL LETTER A WITH GRAVE
+    0x00C1, //66 #LATIN CAPITAL LETTER A WITH ACUTE
+    0x00C2, //67 #LATIN CAPITAL LETTER A WITH CIRCUMFLEX
+    0x00C3, //68 #LATIN CAPITAL LETTER A WITH TILDE
+    0x00C4, //69 #LATIN CAPITAL LETTER A WITH DIAERESIS
+    0x00C5, //70 #LATIN CAPITAL LETTER A WITH RING ABOVE
+    0x00C6, //71 #LATIN CAPITAL LETTER AE
+    0x00C7, //72 #LATIN CAPITAL LETTER C WITH CEDILLA
+    0x00C8, //73 #LATIN CAPITAL LETTER E WITH GRAVE
+    0x00C9, //74 #LATIN CAPITAL LETTER E WITH ACUTE
+    0x00CA, //75 #LATIN CAPITAL LETTER E WITH CIRCUMFLEX
+    0x00CB, //76 #LATIN CAPITAL LETTER E WITH DIAERESIS
+    0x00CC, //77 #LATIN CAPITAL LETTER I WITH GRAVE
+    0x00CD, //78 #LATIN CAPITAL LETTER I WITH ACUTE
+    0x00CE, //79 #LATIN CAPITAL LETTER I WITH CIRCUMFLEX
+    0x00CF, //80 #LATIN CAPITAL LETTER I WITH DIAERESIS
+    0x00D0, //81 #LATIN CAPITAL LETTER ETH
+    0x00D1, //82 #LATIN CAPITAL LETTER N WITH TILDE
+    0x00D2, //83 #LATIN CAPITAL LETTER O WITH GRAVE
+    0x00D3, //84 #LATIN CAPITAL LETTER O WITH ACUTE
+    0x00D4, //85 #LATIN CAPITAL LETTER O WITH CIRCUMFLEX
+    0x00D5, //86 #LATIN CAPITAL LETTER O WITH TILDE
+    0x00D6, //87 #LATIN CAPITAL LETTER O WITH DIAERESIS
+    0x00D7, //88 #MULTIPLICATION SIGN
+    0x00D8, //89 #LATIN CAPITAL LETTER O WITH STROKE
+    0x00D9, //90 #LATIN CAPITAL LETTER U WITH GRAVE
+    0x00DA, //91 #LATIN CAPITAL LETTER U WITH ACUTE
+    0x00DB, //92 #LATIN CAPITAL LETTER U WITH CIRCUMFLEX
+    0x00DC, //93 #LATIN CAPITAL LETTER U WITH DIAERESIS
+    0x00DD, //94 #LATIN CAPITAL LETTER Y WITH ACUTE
+    0x00DE, //95 #LATIN CAPITAL LETTER THORN
+    0x00DF, //96 #LATIN SMALL LETTER SHARP S
+    0x00E0, //97 #LATIN SMALL LETTER A WITH GRAVE
+    0x00E1, //98 #LATIN SMALL LETTER A WITH ACUTE
+    0x00E2, //99 #LATIN SMALL LETTER A WITH CIRCUMFLEX
+    0x00E3, //100 #LATIN SMALL LETTER A WITH TILDE
+    0x00E4, //101 #LATIN SMALL LETTER A WITH DIAERESIS
+    0x00E5, //102 #LATIN SMALL LETTER A WITH RING ABOVE
+    0x00E6, //103 #LATIN SMALL LETTER AE
+    0x00E7, //104 #LATIN SMALL LETTER C WITH CEDILLA
+    0x00E8, //105 #LATIN SMALL LETTER E WITH GRAVE
+    0x00E9, //106 #LATIN SMALL LETTER E WITH ACUTE
+    0x00EA, //107 #LATIN SMALL LETTER E WITH CIRCUMFLEX
+    0x00EB, //108 #LATIN SMALL LETTER E WITH DIAERESIS
+    0x00EC, //109 #LATIN SMALL LETTER I WITH GRAVE
+    0x00ED, //110 #LATIN SMALL LETTER I WITH ACUTE
+    0x00EE, //111 #LATIN SMALL LETTER I WITH CIRCUMFLEX
+    0x00EF, //112 #LATIN SMALL LETTER I WITH DIAERESIS
+    0x00F0, //113 #LATIN SMALL LETTER ETH
+    0x00F1, //114 #LATIN SMALL LETTER N WITH TILDE
+    0x00F2, //115 #LATIN SMALL LETTER O WITH GRAVE
+    0x00F3, //116 #LATIN SMALL LETTER O WITH ACUTE
+    0x00F4, //117 #LATIN SMALL LETTER O WITH CIRCUMFLEX
+    0x00F5, //118 #LATIN SMALL LETTER O WITH TILDE
+    0x00F6, //119 #LATIN SMALL LETTER O WITH DIAERESIS
+    0x00F7, //120 #DIVISION SIGN
+    0x00F8, //121 #LATIN SMALL LETTER O WITH STROKE
+    0x00F9, //122 #LATIN SMALL LETTER U WITH GRAVE
+    0x00FA, //123 #LATIN SMALL LETTER U WITH ACUTE
+    0x00FB, //124 #LATIN SMALL LETTER U WITH CIRCUMFLEX
+    0x00FC, //125 #LATIN SMALL LETTER U WITH DIAERESIS
+    0x00FD, //126 #LATIN SMALL LETTER Y WITH ACUTE
+    0x00FE, //127 #LATIN SMALL LETTER THORN
+    0x00FF  //128 #LATIN SMALL LETTER Y WITH DIAERESIS
+};
+
+//Table 1253
+static const int DRW_Table1253[] = {
+    0x20AC, //1 #EURO SIGN
+    0x00  , //2 #UNDEFINED
+    0x201A, //3 #SINGLE LOW-9 QUOTATION MARK
+    0x0192, //4 #LATIN SMALL LETTER F WITH HOOK
+    0x201E, //5 #DOUBLE LOW-9 QUOTATION MARK
+    0x2026, //6 #HORIZONTAL ELLIPSIS
+    0x2020, //7 #DAGGER
+    0x2021, //8 #DOUBLE DAGGER
+    0x00  , //9 #UNDEFINED
+    0x2030, //10 #PER MILLE SIGN
+    0x00  , //11 #UNDEFINED
+    0x2039, //12 #SINGLE LEFT-POINTING ANGLE QUOTATION MARK
+    0x00  , //13 #UNDEFINED
+    0x00  , //14 #UNDEFINED
+    0x00  , //15 #UNDEFINED
+    0x00  , //16 #UNDEFINED
+    0x00  , //17 #UNDEFINED
+    0x2018, //18 #LEFT SINGLE QUOTATION MARK
+    0x2019, //19 #RIGHT SINGLE QUOTATION MARK
+    0x201C, //20 #LEFT DOUBLE QUOTATION MARK
+    0x201D, //21 #RIGHT DOUBLE QUOTATION MARK
+    0x2022, //22 #BULLET
+    0x2013, //23 #EN DASH
+    0x2014, //24 #EM DASH
+    0x00  , //25 #UNDEFINED
+    0x2122, //26 #TRADE MARK SIGN
+    0x00  , //27 #UNDEFINED
+    0x203A, //28 #SINGLE RIGHT-POINTING ANGLE QUOTATION MARK
+    0x00  , //29 #UNDEFINED
+    0x00  , //30 #UNDEFINED
+    0x00  , //31 #UNDEFINED
+    0x00  , //32 #UNDEFINED
+    0x00A0, //33 #NO-BREAK SPACE
+    0x0385, //34 #GREEK DIALYTIKA TONOS
+    0x0386, //35 #GREEK CAPITAL LETTER ALPHA WITH TONOS
+    0x00A3, //36 #POUND SIGN
+    0x00A4, //37 #CURRENCY SIGN
+    0x00A5, //38 #YEN SIGN
+    0x00A6, //39 #BROKEN BAR
+    0x00A7, //40 #SECTION SIGN
+    0x00A8, //41 #DIAERESIS
+    0x00A9, //42 #COPYRIGHT SIGN
+    0x00  , //43 #UNDEFINED
+    0x00AB, //44 #LEFT-POINTING DOUBLE ANGLE QUOTATION MARK
+    0x00AC, //45 #NOT SIGN
+    0x00AD, //46 #SOFT HYPHEN
+    0x00AE, //47 #REGISTERED SIGN
+    0x2015, //48 #HORIZONTAL BAR
+    0x00B0, //49 #DEGREE SIGN
+    0x00B1, //50 #PLUS-MINUS SIGN
+    0x00B2, //51 #SUPERSCRIPT TWO
+    0x00B3, //52 #SUPERSCRIPT THREE
+    0x0384, //53 #GREEK TONOS
+    0x00B5, //54 #MICRO SIGN
+    0x00B6, //55 #PILCROW SIGN
+    0x00B7, //56 #MIDDLE DOT
+    0x0388, //57 #GREEK CAPITAL LETTER EPSILON WITH TONOS
+    0x0389, //58 #GREEK CAPITAL LETTER ETA WITH TONOS
+    0x038A, //59 #GREEK CAPITAL LETTER IOTA WITH TONOS
+    0x00BB, //60 #RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK
+    0x038C, //61 #GREEK CAPITAL LETTER OMICRON WITH TONOS
+    0x00BD, //62 #VULGAR FRACTION ONE HALF
+    0x038E, //63 #GREEK CAPITAL LETTER UPSILON WITH TONOS
+    0x038F, //64 #GREEK CAPITAL LETTER OMEGA WITH TONOS
+    0x0390, //65 #GREEK SMALL LETTER IOTA WITH DIALYTIKA AND TONOS
+    0x0391, //66 #GREEK CAPITAL LETTER ALPHA
+    0x0392, //67 #GREEK CAPITAL LETTER BETA
+    0x0393, //68 #GREEK CAPITAL LETTER GAMMA
+    0x0394, //69 #GREEK CAPITAL LETTER DELTA
+    0x0395, //70 #GREEK CAPITAL LETTER EPSILON
+    0x0396, //71 #GREEK CAPITAL LETTER ZETA
+    0x0397, //72 #GREEK CAPITAL LETTER ETA
+    0x0398, //73 #GREEK CAPITAL LETTER THETA
+    0x0399, //74 #GREEK CAPITAL LETTER IOTA
+    0x039A, //75 #GREEK CAPITAL LETTER KAPPA
+    0x039B, //76 #GREEK CAPITAL LETTER LAMDA
+    0x039C, //77 #GREEK CAPITAL LETTER MU
+    0x039D, //78 #GREEK CAPITAL LETTER NU
+    0x039E, //79 #GREEK CAPITAL LETTER XI
+    0x039F, //80 #GREEK CAPITAL LETTER OMICRON
+    0x03A0, //81 #GREEK CAPITAL LETTER PI
+    0x03A1, //82 #GREEK CAPITAL LETTER RHO
+    0x00  , //83 #UNDEFINED
+    0x03A3, //84 #GREEK CAPITAL LETTER SIGMA
+    0x03A4, //85 #GREEK CAPITAL LETTER TAU
+    0x03A5, //86 #GREEK CAPITAL LETTER UPSILON
+    0x03A6, //87 #GREEK CAPITAL LETTER PHI
+    0x03A7, //88 #GREEK CAPITAL LETTER CHI
+    0x03A8, //89 #GREEK CAPITAL LETTER PSI
+    0x03A9, //90 #GREEK CAPITAL LETTER OMEGA
+    0x03AA, //91 #GREEK CAPITAL LETTER IOTA WITH DIALYTIKA
+    0x03AB, //92 #GREEK CAPITAL LETTER UPSILON WITH DIALYTIKA
+    0x03AC, //93 #GREEK SMALL LETTER ALPHA WITH TONOS
+    0x03AD, //94 #GREEK SMALL LETTER EPSILON WITH TONOS
+    0x03AE, //95 #GREEK SMALL LETTER ETA WITH TONOS
+    0x03AF, //96 #GREEK SMALL LETTER IOTA WITH TONOS
+    0x03B0, //97 #GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND TONOS
+    0x03B1, //98 #GREEK SMALL LETTER ALPHA
+    0x03B2, //99 #GREEK SMALL LETTER BETA
+    0x03B3, //100 #GREEK SMALL LETTER GAMMA
+    0x03B4, //101 #GREEK SMALL LETTER DELTA
+    0x03B5, //102 #GREEK SMALL LETTER EPSILON
+    0x03B6, //103 #GREEK SMALL LETTER ZETA
+    0x03B7, //104 #GREEK SMALL LETTER ETA
+    0x03B8, //105 #GREEK SMALL LETTER THETA
+    0x03B9, //106 #GREEK SMALL LETTER IOTA
+    0x03BA, //107 #GREEK SMALL LETTER KAPPA
+    0x03BB, //108 #GREEK SMALL LETTER LAMDA
+    0x03BC, //109 #GREEK SMALL LETTER MU
+    0x03BD, //110 #GREEK SMALL LETTER NU
+    0x03BE, //111 #GREEK SMALL LETTER XI
+    0x03BF, //112 #GREEK SMALL LETTER OMICRON
+    0x03C0, //113 #GREEK SMALL LETTER PI
+    0x03C1, //114 #GREEK SMALL LETTER RHO
+    0x03C2, //115 #GREEK SMALL LETTER FINAL SIGMA
+    0x03C3, //116 #GREEK SMALL LETTER SIGMA
+    0x03C4, //117 #GREEK SMALL LETTER TAU
+    0x03C5, //118 #GREEK SMALL LETTER UPSILON
+    0x03C6, //119 #GREEK SMALL LETTER PHI
+    0x03C7, //120 #GREEK SMALL LETTER CHI
+    0x03C8, //121 #GREEK SMALL LETTER PSI
+    0x03C9, //122 #GREEK SMALL LETTER OMEGA
+    0x03CA, //123 #GREEK SMALL LETTER IOTA WITH DIALYTIKA
+    0x03CB, //124 #GREEK SMALL LETTER UPSILON WITH DIALYTIKA
+    0x03CC, //125 #GREEK SMALL LETTER OMICRON WITH TONOS
+    0x03CD, //126 #GREEK SMALL LETTER UPSILON WITH TONOS
+    0x03CE, //127 #GREEK SMALL LETTER OMEGA WITH TONOS
+    0x00    //128 #UNDEFINED
+};
+
+//Table 1254
+static const int DRW_Table1254[] = {
+    0x20AC, //1 #EURO SIGN
+    0x00  , //2 #UNDEFINED
+    0x201A, //3 #SINGLE LOW-9 QUOTATION MARK
+    0x0192, //4 #LATIN SMALL LETTER F WITH HOOK
+    0x201E, //5 #DOUBLE LOW-9 QUOTATION MARK
+    0x2026, //6 #HORIZONTAL ELLIPSIS
+    0x2020, //7 #DAGGER
+    0x2021, //8 #DOUBLE DAGGER
+    0x02C6, //9 #MODIFIER LETTER CIRCUMFLEX ACCENT
+    0x2030, //10 #PER MILLE SIGN
+    0x0160, //11 #LATIN CAPITAL LETTER S WITH CARON
+    0x2039, //12 #SINGLE LEFT-POINTING ANGLE QUOTATION MARK
+    0x0152, //13 #LATIN CAPITAL LIGATURE OE
+    0x00  , //14 #UNDEFINED
+    0x00  , //15 #UNDEFINED
+    0x00  , //16 #UNDEFINED
+    0x00  , //17 #UNDEFINED
+    0x2018, //18 #LEFT SINGLE QUOTATION MARK
+    0x2019, //19 #RIGHT SINGLE QUOTATION MARK
+    0x201C, //20 #LEFT DOUBLE QUOTATION MARK
+    0x201D, //21 #RIGHT DOUBLE QUOTATION MARK
+    0x2022, //22 #BULLET
+    0x2013, //23 #EN DASH
+    0x2014, //24 #EM DASH
+    0x02DC, //25 #SMALL TILDE
+    0x2122, //26 #TRADE MARK SIGN
+    0x0161, //27 #LATIN SMALL LETTER S WITH CARON
+    0x203A, //28 #SINGLE RIGHT-POINTING ANGLE QUOTATION MARK
+    0x0153, //29 #LATIN SMALL LIGATURE OE
+    0x00  , //30 #UNDEFINED
+    0x00  , //31 #UNDEFINED
+    0x0178, //32 #LATIN CAPITAL LETTER Y WITH DIAERESIS
+    0x00A0, //33 #NO-BREAK SPACE
+    0x00A1, //34 #INVERTED EXCLAMATION MARK
+    0x00A2, //35 #CENT SIGN
+    0x00A3, //36 #POUND SIGN
+    0x00A4, //37 #CURRENCY SIGN
+    0x00A5, //38 #YEN SIGN
+    0x00A6, //39 #BROKEN BAR
+    0x00A7, //40 #SECTION SIGN
+    0x00A8, //41 #DIAERESIS
+    0x00A9, //42 #COPYRIGHT SIGN
+    0x00AA, //43 #FEMININE ORDINAL INDICATOR
+    0x00AB, //44 #LEFT-POINTING DOUBLE ANGLE QUOTATION MARK
+    0x00AC, //45 #NOT SIGN
+    0x00AD, //46 #SOFT HYPHEN
+    0x00AE, //47 #REGISTERED SIGN
+    0x00AF, //48 #MACRON
+    0x00B0, //49 #DEGREE SIGN
+    0x00B1, //50 #PLUS-MINUS SIGN
+    0x00B2, //51 #SUPERSCRIPT TWO
+    0x00B3, //52 #SUPERSCRIPT THREE
+    0x00B4, //53 #ACUTE ACCENT
+    0x00B5, //54 #MICRO SIGN
+    0x00B6, //55 #PILCROW SIGN
+    0x00B7, //56 #MIDDLE DOT
+    0x00B8, //57 #CEDILLA
+    0x00B9, //58 #SUPERSCRIPT ONE
+    0x00BA, //59 #MASCULINE ORDINAL INDICATOR
+    0x00BB, //60 #RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK
+    0x00BC, //61 #VULGAR FRACTION ONE QUARTER
+    0x00BD, //62 #VULGAR FRACTION ONE HALF
+    0x00BE, //63 #VULGAR FRACTION THREE QUARTERS
+    0x00BF, //64 #INVERTED QUESTION MARK
+    0x00C0, //65 #LATIN CAPITAL LETTER A WITH GRAVE
+    0x00C1, //66 #LATIN CAPITAL LETTER A WITH ACUTE
+    0x00C2, //67 #LATIN CAPITAL LETTER A WITH CIRCUMFLEX
+    0x00C3, //68 #LATIN CAPITAL LETTER A WITH TILDE
+    0x00C4, //69 #LATIN CAPITAL LETTER A WITH DIAERESIS
+    0x00C5, //70 #LATIN CAPITAL LETTER A WITH RING ABOVE
+    0x00C6, //71 #LATIN CAPITAL LETTER AE
+    0x00C7, //72 #LATIN CAPITAL LETTER C WITH CEDILLA
+    0x00C8, //73 #LATIN CAPITAL LETTER E WITH GRAVE
+    0x00C9, //74 #LATIN CAPITAL LETTER E WITH ACUTE
+    0x00CA, //75 #LATIN CAPITAL LETTER E WITH CIRCUMFLEX
+    0x00CB, //76 #LATIN CAPITAL LETTER E WITH DIAERESIS
+    0x00CC, //77 #LATIN CAPITAL LETTER I WITH GRAVE
+    0x00CD, //78 #LATIN CAPITAL LETTER I WITH ACUTE
+    0x00CE, //79 #LATIN CAPITAL LETTER I WITH CIRCUMFLEX
+    0x00CF, //80 #LATIN CAPITAL LETTER I WITH DIAERESIS
+    0x011E, //81 #LATIN CAPITAL LETTER G WITH BREVE
+    0x00D1, //82 #LATIN CAPITAL LETTER N WITH TILDE
+    0x00D2, //83 #LATIN CAPITAL LETTER O WITH GRAVE
+    0x00D3, //84 #LATIN CAPITAL LETTER O WITH ACUTE
+    0x00D4, //85 #LATIN CAPITAL LETTER O WITH CIRCUMFLEX
+    0x00D5, //86 #LATIN CAPITAL LETTER O WITH TILDE
+    0x00D6, //87 #LATIN CAPITAL LETTER O WITH DIAERESIS
+    0x00D7, //88 #MULTIPLICATION SIGN
+    0x00D8, //89 #LATIN CAPITAL LETTER O WITH STROKE
+    0x00D9, //90 #LATIN CAPITAL LETTER U WITH GRAVE
+    0x00DA, //91 #LATIN CAPITAL LETTER U WITH ACUTE
+    0x00DB, //92 #LATIN CAPITAL LETTER U WITH CIRCUMFLEX
+    0x00DC, //93 #LATIN CAPITAL LETTER U WITH DIAERESIS
+    0x0130, //94 #LATIN CAPITAL LETTER I WITH DOT ABOVE
+    0x015E, //95 #LATIN CAPITAL LETTER S WITH CEDILLA
+    0x00DF, //96 #LATIN SMALL LETTER SHARP S
+    0x00E0, //97 #LATIN SMALL LETTER A WITH GRAVE
+    0x00E1, //98 #LATIN SMALL LETTER A WITH ACUTE
+    0x00E2, //99 #LATIN SMALL LETTER A WITH CIRCUMFLEX
+    0x00E3, //100 #LATIN SMALL LETTER A WITH TILDE
+    0x00E4, //101 #LATIN SMALL LETTER A WITH DIAERESIS
+    0x00E5, //102 #LATIN SMALL LETTER A WITH RING ABOVE
+    0x00E6, //103 #LATIN SMALL LETTER AE
+    0x00E7, //104 #LATIN SMALL LETTER C WITH CEDILLA
+    0x00E8, //105 #LATIN SMALL LETTER E WITH GRAVE
+    0x00E9, //106 #LATIN SMALL LETTER E WITH ACUTE
+    0x00EA, //107 #LATIN SMALL LETTER E WITH CIRCUMFLEX
+    0x00EB, //108 #LATIN SMALL LETTER E WITH DIAERESIS
+    0x00EC, //109 #LATIN SMALL LETTER I WITH GRAVE
+    0x00ED, //110 #LATIN SMALL LETTER I WITH ACUTE
+    0x00EE, //111 #LATIN SMALL LETTER I WITH CIRCUMFLEX
+    0x00EF, //112 #LATIN SMALL LETTER I WITH DIAERESIS
+    0x011F, //113 #LATIN SMALL LETTER G WITH BREVE
+    0x00F1, //114 #LATIN SMALL LETTER N WITH TILDE
+    0x00F2, //115 #LATIN SMALL LETTER O WITH GRAVE
+    0x00F3, //116 #LATIN SMALL LETTER O WITH ACUTE
+    0x00F4, //117 #LATIN SMALL LETTER O WITH CIRCUMFLEX
+    0x00F5, //118 #LATIN SMALL LETTER O WITH TILDE
+    0x00F6, //119 #LATIN SMALL LETTER O WITH DIAERESIS
+    0x00F7, //120 #DIVISION SIGN
+    0x00F8, //121 #LATIN SMALL LETTER O WITH STROKE
+    0x00F9, //122 #LATIN SMALL LETTER U WITH GRAVE
+    0x00FA, //123 #LATIN SMALL LETTER U WITH ACUTE
+    0x00FB, //124 #LATIN SMALL LETTER U WITH CIRCUMFLEX
+    0x00FC, //125 #LATIN SMALL LETTER U WITH DIAERESIS
+    0x0131, //126 #LATIN SMALL LETTER DOTLESS I
+    0x015F, //127 #LATIN SMALL LETTER S WITH CEDILLA
+    0x00FF //128 #LATIN SMALL LETTER Y WITH DIAERESIS
+};
+
+//Table 1255
+static const int DRW_Table1255[] = {
+    0x20AC, //1 #EURO SIGN
+    0x00  , //2 #UNDEFINED
+    0x201A, //3 #SINGLE LOW-9 QUOTATION MARK
+    0x0192, //4 #LATIN SMALL LETTER F WITH HOOK
+    0x201E, //5 #DOUBLE LOW-9 QUOTATION MARK
+    0x2026, //6 #HORIZONTAL ELLIPSIS
+    0x2020, //7 #DAGGER
+    0x2021, //8 #DOUBLE DAGGER
+    0x02C6, //9 #MODIFIER LETTER CIRCUMFLEX ACCENT
+    0x2030, //10 #PER MILLE SIGN
+    0x00  , //11 #UNDEFINED
+    0x2039, //12 #SINGLE LEFT-POINTING ANGLE QUOTATION MARK
+    0x00  , //13 #UNDEFINED
+    0x00  , //14 #UNDEFINED
+    0x00  , //15 #UNDEFINED
+    0x00  , //16 #UNDEFINED
+    0x00  , //17 #UNDEFINED
+    0x2018, //18 #LEFT SINGLE QUOTATION MARK
+    0x2019, //19 #RIGHT SINGLE QUOTATION MARK
+    0x201C, //20 #LEFT DOUBLE QUOTATION MARK
+    0x201D, //21 #RIGHT DOUBLE QUOTATION MARK
+    0x2022, //22 #BULLET
+    0x2013, //23 #EN DASH
+    0x2014, //24 #EM DASH
+    0x02DC, //25 #SMALL TILDE
+    0x2122, //26 #TRADE MARK SIGN
+    0x00  , //27 #UNDEFINED
+    0x203A, //28 #SINGLE RIGHT-POINTING ANGLE QUOTATION MARK
+    0x00  , //29 #UNDEFINED
+    0x00  , //30 #UNDEFINED
+    0x00  , //31 #UNDEFINED
+    0x00  , //32 #UNDEFINED
+    0x00A0, //33 #NO-BREAK SPACE
+    0x00A1, //34 #INVERTED EXCLAMATION MARK
+    0x00A2, //35 #CENT SIGN
+    0x00A3, //36 #POUND SIGN
+    0x20AA, //37 #NEW SHEQEL SIGN
+    0x00A5, //38 #YEN SIGN
+    0x00A6, //39 #BROKEN BAR
+    0x00A7, //40 #SECTION SIGN
+    0x00A8, //41 #DIAERESIS
+    0x00A9, //42 #COPYRIGHT SIGN
+    0x00D7, //43 #MULTIPLICATION SIGN
+    0x00AB, //44 #LEFT-POINTING DOUBLE ANGLE QUOTATION MARK
+    0x00AC, //45 #NOT SIGN
+    0x00AD, //46 #SOFT HYPHEN
+    0x00AE, //47 #REGISTERED SIGN
+    0x00AF, //48 #MACRON
+    0x00B0, //49 #DEGREE SIGN
+    0x00B1, //50 #PLUS-MINUS SIGN
+    0x00B2, //51 #SUPERSCRIPT TWO
+    0x00B3, //52 #SUPERSCRIPT THREE
+    0x00B4, //53 #ACUTE ACCENT
+    0x00B5, //54 #MICRO SIGN
+    0x00B6, //55 #PILCROW SIGN
+    0x00B7, //56 #MIDDLE DOT
+    0x00B8, //57 #CEDILLA
+    0x00B9, //58 #SUPERSCRIPT ONE
+    0x00F7, //59 #DIVISION SIGN
+    0x00BB, //60 #RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK
+    0x00BC, //61 #VULGAR FRACTION ONE QUARTER
+    0x00BD, //62 #VULGAR FRACTION ONE HALF
+    0x00BE, //63 #VULGAR FRACTION THREE QUARTERS
+    0x00BF, //64 #INVERTED QUESTION MARK
+    0x05B0, //65 #HEBREW POINT SHEVA
+    0x05B1, //66 #HEBREW POINT HATAF SEGOL
+    0x05B2, //67 #HEBREW POINT HATAF PATAH
+    0x05B3, //68 #HEBREW POINT HATAF QAMATS
+    0x05B4, //69 #HEBREW POINT HIRIQ
+    0x05B5, //70 #HEBREW POINT TSERE
+    0x05B6, //71 #HEBREW POINT SEGOL
+    0x05B7, //72 #HEBREW POINT PATAH
+    0x05B8, //73 #HEBREW POINT QAMATS
+    0x05B9, //74 #HEBREW POINT HOLAM
+    0x00  , //75 #UNDEFINED
+    0x05BB, //76 #HEBREW POINT QUBUTS
+    0x05BC, //77 #HEBREW POINT DAGESH OR MAPIQ
+    0x05BD, //78 #HEBREW POINT METEG
+    0x05BE, //79 #HEBREW PUNCTUATION MAQAF
+    0x05BF, //80 #HEBREW POINT RAFE
+    0x05C0, //81 #HEBREW PUNCTUATION PASEQ
+    0x05C1, //82 #HEBREW POINT SHIN DOT
+    0x05C2, //83 #HEBREW POINT SIN DOT
+    0x05C3, //84 #HEBREW PUNCTUATION SOF PASUQ
+    0x05F0, //85 #HEBREW LIGATURE YIDDISH DOUBLE VAV
+    0x05F1, //86 #HEBREW LIGATURE YIDDISH VAV YOD
+    0x05F2, //87 #HEBREW LIGATURE YIDDISH DOUBLE YOD
+    0x05F3, //88 #HEBREW PUNCTUATION GERESH
+    0x05F4, //89 #HEBREW PUNCTUATION GERSHAYIM
+    0x00  , //90 #UNDEFINED
+    0x00  , //91 #UNDEFINED
+    0x00  , //92 #UNDEFINED
+    0x00  , //93 #UNDEFINED
+    0x00  , //94 #UNDEFINED
+    0x00  , //95 #UNDEFINED
+    0x00  , //96 #UNDEFINED
+    0x05D0, //97 #HEBREW LETTER ALEF
+    0x05D1, //98 #HEBREW LETTER BET
+    0x05D2, //99 #HEBREW LETTER GIMEL
+    0x05D3, //100 #HEBREW LETTER DALET
+    0x05D4, //101 #HEBREW LETTER HE
+    0x05D5, //102 #HEBREW LETTER VAV
+    0x05D6, //103 #HEBREW LETTER ZAYIN
+    0x05D7, //104 #HEBREW LETTER HET
+    0x05D8, //105 #HEBREW LETTER TET
+    0x05D9, //106 #HEBREW LETTER YOD
+    0x05DA, //107 #HEBREW LETTER FINAL KAF
+    0x05DB, //108 #HEBREW LETTER KAF
+    0x05DC, //109 #HEBREW LETTER LAMED
+    0x05DD, //110 #HEBREW LETTER FINAL MEM
+    0x05DE, //111 #HEBREW LETTER MEM
+    0x05DF, //112 #HEBREW LETTER FINAL NUN
+    0x05E0, //113 #HEBREW LETTER NUN
+    0x05E1, //114 #HEBREW LETTER SAMEKH
+    0x05E2, //115 #HEBREW LETTER AYIN
+    0x05E3, //116 #HEBREW LETTER FINAL PE
+    0x05E4, //117 #HEBREW LETTER PE
+    0x05E5, //118 #HEBREW LETTER FINAL TSADI
+    0x05E6, //119 #HEBREW LETTER TSADI
+    0x05E7, //120 #HEBREW LETTER QOF
+    0x05E8, //121 #HEBREW LETTER RESH
+    0x05E9, //122 #HEBREW LETTER SHIN
+    0x05EA, //123 #HEBREW LETTER TAV
+    0x00  , //124 #UNDEFINED
+    0x00  , //125 #UNDEFINED
+    0x200E, //126 #LEFT-TO-RIGHT MARK
+    0x200F, //127 #RIGHT-TO-LEFT MARK
+    0x00    //128 #UNDEFINED
+};
+
+//Table 1256
+static const int DRW_Table1256[] = {
+    0x20AC, //1 #EURO SIGN
+    0x067E, //2 #ARABIC LETTER PEH
+    0x201A, //3 #SINGLE LOW-9 QUOTATION MARK
+    0x0192, //4 #LATIN SMALL LETTER F WITH HOOK
+    0x201E, //5 #DOUBLE LOW-9 QUOTATION MARK
+    0x2026, //6 #HORIZONTAL ELLIPSIS
+    0x2020, //7 #DAGGER
+    0x2021, //8 #DOUBLE DAGGER
+    0x02C6, //9 #MODIFIER LETTER CIRCUMFLEX ACCENT
+    0x2030, //10 #PER MILLE SIGN
+    0x0679, //11 #ARABIC LETTER TTEH
+    0x2039, //12 #SINGLE LEFT-POINTING ANGLE QUOTATION MARK
+    0x0152, //13 #LATIN CAPITAL LIGATURE OE
+    0x0686, //14 #ARABIC LETTER TCHEH
+    0x0698, //15 #ARABIC LETTER JEH
+    0x0688, //16 #ARABIC LETTER DDAL
+    0x06AF, //17 #ARABIC LETTER GAF
+    0x2018, //18 #LEFT SINGLE QUOTATION MARK
+    0x2019, //19 #RIGHT SINGLE QUOTATION MARK
+    0x201C, //20 #LEFT DOUBLE QUOTATION MARK
+    0x201D, //21 #RIGHT DOUBLE QUOTATION MARK
+    0x2022, //22 #BULLET
+    0x2013, //23 #EN DASH
+    0x2014, //24 #EM DASH
+    0x06A9, //25 #ARABIC LETTER KEHEH
+    0x2122, //26 #TRADE MARK SIGN
+    0x0691, //27 #ARABIC LETTER RREH
+    0x203A, //28 #SINGLE RIGHT-POINTING ANGLE QUOTATION MARK
+    0x0153, //29 #LATIN SMALL LIGATURE OE
+    0x200C, //30 #ZERO WIDTH NON-JOINER
+    0x200D, //31 #ZERO WIDTH JOINER
+    0x06BA, //32 #ARABIC LETTER NOON GHUNNA
+    0x00A0, //33 #NO-BREAK SPACE
+    0x060C, //34 #ARABIC COMMA
+    0x00A2, //35 #CENT SIGN
+    0x00A3, //36 #POUND SIGN
+    0x00A4, //37 #CURRENCY SIGN
+    0x00A5, //38 #YEN SIGN
+    0x00A6, //39 #BROKEN BAR
+    0x00A7, //40 #SECTION SIGN
+    0x00A8, //41 #DIAERESIS
+    0x00A9, //42 #COPYRIGHT SIGN
+    0x06BE, //43 #ARABIC LETTER HEH DOACHASHMEE
+    0x00AB, //44 #LEFT-POINTING DOUBLE ANGLE QUOTATION MARK
+    0x00AC, //45 #NOT SIGN
+    0x00AD, //46 #SOFT HYPHEN
+    0x00AE, //47 #REGISTERED SIGN
+    0x00AF, //48 #MACRON
+    0x00B0, //49 #DEGREE SIGN
+    0x00B1, //50 #PLUS-MINUS SIGN
+    0x00B2, //51 #SUPERSCRIPT TWO
+    0x00B3, //52 #SUPERSCRIPT THREE
+    0x00B4, //53 #ACUTE ACCENT
+    0x00B5, //54 #MICRO SIGN
+    0x00B6, //55 #PILCROW SIGN
+    0x00B7, //56 #MIDDLE DOT
+    0x00B8, //57 #CEDILLA
+    0x00B9, //58 #SUPERSCRIPT ONE
+    0x061B, //59 #ARABIC SEMICOLON
+    0x00BB, //60 #RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK
+    0x00BC, //61 #VULGAR FRACTION ONE QUARTER
+    0x00BD, //62 #VULGAR FRACTION ONE HALF
+    0x00BE, //63 #VULGAR FRACTION THREE QUARTERS
+    0x061F, //64 #ARABIC QUESTION MARK
+    0x06C1, //65 #ARABIC LETTER HEH GOAL
+    0x0621, //66 #ARABIC LETTER HAMZA
+    0x0622, //67 #ARABIC LETTER ALEF WITH MADDA ABOVE
+    0x0623, //68 #ARABIC LETTER ALEF WITH HAMZA ABOVE
+    0x0624, //69 #ARABIC LETTER WAW WITH HAMZA ABOVE
+    0x0625, //70 #ARABIC LETTER ALEF WITH HAMZA BELOW
+    0x0626, //71 #ARABIC LETTER YEH WITH HAMZA ABOVE
+    0x0627, //72 #ARABIC LETTER ALEF
+    0x0628, //73 #ARABIC LETTER BEH
+    0x0629, //74 #ARABIC LETTER TEH MARBUTA
+    0x062A, //75 #ARABIC LETTER TEH
+    0x062B, //76 #ARABIC LETTER THEH
+    0x062C, //77 #ARABIC LETTER JEEM
+    0x062D, //78 #ARABIC LETTER HAH
+    0x062E, //79 #ARABIC LETTER KHAH
+    0x062F, //80 #ARABIC LETTER DAL
+    0x0630, //81 #ARABIC LETTER THAL
+    0x0631, //82 #ARABIC LETTER REH
+    0x0632, //83 #ARABIC LETTER ZAIN
+    0x0633, //84 #ARABIC LETTER SEEN
+    0x0634, //85 #ARABIC LETTER SHEEN
+    0x0635, //86 #ARABIC LETTER SAD
+    0x0636, //87 #ARABIC LETTER DAD
+    0x00D7, //88 #MULTIPLICATION SIGN
+    0x0637, //89 #ARABIC LETTER TAH
+    0x0638, //90 #ARABIC LETTER ZAH
+    0x0639, //91 #ARABIC LETTER AIN
+    0x063A, //92 #ARABIC LETTER GHAIN
+    0x0640, //93 #ARABIC TATWEEL
+    0x0641, //94 #ARABIC LETTER FEH
+    0x0642, //95 #ARABIC LETTER QAF
+    0x0643, //96 #ARABIC LETTER KAF
+    0x00E0, //97 #LATIN SMALL LETTER A WITH GRAVE
+    0x0644, //98 #ARABIC LETTER LAM
+    0x00E2, //99 #LATIN SMALL LETTER A WITH CIRCUMFLEX
+    0x0645, //100 #ARABIC LETTER MEEM
+    0x0646, //101 #ARABIC LETTER NOON
+    0x0647, //102 #ARABIC LETTER HEH
+    0x0648, //103 #ARABIC LETTER WAW
+    0x00E7, //104 #LATIN SMALL LETTER C WITH CEDILLA
+    0x00E8, //105 #LATIN SMALL LETTER E WITH GRAVE
+    0x00E9, //106 #LATIN SMALL LETTER E WITH ACUTE
+    0x00EA, //107 #LATIN SMALL LETTER E WITH CIRCUMFLEX
+    0x00EB, //108 #LATIN SMALL LETTER E WITH DIAERESIS
+    0x0649, //109 #ARABIC LETTER ALEF MAKSURA
+    0x064A, //110 #ARABIC LETTER YEH
+    0x00EE, //111 #LATIN SMALL LETTER I WITH CIRCUMFLEX
+    0x00EF, //112 #LATIN SMALL LETTER I WITH DIAERESIS
+    0x064B, //113 #ARABIC FATHATAN
+    0x064C, //114 #ARABIC DAMMATAN
+    0x064D, //115 #ARABIC KASRATAN
+    0x064E, //116 #ARABIC FATHA
+    0x00F4, //117 #LATIN SMALL LETTER O WITH CIRCUMFLEX
+    0x064F, //118 #ARABIC DAMMA
+    0x0650, //119 #ARABIC KASRA
+    0x00F7, //120 #DIVISION SIGN
+    0x0651, //121 #ARABIC SHADDA
+    0x00F9, //122 #LATIN SMALL LETTER U WITH GRAVE
+    0x0652, //123 #ARABIC SUKUN
+    0x00FB, //124 #LATIN SMALL LETTER U WITH CIRCUMFLEX
+    0x00FC, //125 #LATIN SMALL LETTER U WITH DIAERESIS
+    0x200E, //126 #LEFT-TO-RIGHT MARK
+    0x200F, //127 #RIGHT-TO-LEFT MARK
+    0x06D2  //128 #ARABIC LETTER YEH BARREE
+};
+
+//Table 1257
+static const int DRW_Table1257[] = {
+    0x20AC, //1 #EURO SIGN
+    0x00  , //2 #UNDEFINED
+    0x201A, //3 #SINGLE LOW-9 QUOTATION MARK
+    0x00  , //4 #UNDEFINED
+    0x201E, //5 #DOUBLE LOW-9 QUOTATION MARK
+    0x2026, //6 #HORIZONTAL ELLIPSIS
+    0x2020, //7 #DAGGER
+    0x2021, //8 #DOUBLE DAGGER
+    0x00  , //9 #UNDEFINED
+    0x2030, //10 #PER MILLE SIGN
+    0x00  , //11 #UNDEFINED
+    0x2039, //12 #SINGLE LEFT-POINTING ANGLE QUOTATION MARK
+    0x00  , //13 #UNDEFINED
+    0x00A8, //14 #DIAERESIS
+    0x02C7, //15 #CARON
+    0x00B8, //16 #CEDILLA
+    0x00  , //17 #UNDEFINED
+    0x2018, //18 #LEFT SINGLE QUOTATION MARK
+    0x2019, //19 #RIGHT SINGLE QUOTATION MARK
+    0x201C, //20 #LEFT DOUBLE QUOTATION MARK
+    0x201D, //21 #RIGHT DOUBLE QUOTATION MARK
+    0x2022, //22 #BULLET
+    0x2013, //23 #EN DASH
+    0x2014, //24 #EM DASH
+    0x00  , //25 #UNDEFINED
+    0x2122, //26 #TRADE MARK SIGN
+    0x00  , //27 #UNDEFINED
+    0x203A, //28 #SINGLE RIGHT-POINTING ANGLE QUOTATION MARK
+    0x00  , //29 #UNDEFINED
+    0x00AF, //30 #MACRON
+    0x02DB, //31 #OGONEK
+    0x00  , //32 #UNDEFINED
+    0x00A0, //33 #NO-BREAK SPACE
+    0x00  , //34 #UNDEFINED
+    0x00A2, //35 #CENT SIGN
+    0x00A3, //36 #POUND SIGN
+    0x00A4, //37 #CURRENCY SIGN
+    0x00  , //38 #UNDEFINED
+    0x00A6, //39 #BROKEN BAR
+    0x00A7, //40 #SECTION SIGN
+    0x00D8, //41 #LATIN CAPITAL LETTER O WITH STROKE
+    0x00A9, //42 #COPYRIGHT SIGN
+    0x0156, //43 #LATIN CAPITAL LETTER R WITH CEDILLA
+    0x00AB, //44 #LEFT-POINTING DOUBLE ANGLE QUOTATION MARK
+    0x00AC, //45 #NOT SIGN
+    0x00AD, //46 #SOFT HYPHEN
+    0x00AE, //47 #REGISTERED SIGN
+    0x00C6, //48 #LATIN CAPITAL LETTER AE
+    0x00B0, //49 #DEGREE SIGN
+    0x00B1, //50 #PLUS-MINUS SIGN
+    0x00B2, //51 #SUPERSCRIPT TWO
+    0x00B3, //52 #SUPERSCRIPT THREE
+    0x00B4, //53 #ACUTE ACCENT
+    0x00B5, //54 #MICRO SIGN
+    0x00B6, //55 #PILCROW SIGN
+    0x00B7, //56 #MIDDLE DOT
+    0x00F8, //57 #LATIN SMALL LETTER O WITH STROKE
+    0x00B9, //58 #SUPERSCRIPT ONE
+    0x0157, //59 #LATIN SMALL LETTER R WITH CEDILLA
+    0x00BB, //60 #RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK
+    0x00BC, //61 #VULGAR FRACTION ONE QUARTER
+    0x00BD, //62 #VULGAR FRACTION ONE HALF
+    0x00BE, //63 #VULGAR FRACTION THREE QUARTERS
+    0x00E6, //64 #LATIN SMALL LETTER AE
+    0x0104, //65 #LATIN CAPITAL LETTER A WITH OGONEK
+    0x012E, //66 #LATIN CAPITAL LETTER I WITH OGONEK
+    0x0100, //67 #LATIN CAPITAL LETTER A WITH MACRON
+    0x0106, //68 #LATIN CAPITAL LETTER C WITH ACUTE
+    0x00C4, //69 #LATIN CAPITAL LETTER A WITH DIAERESIS
+    0x00C5, //70 #LATIN CAPITAL LETTER A WITH RING ABOVE
+    0x0118, //71 #LATIN CAPITAL LETTER E WITH OGONEK
+    0x0112, //72 #LATIN CAPITAL LETTER E WITH MACRON
+    0x010C, //73 #LATIN CAPITAL LETTER C WITH CARON
+    0x00C9, //74 #LATIN CAPITAL LETTER E WITH ACUTE
+    0x0179, //75 #LATIN CAPITAL LETTER Z WITH ACUTE
+    0x0116, //76 #LATIN CAPITAL LETTER E WITH DOT ABOVE
+    0x0122, //77 #LATIN CAPITAL LETTER G WITH CEDILLA
+    0x0136, //78 #LATIN CAPITAL LETTER K WITH CEDILLA
+    0x012A, //79 #LATIN CAPITAL LETTER I WITH MACRON
+    0x013B, //80 #LATIN CAPITAL LETTER L WITH CEDILLA
+    0x0160, //81 #LATIN CAPITAL LETTER S WITH CARON
+    0x0143, //82 #LATIN CAPITAL LETTER N WITH ACUTE
+    0x0145, //83 #LATIN CAPITAL LETTER N WITH CEDILLA
+    0x00D3, //84 #LATIN CAPITAL LETTER O WITH ACUTE
+    0x014C, //85 #LATIN CAPITAL LETTER O WITH MACRON
+    0x00D5, //86 #LATIN CAPITAL LETTER O WITH TILDE
+    0x00D6, //87 #LATIN CAPITAL LETTER O WITH DIAERESIS
+    0x00D7, //88 #MULTIPLICATION SIGN
+    0x0172, //89 #LATIN CAPITAL LETTER U WITH OGONEK
+    0x0141, //90 #LATIN CAPITAL LETTER L WITH STROKE
+    0x015A, //91 #LATIN CAPITAL LETTER S WITH ACUTE
+    0x016A, //92 #LATIN CAPITAL LETTER U WITH MACRON
+    0x00DC, //93 #LATIN CAPITAL LETTER U WITH DIAERESIS
+    0x017B, //94 #LATIN CAPITAL LETTER Z WITH DOT ABOVE
+    0x017D, //95 #LATIN CAPITAL LETTER Z WITH CARON
+    0x00DF, //96 #LATIN SMALL LETTER SHARP S
+    0x0105, //97 #LATIN SMALL LETTER A WITH OGONEK
+    0x012F, //98 #LATIN SMALL LETTER I WITH OGONEK
+    0x0101, //99 #LATIN SMALL LETTER A WITH MACRON
+    0x0107, //100 #LATIN SMALL LETTER C WITH ACUTE
+    0x00E4, //101 #LATIN SMALL LETTER A WITH DIAERESIS
+    0x00E5, //102 #LATIN SMALL LETTER A WITH RING ABOVE
+    0x0119, //103 #LATIN SMALL LETTER E WITH OGONEK
+    0x0113, //104 #LATIN SMALL LETTER E WITH MACRON
+    0x010D, //105 #LATIN SMALL LETTER C WITH CARON
+    0x00E9, //106 #LATIN SMALL LETTER E WITH ACUTE
+    0x017A, //107 #LATIN SMALL LETTER Z WITH ACUTE
+    0x0117, //108 #LATIN SMALL LETTER E WITH DOT ABOVE
+    0x0123, //109 #LATIN SMALL LETTER G WITH CEDILLA
+    0x0137, //110 #LATIN SMALL LETTER K WITH CEDILLA
+    0x012B, //111 #LATIN SMALL LETTER I WITH MACRON
+    0x013C, //112 #LATIN SMALL LETTER L WITH CEDILLA
+    0x0161, //113 #LATIN SMALL LETTER S WITH CARON
+    0x0144, //114 #LATIN SMALL LETTER N WITH ACUTE
+    0x0146, //115 #LATIN SMALL LETTER N WITH CEDILLA
+    0x00F3, //116 #LATIN SMALL LETTER O WITH ACUTE
+    0x014D, //117 #LATIN SMALL LETTER O WITH MACRON
+    0x00F5, //118 #LATIN SMALL LETTER O WITH TILDE
+    0x00F6, //119 #LATIN SMALL LETTER O WITH DIAERESIS
+    0x00F7, //120 #DIVISION SIGN
+    0x0173, //121 #LATIN SMALL LETTER U WITH OGONEK
+    0x0142, //122 #LATIN SMALL LETTER L WITH STROKE
+    0x015B, //123 #LATIN SMALL LETTER S WITH ACUTE
+    0x016B, //124 #LATIN SMALL LETTER U WITH MACRON
+    0x00FC, //125 #LATIN SMALL LETTER U WITH DIAERESIS
+    0x017C, //126 #LATIN SMALL LETTER Z WITH DOT ABOVE
+    0x017E, //127 #LATIN SMALL LETTER Z WITH CARON
+    0x02D9  //128 #DOT ABOVE
+};
+
+//Table 1258
+static const int DRW_Table1258[] = {
+    0x20AC, //1 #EURO SIGN
+    0x00  , //2 #UNDEFINED
+    0x201A, //3 #SINGLE LOW-9 QUOTATION MARK
+    0x0192, //4 #LATIN SMALL LETTER F WITH HOOK
+    0x201E, //5 #DOUBLE LOW-9 QUOTATION MARK
+    0x2026, //6 #HORIZONTAL ELLIPSIS
+    0x2020, //7 #DAGGER
+    0x2021, //8 #DOUBLE DAGGER
+    0x02C6, //9 #MODIFIER LETTER CIRCUMFLEX ACCENT
+    0x2030, //10 #PER MILLE SIGN
+    0x00  , //11 #UNDEFINED
+    0x2039, //12 #SINGLE LEFT-POINTING ANGLE QUOTATION MARK
+    0x0152, //13 #LATIN CAPITAL LIGATURE OE
+    0x00  , //14 #UNDEFINED
+    0x00  , //15 #UNDEFINED
+    0x00  , //16 #UNDEFINED
+    0x00  , //17 #UNDEFINED
+    0x2018, //18 #LEFT SINGLE QUOTATION MARK
+    0x2019, //19 #RIGHT SINGLE QUOTATION MARK
+    0x201C, //20 #LEFT DOUBLE QUOTATION MARK
+    0x201D, //21 #RIGHT DOUBLE QUOTATION MARK
+    0x2022, //22 #BULLET
+    0x2013, //23 #EN DASH
+    0x2014, //24 #EM DASH
+    0x02DC, //25 #SMALL TILDE
+    0x2122, //26 #TRADE MARK SIGN
+    0x00  , //27 #UNDEFINED
+    0x203A, //28 #SINGLE RIGHT-POINTING ANGLE QUOTATION MARK
+    0x0153, //29 #LATIN SMALL LIGATURE OE
+    0x00  , //30 #UNDEFINED
+    0x00  , //31 #UNDEFINED
+    0x0178, //32 #LATIN CAPITAL LETTER Y WITH DIAERESIS
+    0x00A0, //33 #NO-BREAK SPACE
+    0x00A1, //34 #INVERTED EXCLAMATION MARK
+    0x00A2, //35 #CENT SIGN
+    0x00A3, //36 #POUND SIGN
+    0x00A4, //37 #CURRENCY SIGN
+    0x00A5, //38 #YEN SIGN
+    0x00A6, //39 #BROKEN BAR
+    0x00A7, //40 #SECTION SIGN
+    0x00A8, //41 #DIAERESIS
+    0x00A9, //42 #COPYRIGHT SIGN
+    0x00AA, //43 #FEMININE ORDINAL INDICATOR
+    0x00AB, //44 #LEFT-POINTING DOUBLE ANGLE QUOTATION MARK
+    0x00AC, //45 #NOT SIGN
+    0x00AD, //46 #SOFT HYPHEN
+    0x00AE, //47 #REGISTERED SIGN
+    0x00AF, //48 #MACRON
+    0x00B0, //49 #DEGREE SIGN
+    0x00B1, //50 #PLUS-MINUS SIGN
+    0x00B2, //51 #SUPERSCRIPT TWO
+    0x00B3, //52 #SUPERSCRIPT THREE
+    0x00B4, //53 #ACUTE ACCENT
+    0x00B5, //54 #MICRO SIGN
+    0x00B6, //55 #PILCROW SIGN
+    0x00B7, //56 #MIDDLE DOT
+    0x00B8, //57 #CEDILLA
+    0x00B9, //58 #SUPERSCRIPT ONE
+    0x00BA, //59 #MASCULINE ORDINAL INDICATOR
+    0x00BB, //60 #RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK
+    0x00BC, //61 #VULGAR FRACTION ONE QUARTER
+    0x00BD, //62 #VULGAR FRACTION ONE HALF
+    0x00BE, //63 #VULGAR FRACTION THREE QUARTERS
+    0x00BF, //64 #INVERTED QUESTION MARK
+    0x00C0, //65 #LATIN CAPITAL LETTER A WITH GRAVE
+    0x00C1, //66 #LATIN CAPITAL LETTER A WITH ACUTE
+    0x00C2, //67 #LATIN CAPITAL LETTER A WITH CIRCUMFLEX
+    0x0102, //68 #LATIN CAPITAL LETTER A WITH BREVE
+    0x00C4, //69 #LATIN CAPITAL LETTER A WITH DIAERESIS
+    0x00C5, //70 #LATIN CAPITAL LETTER A WITH RING ABOVE
+    0x00C6, //71 #LATIN CAPITAL LETTER AE
+    0x00C7, //72 #LATIN CAPITAL LETTER C WITH CEDILLA
+    0x00C8, //73 #LATIN CAPITAL LETTER E WITH GRAVE
+    0x00C9, //74 #LATIN CAPITAL LETTER E WITH ACUTE
+    0x00CA, //75 #LATIN CAPITAL LETTER E WITH CIRCUMFLEX
+    0x00CB, //76 #LATIN CAPITAL LETTER E WITH DIAERESIS
+    0x0300, //77 #COMBINING GRAVE ACCENT
+    0x00CD, //78 #LATIN CAPITAL LETTER I WITH ACUTE
+    0x00CE, //79 #LATIN CAPITAL LETTER I WITH CIRCUMFLEX
+    0x00CF, //80 #LATIN CAPITAL LETTER I WITH DIAERESIS
+    0x0110, //81 #LATIN CAPITAL LETTER D WITH STROKE
+    0x00D1, //82 #LATIN CAPITAL LETTER N WITH TILDE
+    0x0309, //83 #COMBINING HOOK ABOVE
+    0x00D3, //84 #LATIN CAPITAL LETTER O WITH ACUTE
+    0x00D4, //85 #LATIN CAPITAL LETTER O WITH CIRCUMFLEX
+    0x01A0, //86 #LATIN CAPITAL LETTER O WITH HORN
+    0x00D6, //87 #LATIN CAPITAL LETTER O WITH DIAERESIS
+    0x00D7, //88 #MULTIPLICATION SIGN
+    0x00D8, //89 #LATIN CAPITAL LETTER O WITH STROKE
+    0x00D9, //90 #LATIN CAPITAL LETTER U WITH GRAVE
+    0x00DA, //91 #LATIN CAPITAL LETTER U WITH ACUTE
+    0x00DB, //92 #LATIN CAPITAL LETTER U WITH CIRCUMFLEX
+    0x00DC, //93 #LATIN CAPITAL LETTER U WITH DIAERESIS
+    0x01AF, //94 #LATIN CAPITAL LETTER U WITH HORN
+    0x0303, //95 #COMBINING TILDE
+    0x00DF, //96 #LATIN SMALL LETTER SHARP S
+    0x00E0, //97 #LATIN SMALL LETTER A WITH GRAVE
+    0x00E1, //98 #LATIN SMALL LETTER A WITH ACUTE
+    0x00E2, //99 #LATIN SMALL LETTER A WITH CIRCUMFLEX
+    0x0103, //100 #LATIN SMALL LETTER A WITH BREVE
+    0x00E4, //101 #LATIN SMALL LETTER A WITH DIAERESIS
+    0x00E5, //102 #LATIN SMALL LETTER A WITH RING ABOVE
+    0x00E6, //103 #LATIN SMALL LETTER AE
+    0x00E7, //104 #LATIN SMALL LETTER C WITH CEDILLA
+    0x00E8, //105 #LATIN SMALL LETTER E WITH GRAVE
+    0x00E9, //106 #LATIN SMALL LETTER E WITH ACUTE
+    0x00EA, //107 #LATIN SMALL LETTER E WITH CIRCUMFLEX
+    0x00EB, //108 #LATIN SMALL LETTER E WITH DIAERESIS
+    0x0301, //109 #COMBINING ACUTE ACCENT
+    0x00ED, //110 #LATIN SMALL LETTER I WITH ACUTE
+    0x00EE, //111 #LATIN SMALL LETTER I WITH CIRCUMFLEX
+    0x00EF, //112 #LATIN SMALL LETTER I WITH DIAERESIS
+    0x0111, //113 #LATIN SMALL LETTER D WITH STROKE
+    0x00F1, //114 #LATIN SMALL LETTER N WITH TILDE
+    0x0323, //115 #COMBINING DOT BELOW
+    0x00F3, //116 #LATIN SMALL LETTER O WITH ACUTE
+    0x00F4, //117 #LATIN SMALL LETTER O WITH CIRCUMFLEX
+    0x01A1, //118 #LATIN SMALL LETTER O WITH HORN
+    0x00F6, //119 #LATIN SMALL LETTER O WITH DIAERESIS
+    0x00F7, //120 #DIVISION SIGN
+    0x00F8, //121 #LATIN SMALL LETTER O WITH STROKE
+    0x00F9, //122 #LATIN SMALL LETTER U WITH GRAVE
+    0x00FA, //123 #LATIN SMALL LETTER U WITH ACUTE
+    0x00FB, //124 #LATIN SMALL LETTER U WITH CIRCUMFLEX
+    0x00FC, //125 #LATIN SMALL LETTER U WITH DIAERESIS
+    0x01B0, //126 #LATIN SMALL LETTER U WITH HORN
+    0x20AB, //127 #DONG SIGN
+    0x00FF  //128 #LATIN SMALL LETTER Y WITH DIAERESIS
+};
+
+#endif // DRW_CPTABLES_H

lib_dxf/intern/drw_textcodec.cpp

+#include "drw_textcodec.h"
+#include <sstream>
+#include <iomanip>
+#include <algorithm>
+#include "../drw_base.h"
+#include "drw_cptables.h"
+#include "drw_cptable932.h"
+#include "drw_cptable936.h"
+#include "drw_cptable949.h"
+#include "drw_cptable950.h"
+
+DRW_TextCodec::DRW_TextCodec() {
+    version = DRW::AC1021;
+    conv = new DRW_Converter(NULL, 0);
+}
+
+DRW_TextCodec::~DRW_TextCodec() {
+    delete conv;
+}
+
+void DRW_TextCodec::setVersion(std::string *v){
+    std::string versionStr = *v;
+    if (versionStr == "AC1009" || versionStr == "AC1006") {
+        version = DRW::AC1009;
+        cp = "ANSI_1252";
+        setCodePage(&cp);
+    } else if (versionStr == "AC1012" || versionStr == "AC1014"
+             || versionStr == "AC1015" || versionStr == "AC1018") {
+        version = DRW::AC1015;
+        if (cp.empty()) { //codepage not set, initialize
+            cp = "ANSI_1252";
+            setCodePage(&cp);
+        }
+    } else {
+        version = DRW::AC1021;
+        cp = "ANSI_1252";
+    }
+}
+
+void DRW_TextCodec::setCodePage(std::string *c){
+    cp = correctCodePage(*c);
+    delete conv;
+    if (version == DRW::AC1009 || version == DRW::AC1015) {
+        if (cp == "ANSI_874")
+            conv = new DRW_ConvTable(DRW_Table874, CPLENGHTCOMMON);
+        else if (cp == "ANSI_932")
+            conv = new DRW_Conv932Table(DRW_Table932, DRW_LeadTable932,
+                                         DRW_DoubleTable932, CPLENGHT932);
+        else if (cp == "ANSI_936")
+            conv = new DRW_ConvDBCSTable(DRW_Table936, DRW_LeadTable936,
+                                         DRW_DoubleTable936, CPLENGHT936);
+        else if (cp == "ANSI_949")
+            conv = new DRW_ConvDBCSTable(DRW_Table949, DRW_LeadTable949,
+                                         DRW_DoubleTable949, CPLENGHT949);
+        else if (cp == "ANSI_950")
+            conv = new DRW_ConvDBCSTable(DRW_Table950, DRW_LeadTable950,
+                                         DRW_DoubleTable950, CPLENGHT950);
+        else if (cp == "ANSI_1250")
+            conv = new DRW_ConvTable(DRW_Table1250, CPLENGHTCOMMON);
+        else if (cp == "ANSI_1251")
+            conv = new DRW_ConvTable(DRW_Table1251, CPLENGHTCOMMON);
+        else if (cp == "ANSI_1253")
+            conv = new DRW_ConvTable(DRW_Table1253, CPLENGHTCOMMON);
+        else if (cp == "ANSI_1254")
+            conv = new DRW_ConvTable(DRW_Table1254, CPLENGHTCOMMON);
+        else if (cp == "ANSI_1255")
+            conv = new DRW_ConvTable(DRW_Table1255, CPLENGHTCOMMON);
+        else if (cp == "ANSI_1256")
+            conv = new DRW_ConvTable(DRW_Table1256, CPLENGHTCOMMON);
+        else if (cp == "ANSI_1257")
+            conv = new DRW_ConvTable(DRW_Table1257, CPLENGHTCOMMON);
+        else if (cp == "ANSI_1258")
+            conv = new DRW_ConvTable(DRW_Table1258, CPLENGHTCOMMON);
+        else if (cp == "UTF-8") { //DXF older than 2007 are write in win codepages
+            cp = "ANSI_1252";
+            conv = new DRW_Converter(NULL, 0);
+        } else
+            conv = new DRW_ConvTable(DRW_Table1252, CPLENGHTCOMMON);
+    } else {
+        conv = new DRW_Converter(NULL, 0);
+    }
+}
+
+std::string DRW_TextCodec::toUtf8(std::string s) {
+    return conv->toUtf8(&s);
+}
+
+std::string DRW_TextCodec::fromUtf8(std::string s) {
+    return conv->fromUtf8(&s);
+}
+
+std::string DRW_Converter::toUtf8(std::string *s) {
+    std::string result;
+    int j = 0;
+    unsigned int i= 0;
+    for (i=0; i < s->length(); i++) {
+        unsigned char c = s->at(i);
+        if (c < 0x80) { //ascii check for /U+????
+            if (c == '\\' && i+6 < s->length() && s->at(i+1) == 'U' && s->at(i+2) == '+') {
+                result += s->substr(j,i-j);
+                result += encodeText(s->substr(i,7));
+                i +=6;
+                j = i+1;
+            }
+        } else if (c < 0xE0 ) {//2 bits
+            i++;
+        } else if (c < 0xF0 ) {//3 bits
+            i +=2;
+        } else if (c < 0xF8 ) {//4 bits
+            i +=3;
+        }
+    }
+    result += s->substr(j);
+
+    return result;
+}
+
+std::string DRW_ConvTable::fromUtf8(std::string *s) {
+    std::string result;
+    bool notFound;
+    int code;
+
+    int j = 0;
+    for (unsigned int i=0; i < s->length(); i++) {
+        unsigned char c = s->at(i);
+        if (c > 0x7F) { //need to decode
+            result += s->substr(j,i-j);
+            std::string part1 = s->substr(i,4);
+            int l;
+            code = decodeNum(part1, &l);
+            j = i+l;
+            i = j - 1;
+            notFound = true;
+            for (int k=0; k<cpLenght; k++){
+                if(table[k] == code) {
+                    result += CPOFFSET + k; //translate from table
+                    notFound = false;
+                    break;
+                }
+            }
+            if (notFound)
+                result += decodeText(code);
+        }
+    }
+    result += s->substr(j);
+
+    return result;
+}
+
+std::string DRW_ConvTable::toUtf8(std::string *s) {
+    std::string res;
+    string::iterator it;
+    for ( it=s->begin() ; it < s->end(); it++ ) {
+        unsigned char c = *it;
+        if (c < 0x80) {
+            //check for \U+ encoded text
+            if (c == '\\') {
+                if (it+6 < s->end() && *(it+1) == 'U' && *(it+2) == '+')  {
+                    res += encodeText(std::string(it, it+7));
+                    it +=6;
+                } else {
+                    res +=c; //no \U+ encoded text write
+                }
+            } else
+                res +=c; //c!='\' ascii char write
+        } else {//end c < 0x80
+            res += encodeNum(table[c-0x80]); //translate from table
+        }
+    } //end for
+
+    return res;
+}
+
+std::string DRW_Converter::encodeText(std::string stmp){
+    int code;
+#if defined(__APPLE__)
+    int Succeeded = sscanf (&( stmp.substr(3,4)[0]), "%x", &code );
+    if ( !Succeeded || Succeeded == EOF )
+        code = 0;
+#else
+    std::istringstream sd(stmp.substr(3,4));
+    sd >> std::hex >> code;
+#endif
+    return encodeNum(code);
+}
+
+std::string DRW_Converter::decodeText(int c){
+    std::string res = "\\U+";
+    std::string num;
+#if defined(__APPLE__)
+    std::string str(16, '\0');
+    snprintf (&(str[0]), 16, "%04X", c );
+    num = str;
+#else
+    std::stringstream ss;
+    ss << std::uppercase << std::setfill('0') << std::setw(4) << std::hex << c;
+    ss >> num;
+#endif
+    res += num;
+    return res;
+}
+
+std::string DRW_Converter::encodeNum(int c){
+    unsigned char ret[5];
+    if (c < 128) { // 0-7F US-ASCII 7 bits
+        ret[0] = c;
+        ret[1] = 0;
+    } else if (c < 0x800) { //80-07FF 2 bytes
+        ret[0] = 0xC0 | (c >> 6);
+        ret[1] = 0x80 | (c & 0x3f);
+        ret[2] = 0;
+    } else if (c< 0x10000) { //800-FFFF 3 bytes
+        ret[0] = 0xe0 | (c >> 12);
+        ret[1] = 0x80 | ((c >> 6) & 0x3f);
+        ret[2] = 0x80 | (c & 0x3f);
+        ret[3] = 0;
+    } else { //10000-10FFFF 4 bytes
+        ret[0] = 0xf0 | (c >> 18);
+        ret[1] = 0x80 | ((c >> 12) & 0x3f);
+        ret[2] = 0x80 | ((c >> 6) & 0x3f);
+        ret[3] = 0x80 | (c & 0x3f);
+        ret[4] = 0;
+    }
+    return std::string((char*)ret);
+}
+
+/** 's' is a string with at least 4 bytes lenght
+** returned 'b' is byte lenght of encoded char: 2,3 or 4
+**/
+int DRW_Converter::decodeNum(std::string s, int *b){
+    int code= 0;
+    unsigned char c = s.at(0);
+    if ( (c& 0xE0)  == 0xC0) { //2 bytes
+        code = ( c&0x1F)<<6;
+        code = (s.at(1) &0x3F) | code;
+        *b = 2;
+    } else if ( (c& 0xF0)  == 0xE0) { //3 bytes
+        code = ( c&0x0F)<<12;
+        code = ((s.at(1) &0x3F)<<6) | code;
+        code = (s.at(2) &0x3F) | code;
+        *b = 3;
+    } else if ( (c& 0xF8)  == 0xF0) { //4 bytes
+        code = ( c&0x07)<<18;
+        code = ((s.at(1) &0x3F)<<12) | code;
+        code = ((s.at(2) &0x3F)<<6) | code;
+        code = (s.at(3) &0x3F) | code;
+        *b = 4;
+    }
+
+    return code;
+}
+
+
+std::string DRW_ConvDBCSTable::fromUtf8(std::string *s) {
+    std::string result;
+    bool notFound;
+    int code;
+
+    int j = 0;
+    for (unsigned int i=0; i < s->length(); i++) {
+        unsigned char c = s->at(i);
+        if (c > 0x7F) { //need to decode
+            result += s->substr(j,i-j);
+            std::string part1 = s->substr(i,4);
+            int l;
+            code = decodeNum(part1, &l);
+            j = i+l;
+            i = j - 1;
+            notFound = true;
+                for (int k=0; k<cpLenght; k++){
+                    if(doubleTable[k][1] == code) {
+                        int data = doubleTable[k][0];
+                        char d[3];
+                        d[0] = data >> 8;
+                        d[1] = data & 0xFF;
+                        d[2]= '\0';
+                        result += d; //translate from table
+                        notFound = false;
+                        break;
+                    }
+                }
+            if (notFound)
+                result += decodeText(code);
+        } //direct conversion
+    }
+    result += s->substr(j);
+
+    return result;
+}
+
+std::string DRW_ConvDBCSTable::toUtf8(std::string *s) {
+    std::string res;
+    string::iterator it;
+    for ( it=s->begin() ; it < s->end(); it++ ) {
+        bool notFound = true;
+        unsigned char c = *it;
+        if (c < 0x80) {
+            notFound = false;
+            //check for \U+ encoded text
+            if (c == '\\') {
+                if (it+6 < s->end() && *(it+1) == 'U' && *(it+2) == '+')  {
+                    res += encodeText(std::string(it, it+7));
+                    it +=6;
+                } else {
+                    res +=c; //no \U+ encoded text write
+                }
+            } else
+                res +=c; //c!='\' ascii char write
+        } else if(c == 0x80 ){//1 byte table
+            notFound = false;
+            res += encodeNum(0x20AC);//euro sign
+        } else {//2 bytes
+            ++it;
+            int code = (c << 8) | (unsigned char )(*it);
+            int sta = leadTable[c-0x81];
+            int end = leadTable[c-0x80];
+            for (int k=sta; k<end; k++){
+                if(doubleTable[k][0] == code) {
+                    res += encodeNum(doubleTable[k][1]); //translate from table
+                    notFound = false;
+                    break;
+                }
+            }
+        }
+        //not found
+        if (notFound) res += encodeNum(NOTFOUND936);
+    } //end for
+
+    return res;
+}
+
+std::string DRW_Conv932Table::fromUtf8(std::string *s) {
+    std::string result;
+    bool notFound;
+    int code;
+
+    int j = 0;
+    for (unsigned int i=0; i < s->length(); i++) {
+        unsigned char c = s->at(i);
+        if (c > 0x7F) { //need to decode
+            result += s->substr(j,i-j);
+            std::string part1 = s->substr(i,4);
+            int l;
+            code = decodeNum(part1, &l);
+            j = i+l;
+            i = j - 1;
+            notFound = true;
+            // 1 byte table
+            if (code > 0xff60 && code < 0xFFA0) {
+                result += code - CPOFFSET932; //translate from table
+                notFound = false;
+            }
+            if (notFound && ( code<0xF8 || (code>0x390 && code<0x542) ||
+                    (code>0x200F && code<0x9FA1) || code>0xF928 )) {
+                for (int k=0; k<cpLenght; k++){
+                    if(doubleTable[k][1] == code) {
+                        int data = doubleTable[k][0];
+                        char d[3];
+                        d[0] = data >> 8;
+                        d[1] = data & 0xFF;
+                        d[2]= '\0';
+                        result += d; //translate from table
+                        notFound = false;
+                        break;
+                    }
+                }
+            }
+            if (notFound)
+                result += decodeText(code);
+        } //direct conversion
+    }
+    result += s->substr(j);
+
+    return result;
+}
+
+std::string DRW_Conv932Table::toUtf8(std::string *s) {
+    std::string res;
+    string::iterator it;
+    for ( it=s->begin() ; it < s->end(); it++ ) {
+        bool notFound = true;
+        unsigned char c = *it;
+        if (c < 0x80) {
+            notFound = false;
+            //check for \U+ encoded text
+            if (c == '\\') {
+                if (it+6 < s->end() && *(it+1) == 'U' && *(it+2) == '+')  {
+                    res += encodeText(std::string(it, it+7));
+                    it +=6;
+                } else {
+                    res +=c; //no \U+ encoded text write
+                }
+            } else
+                res +=c; //c!='\' ascii char write
+        } else if(c > 0xA0 && c < 0xE0 ){//1 byte table
+            notFound = false;
+            res += encodeNum(c + CPOFFSET932); //translate from table
+        } else {//2 bytes
+            ++it;
+            int code = (c << 8) | (unsigned char )(*it);
+            int sta;
+            int end=0;
+            if (c > 0x80 && c < 0xA0) {
+                sta = DRW_LeadTable932[c-0x81];
+                end = DRW_LeadTable932[c-0x80];
+            } else if (c > 0xDF && c < 0xFD){
+                sta = DRW_LeadTable932[c-0xC1];
+                end = DRW_LeadTable932[c-0xC0];
+            }
+            if (end > 0) {
+                for (int k=sta; k<end; k++){
+                    if(DRW_DoubleTable932[k][0] == code) {
+                        res += encodeNum(DRW_DoubleTable932[k][1]); //translate from table
+                        notFound = false;
+                        break;
+                    }
+                }
+            }
+        }
+        //not found
+        if (notFound) res += encodeNum(NOTFOUND932);
+    } //end for
+
+    return res;
+}
+
+std::string DRW_TextCodec::correctCodePage(const std::string& s) {
+    //stringstream cause crash in OS/X, bug#3597944
+    std::string cp=s;
+    transform(cp.begin(), cp.end(), cp.begin(), toupper);
+    //Latin/Thai
+    if (cp=="ANSI_874" || cp=="CP874" || cp=="ISO8859-11" || cp=="TIS-620") {
+        return "ANSI_874";
+        //Central Europe and Eastern Europe
+    } else if (cp=="ANSI_1250" || cp=="CP1250" || cp=="ISO8859-2") {
+        return "ANSI_1250";
+        //Cyrillic script
+    } else if (cp=="ANSI_1251" || cp=="CP1251" || cp=="ISO8859-5" || cp=="KOI8-R" ||
+               cp=="KOI8-U" || cp=="IBM 866") {
+        return "ANSI_1251";
+        //Western Europe
+    } else if (cp=="ANSI_1252" || cp=="CP1252" || cp=="LATIN1" || cp=="ISO-8859-1" ||
+               cp=="CP819" || cp=="CSISO" || cp=="IBM819" || cp=="ISO_8859-1" || cp=="APPLE ROMAN" ||
+               cp=="ISO8859-1" || cp=="ISO8859-15" || cp=="ISO-IR-100" || cp=="L1" || cp=="IBM 850") {
+        return "ANSI_1252";
+        //Greek
+    } else if (cp=="ANSI_1253" || cp=="CP1253" || cp=="iso8859-7") {
+        return "ANSI_1253";
+        //Turkish
+    } else if (cp=="ANSI_1254" || cp=="CP1254" || cp=="iso8859-9" || cp=="iso8859-3") {
+        return "ANSI_1254";
+        //Hebrew
+    } else if (cp=="ANSI_1255" || cp=="CP1255" || cp=="iso8859-8") {
+        return "ANSI_1255";
+        //Arabic
+    } else if (cp=="ANSI_1256" || cp=="CP1256" || cp=="ISO8859-6") {
+        return "ANSI_1256";
+        //Baltic
+    } else if (cp=="ANSI_1257" || cp=="CP1257" || cp=="ISO8859-4" || cp=="ISO8859-10" || cp=="ISO8859-13") {
+        return "ANSI_1257";
+        //Vietnamese
+    } else if (cp=="ANSI_1258" || cp=="CP1258") {
+        return "ANSI_1258";
+
+        //Japanese
+    } else if (cp=="ANSI_932" || cp=="SHIFT-JIS" || cp=="SHIFT_JIS" || cp=="CSSHIFTJIS" ||
+               cp=="CSWINDOWS31J" || cp=="MS_KANJI" || cp=="X-MS-CP932" || cp=="X-SJIS" ||
+               cp=="EUCJP" || cp=="EUC-JP" || cp=="CSEUCPKDFMTJAPANESE" || cp=="X-EUC" ||
+               cp=="X-EUC-JP" || cp=="JIS7") {
+        return "ANSI_932";
+        //Chinese PRC GBK (XGB) simplified
+    } else if (cp=="ANSI_936" || cp=="GBK" || cp=="GB2312" || cp=="CHINESE" || cp=="CN-GB" ||
+               cp=="CSGB2312" || cp=="CSGB231280" || cp=="CSISO58BG231280" ||
+               cp=="GB_2312-80" || cp=="GB231280" || cp=="GB2312-80" || cp=="GBK" ||
+               cp=="ISO-IR-58" || cp=="GB18030") {
+        return "ANSI_936";
+        //Korean
+    } else if (cp=="ANSI_949" || cp=="EUCKR") {
+        return "ANSI_949";
+        //Chinese Big5 (Taiwan, Hong Kong SAR)
+    } else if (cp=="ANSI_950" || cp=="BIG5" || cp=="CN-BIG5" || cp=="CSBIG5" ||
+               cp=="X-X-BIG5" || cp=="BIG5-HKSCS") {
+        return "ANSI_950";
+
+//celtic
+/*    } else if (cp=="ISO8859-14") {
+       return "ISO8859-14";
+    } else if (cp=="TSCII") {
+        return "TSCII"; //tamil
+    } else if (cp=="UTF16") {
+        return "UTF16"; */
+
+    } else if (cp=="UTF-8" || cp=="UTF8" || cp=="UTF88-BIT") {
+        return "UTF-8";
+    }
+
+    return "ANSI_1252";
+}

lib_dxf/intern/drw_textcodec.h

+#ifndef DRW_TEXTCODEC_H
+#define DRW_TEXTCODEC_H
+
+#include <string>
+
+class DRW_Converter;
+
+class DRW_TextCodec
+{
+public:
+    DRW_TextCodec();
+    ~DRW_TextCodec();
+    std::string fromUtf8(std::string s);
+    std::string toUtf8(std::string s);
+    int getVersion(){return version;}
+    void setVersion(std::string *v);
+    void setVersion(int v){version = v;}
+    void setCodePage(std::string *c);
+    void setCodePage(std::string c){setCodePage(&c);}
+    std::string getCodePage(){return cp;}
+
+private:
+    std::string correctCodePage(const std::string& s);
+
+private:
+    int version;
+    std::string cp;
+    DRW_Converter *conv;
+};
+
+class DRW_Converter
+{
+public:
+    DRW_Converter(const int *t, int l){table = t;
+                               cpLenght = l;}
+    virtual ~DRW_Converter(){}
+    virtual std::string fromUtf8(std::string *s) {return *s;}
+    virtual std::string toUtf8(std::string *s);
+    std::string encodeText(std::string stmp);
+    std::string decodeText(int c);
+    std::string encodeNum(int c);
+    int decodeNum(std::string s, int *b);
+    const int *table;
+    int cpLenght;
+};
+
+class DRW_ConvTable : public DRW_Converter {
+public:
+    DRW_ConvTable(const int *t, int l):DRW_Converter(t, l) {}
+    virtual std::string fromUtf8(std::string *s);
+    virtual std::string toUtf8(std::string *s);
+};
+
+class DRW_ConvDBCSTable : public DRW_Converter {
+public:
+    DRW_ConvDBCSTable(const int *t,  const int *lt, const int dt[][2], int l):DRW_Converter(t, l) {
+        leadTable = lt;
+        doubleTable = dt;
+    }
+
+    virtual std::string fromUtf8(std::string *s);
+    virtual std::string toUtf8(std::string *s);
+private:
+    const int *leadTable;
+    const int (*doubleTable)[2];
+
+};
+
+class DRW_Conv932Table : public DRW_Converter {
+public:
+    DRW_Conv932Table(const int *t,  const int *lt, const int dt[][2], int l):DRW_Converter(t, l) {
+        leadTable = lt;
+        doubleTable = dt;
+    }
+
+    virtual std::string fromUtf8(std::string *s);
+    virtual std::string toUtf8(std::string *s);
+private:
+    const int *leadTable;
+    const int (*doubleTable)[2];
+
+};
+
+#endif // DRW_TEXTCODEC_H

lib_dxf/intern/dxfreader.cpp

+/******************************************************************************
+**  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/>.    **
+******************************************************************************/
+
+#include <stdlib.h>
+#include <fstream>
+#include <string>
+#include <sstream>
+#include "dxfreader.h"
+#include "drw_textcodec.h"
+
+#ifdef DRW_DBG
+#include <iostream> //for debug
+#define DBG(a) std::cerr << a
+#else
+#define DBG(a)
+#endif
+
+bool dxfReader::readRec(int *codeData, bool skip) {
+//    std::string text;
+    int code;
+
+#ifdef DRW_DBG
+    count = count+2; //DBG
+/*    if (count > 10250)
+        DBG("line 10256");*/
+#endif
+
+    if (!readCode(&code))
+        return false;
+    *codeData = code;
+
+    if (code < 10)
+        readString();
+    else if (code < 60)
+        readDouble();
+    else if (code < 80)
+        readInt();
+    else if (code > 89 && code < 100) //TODO this is an int 32b
+        readInt32();
+    else if (code == 100 || code == 102 || code == 105)
+        readString();
+    else if (code > 109 && code < 150) //skip not used at the v2012
+        readDouble();
+    else if (code > 159 && code < 170) //skip not used at the v2012
+        readInt64();
+    else if (code < 180)
+        readInt();
+    else if (code > 209 && code < 240) //skip not used at the v2012
+        readDouble();
+    else if (code > 269 && code < 290) //skip not used at the v2012
+        readInt();
+    else if (code < 300) //TODO this is a boolean indicator, int in Binary?
+        readBool();
+    else if (code < 370)
+        readString();
+    else if (code < 390)
+        readInt();
+    else if (code < 400)
+        readString();
+    else if (code < 410)
+        readInt();
+    else if (code < 420)
+        readString();
+    else if (code < 430) //TODO this is an int 32b
+        readInt32();
+    else if (code < 440)
+        readString();
+    else if (code < 450) //TODO this is an int 32b
+        readInt32();
+    else if (code < 460) //TODO this is long??
+        readInt();
+    else if (code < 470) //TODO this is a floating point double precision??
+        readDouble();
+    else if (code < 481)
+        readString();
+    else if (code > 998 && code < 1009) //skip not used at the v2012
+        readString();
+    else if (code < 1060) //TODO this is a floating point double precision??
+        readDouble();
+    else if (code < 1071)
+        readInt();
+    else if (code == 1071) //TODO this is an int 32b
+        readInt32();
+    else if (skip)
+        //skip safely this dxf entry ( ok for ascii dxf)
+        readString();
+    else
+        //break in binary files because the conduct is unpredictable
+        return false;
+
+    return (filestr->good());
+}
+int dxfReader::getHandleString(){
+    int res;
+#if defined(__APPLE__)
+    int Succeeded = sscanf ( strData.c_str(), "%x", &res );
+    if ( !Succeeded || Succeeded == EOF )
+        res = 0;
+#else
+    std::istringstream Convert(strData);
+    if ( !(Convert >> std::hex >>res) )
+        res = 0;
+#endif
+    return res;
+}
+
+bool dxfReaderBinary::readCode(int *code) {
+    unsigned short *int16p;
+    char buffer[2];
+    filestr->read(buffer,2);
+    int16p = (unsigned short *) buffer;
+//exist a 32bits int (code 90) with 2 bytes???
+    if ((*code == 90) && (*int16p>2000)){
+        DBG(*code); DBG(" de 16bits\n");
+        filestr->seekg(-4, std::ios_base::cur);
+        filestr->read(buffer,2);
+        int16p = (unsigned short *) buffer;
+    }
+    *code = *int16p;
+    DBG(*code); DBG("\n");
+
+    return (filestr->good());
+}
+
+bool dxfReaderBinary::readString() {
+    std::getline(*filestr, strData, '\0');
+    DBG(strData); DBG("\n");
+    return (filestr->good());
+}
+
+bool dxfReaderBinary::readString(std::string *text) {
+    std::getline(*filestr, *text, '\0');
+    DBG(*text); DBG("\n");
+    return (filestr->good());
+}
+
+bool dxfReaderBinary::readInt() {
+    char buffer[2];
+    filestr->read(buffer,2);
+    intData = (int)((buffer[1] << 8) | buffer[0]);
+    DBG(intData); DBG("\n");
+    return (filestr->good());
+}
+
+bool dxfReaderBinary::readInt32() {
+    unsigned int *int32p;
+    char buffer[4];
+    filestr->read(buffer,4);
+    int32p = (unsigned int *) buffer;
+    intData = *int32p;
+    DBG(intData); DBG("\n");
+    return (filestr->good());
+}
+
+bool dxfReaderBinary::readInt64() {
+    unsigned long long int *int64p; //64 bits integer pointer
+    char buffer[8];
+    filestr->read(buffer,8);
+    int64p = (unsigned long long int *) buffer;
+    int64 = *int64p;
+    DBG(int64); DBG(" int64\n");
+    return (filestr->good());
+}
+
+bool dxfReaderBinary::readDouble() {
+    double *result;
+    char buffer[8];
+    filestr->read(buffer,8);
+    result = (double *) buffer;
+    doubleData = *result;
+    DBG(doubleData); DBG("\n");
+    return (filestr->good());
+}
+
+//saved as int or add a bool member??
+bool dxfReaderBinary::readBool() {
+    char buffer[1];
+    filestr->read(buffer,1);
+    intData = (int)(buffer[0]);
+    DBG(intData); DBG("\n");
+    return (filestr->good());
+}
+
+bool dxfReaderAscii::readCode(int *code) {
+    std::string text;
+    std::getline(*filestr, text);
+    *code = atoi(text.c_str());
+    DBG(*code); DBG("\n");
+    return (filestr->good());
+}
+bool dxfReaderAscii::readString(std::string *text) {
+    std::getline(*filestr, *text);
+    if (!text->empty() && text->at(text->size()-1) == '\r')
+        text->erase(text->size()-1);
+    return (filestr->good());
+}
+
+bool dxfReaderAscii::readString() {
+    std::getline(*filestr, strData);
+    if (!strData.empty() && strData.at(strData.size()-1) == '\r')
+        strData.erase(strData.size()-1);
+    DBG(strData); DBG("\n");
+    return (filestr->good());
+}
+
+bool dxfReaderAscii::readInt() {
+    std::string text;
+    if (readString(&text)){
+        intData = atoi(text.c_str());
+        DBG(intData); DBG("\n");
+        return true;
+    } else
+        return false;
+}
+
+bool dxfReaderAscii::readInt32() {
+    return readInt();
+}
+
+bool dxfReaderAscii::readInt64() {
+    return readInt();
+}
+
+bool dxfReaderAscii::readDouble() {
+    std::string text;
+    if (readString(&text)){
+#if defined(__APPLE__)
+        int succeeded=sscanf( & (text[0]), "%lg", &doubleData);
+        if(succeeded != 1) {
+            DBG("dxfReaderAscii::readDouble(): reading double error: ");
+            DBG(text);
+            DBG('\n');
+        }
+#else
+        std::istringstream sd(text);
+        sd >> doubleData;
+        DBG(doubleData); DBG('\n');
+#endif
+        return true;
+    } else
+        return false;
+}
+
+//saved as int or add a bool member??
+bool dxfReaderAscii::readBool() {
+    std::string text;
+    if (readString(&text)){
+        intData = atoi(text.c_str());
+        DBG(intData); DBG("\n");
+        return true;
+    } else
+        return false;
+}
+

lib_dxf/intern/dxfreader.h

+/******************************************************************************
+**  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 DXFREADER_H
+#define DXFREADER_H
+
+#include "drw_textcodec.h"
+
+class dxfReader {
+public:
+    dxfReader(std::ifstream *stream){
+        filestr = stream;
+#ifdef DRW_DBG
+        count =0;
+#endif
+    }
+    virtual ~dxfReader(){}
+    virtual bool readCode(int *code) = 0; //return true if sucesful (not EOF)
+    virtual bool readString(std::string *text) = 0;
+    virtual bool readString() = 0;
+    bool readRec(int *code, bool skip);
+    virtual bool readInt() = 0;
+    virtual bool readInt32() = 0;
+    virtual bool readInt64() = 0;
+    virtual bool readDouble() = 0;
+    virtual bool readBool() = 0;
+    std::string getString() {return strData;}
+    int getHandleString();//Convert hex string to int
+    std::string toUtf8String(std::string t) {return decoder.toUtf8(t);}
+    std::string getUtf8String() {return decoder.toUtf8(strData);}
+    double getDouble() {return doubleData;}
+    int getInt32() {return intData;}
+    unsigned long long int getInt64() {return int64;}
+    bool getBool() { return (intData==0) ? false : true;}
+    int getVersion(){return decoder.getVersion();}
+    void setVersion(std::string *v){decoder.setVersion(v);}
+    void setCodePage(std::string *c){decoder.setCodePage(c);}
+    std::string getCodePage(){ return decoder.getCodePage();}
+#ifdef DRW_DBG
+    int count;//DBG
+#endif
+protected:
+    std::ifstream *filestr;
+    std::string strData;
+    double doubleData;
+    signed short intData; //16 bits integer
+    unsigned long long int int64; //64 bits integer
+private:
+    DRW_TextCodec decoder;
+};
+
+class dxfReaderBinary : public dxfReader {
+public:
+    dxfReaderBinary(std::ifstream *stream):dxfReader(stream){ }
+    virtual ~dxfReaderBinary() {}
+    virtual bool readCode(int *code);
+    virtual bool readString(std::string *text);
+    virtual bool readString();
+    virtual bool readInt();
+    virtual bool readInt32();
+    virtual bool readInt64();
+    virtual bool readDouble();
+    virtual bool readBool();
+};
+
+class dxfReaderAscii : public dxfReader {
+public:
+    dxfReaderAscii(std::ifstream *stream):dxfReader(stream){ }
+    virtual ~dxfReaderAscii(){}
+    virtual bool readCode(int *code);
+    virtual bool readString(std::string *text);
+    virtual bool readString();
+    virtual bool readInt();
+    virtual bool readDouble();
+    virtual bool readInt32();
+    virtual bool readInt64();
+    virtual bool readBool();
+};
+
+#endif // DXFREADER_H

lib_dxf/intern/dxfwriter.cpp

+/******************************************************************************
+**  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/>.    **
+******************************************************************************/
+
+#include <stdlib.h>
+#include <fstream>
+#include <string>
+#include <algorithm>
+#include "dxfwriter.h"
+
+#ifdef DRW_DBG
+#include <iostream> //for debug
+#define DBG(a) std::cerr << a
+#else
+#define DBG(a)
+#endif
+
+//RLZ TODO change std::endl to x0D x0A (13 10)
+/*bool dxfWriter::readRec(int *codeData, bool skip) {
+//    std::string text;
+    int code;
+
+#ifdef DRW_DBG
+    count = count+2; //DBG
+#endif
+
+    if (!readCode(&code))
+        return false;
+    *codeData = code;
+
+    if (code < 10)
+        readString();
+    else if (code < 60)
+        readDouble();
+    else if (code < 80)
+        readInt();
+    else if (code > 89 && code < 100) //TODO this is an int 32b
+        readInt32();
+    else if (code == 100 || code == 102 || code == 105)
+        readString();
+    else if (code > 109 && code < 150) //skip not used at the v2012
+        readDouble();
+    else if (code > 159 && code < 170) //skip not used at the v2012
+        readInt64();
+    else if (code < 180)
+        readInt();
+    else if (code > 209 && code < 240) //skip not used at the v2012
+        readDouble();
+    else if (code > 269 && code < 290) //skip not used at the v2012
+        readInt();
+    else if (code < 300) //TODO this is a boolean indicator, int in Binary?
+        readBool();
+    else if (code < 370)
+        readString();
+    else if (code < 390)
+        readInt();
+    else if (code < 400)
+        readString();
+    else if (code < 410)
+        readInt();
+    else if (code < 420)
+        readString();
+    else if (code < 430) //TODO this is an int 32b
+        readInt32();
+    else if (code < 440)
+        readString();
+    else if (code < 450) //TODO this is an int 32b
+        readInt32();
+    else if (code < 460) //TODO this is long??
+        readInt();
+    else if (code < 470) //TODO this is a floating point double precision??
+        readDouble();
+    else if (code < 481)
+        readString();
+    else if (code > 998 && code < 1009) //skip not used at the v2012
+        readString();
+    else if (code < 1060) //TODO this is a floating point double precision??
+        readDouble();
+    else if (code < 1071)
+        readInt();
+    else if (code == 1071) //TODO this is an int 32b
+        readInt32();
+    else if (skip)
+        //skip safely this dxf entry ( ok for ascii dxf)
+        readString();
+    else
+        //break in binary files because the conduct is unpredictable
+        return false;
+
+    return (filestr->good());
+}*/
+
+bool dxfWriter::writeUtf8String(int code, std::string text) {
+    std::string t = encoder.fromUtf8(text);
+    return writeString(code, t);
+}
+
+bool dxfWriter::writeUtf8Caps(int code, std::string text) {
+    std::string strname = text;
+    std::transform(strname.begin(), strname.end(), strname.begin(),::toupper);
+    std::string t = encoder.fromUtf8(strname);
+    return writeString(code, t);
+}
+
+bool dxfWriterBinary::writeString(int code, std::string text) {
+    char bufcode[2];
+    bufcode[0] =code & 0xFF;
+    bufcode[1] =code  >> 8;
+    filestr->write(bufcode, 2);
+    *filestr << text << '\0';
+    return (filestr->good());
+}
+
+/*bool dxfWriterBinary::readCode(int *code) {
+    unsigned short *int16p;
+    char buffer[2];
+    filestr->read(buffer,2);
+    int16p = (unsigned short *) buffer;
+//exist a 32bits int (code 90) with 2 bytes???
+    if ((*code == 90) && (*int16p>2000)){
+        DBG(*code); DBG(" de 16bits\n");
+        filestr->seekg(-4, std::ios_base::cur);
+        filestr->read(buffer,2);
+        int16p = (unsigned short *) buffer;
+    }
+    *code = *int16p;
+    DBG(*code); DBG("\n");
+
+    return (filestr->good());
+}*/
+
+/*bool dxfWriterBinary::readString() {
+    std::getline(*filestr, strData, '\0');
+    DBG(strData); DBG("\n");
+    return (filestr->good());
+}*/
+
+/*bool dxfWriterBinary::readString(std::string *text) {
+    std::getline(*filestr, *text, '\0');
+    DBG(*text); DBG("\n");
+    return (filestr->good());
+}*/
+
+bool dxfWriterBinary::writeInt16(int code, int data) {
+    char bufcode[2];
+    char buffer[2];
+    bufcode[0] =code & 0xFF;
+    bufcode[1] =code  >> 8;
+    buffer[0] =data & 0xFF;
+    buffer[1] =data  >> 8;
+    filestr->write(bufcode, 2);
+    filestr->write(buffer, 2);
+    return (filestr->good());
+}
+
+bool dxfWriterBinary::writeInt32(int code, int data) {
+    char buffer[4];
+    buffer[0] =code & 0xFF;
+    buffer[1] =code  >> 8;
+    filestr->write(buffer, 2);
+
+    buffer[0] =data & 0xFF;
+    buffer[1] =data  >> 8;
+    buffer[2] =data  >> 16;
+    buffer[3] =data  >> 24;
+    filestr->write(buffer, 4);
+    return (filestr->good());
+}
+
+bool dxfWriterBinary::writeInt64(int code, unsigned long long int data) {
+    char buffer[8];
+    buffer[0] =code & 0xFF;
+    buffer[1] =code  >> 8;
+    filestr->write(buffer, 2);
+
+    buffer[0] =data & 0xFF;
+    buffer[1] =data  >> 8;
+    buffer[2] =data  >> 16;
+    buffer[3] =data  >> 24;
+    buffer[4] =data  >> 32;
+    buffer[5] =data  >> 40;
+    buffer[6] =data  >> 48;
+    buffer[7] =data  >> 56;
+    filestr->write(buffer, 8);
+    return (filestr->good());
+}
+
+bool dxfWriterBinary::writeDouble(int code, double data) {
+    char bufcode[2];
+    char buffer[8];
+    bufcode[0] =code & 0xFF;
+    bufcode[1] =code  >> 8;
+    filestr->write(bufcode, 2);
+
+    unsigned char *val;
+    val = (unsigned char *) &data;
+    for (int i=0; i<8; i++) {
+        buffer[i] =val[i];
+    }
+    filestr->write(buffer, 8);
+    return (filestr->good());
+}
+
+//saved as int or add a bool member??
+bool dxfWriterBinary::writeBool(int code, bool data) {
+    char buffer[1];
+    char bufcode[2];
+    bufcode[0] =code & 0xFF;
+    bufcode[1] =code  >> 8;
+    filestr->write(bufcode, 2);
+    buffer[0] = data;
+    filestr->write(buffer, 1);
+    return (filestr->good());
+}
+
+bool dxfWriterAscii::writeString(int code, std::string text) {
+    *filestr << code << std::endl << text << std::endl ;
+    /*    std::getline(*filestr, strData, '\0');
+    DBG(strData); DBG("\n");*/
+    return (filestr->good());
+}
+
+/*bool dxfWriterAscii::readCode(int *code) {
+    std::string text;
+    std::getline(*filestr, text);
+    *code = atoi(text.c_str());
+    DBG(*code); DBG("\n");
+    return (filestr->good());
+}*/
+/*bool dxfWriterAscii::readString(std::string *text) {
+    std::getline(*filestr, *text);
+    if (text->at(text->size()-1) == '\r')
+        text->erase(text->size()-1);
+    return (filestr->good());
+}*/
+
+/*bool dxfWriterAscii::readString() {
+    std::getline(*filestr, strData);
+    if (strData.at(strData.size()-1) == '\r')
+        strData.erase(strData.size()-1);
+    DBG(strData); DBG("\n");
+    return (filestr->good());
+}*/
+
+bool dxfWriterAscii::writeInt16(int code, int data) {
+//    *filestr << code << "\r\n" << data << "\r\n";
+    *filestr << code << std::endl << data << std::endl;
+    return (filestr->good());
+}
+
+bool dxfWriterAscii::writeInt32(int code, int data) {
+    return writeInt16(code, data);
+}
+
+bool dxfWriterAscii::writeInt64(int code, unsigned long long int data) {
+    *filestr << code << std::endl << data << std::endl;
+    return (filestr->good());
+}
+
+bool dxfWriterAscii::writeDouble(int code, double data) {
+    std::streamsize prec = filestr->precision();
+    filestr->precision(12);
+    *filestr << code << std::endl << data << std::endl;
+    filestr->precision(prec);
+    return (filestr->good());
+}
+
+//saved as int or add a bool member??
+bool dxfWriterAscii::writeBool(int code, bool data) {
+    *filestr << code << std::endl << data << std::endl;
+    return (filestr->good());
+}
+

lib_dxf/intern/dxfwriter.h

+/******************************************************************************
+**  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 DXFWRITER_H
+#define DXFWRITER_H
+
+#include "drw_textcodec.h"
+
+class dxfWriter {
+public:
+    dxfWriter(std::ofstream *stream){filestr = stream; /*count =0;*/}
+    virtual ~dxfWriter(){}
+    virtual bool writeString(int code, std::string text) = 0;
+    bool writeUtf8String(int code, std::string text);
+    bool writeUtf8Caps(int code, std::string text);
+    std::string fromUtf8String(std::string t) {return encoder.fromUtf8(t);}
+    virtual bool writeInt16(int code, int data) = 0;
+    virtual bool writeInt32(int code, int data) = 0;
+    virtual bool writeInt64(int code, unsigned long long int data) = 0;
+    virtual bool writeDouble(int code, double data) = 0;
+    virtual bool writeBool(int code, bool data) = 0;
+    void setVersion(std::string *v){encoder.setVersion(v);}
+    void setCodePage(std::string *c){encoder.setCodePage(c);}
+    std::string getCodePage(){return encoder.getCodePage();}
+protected:
+    std::ofstream *filestr;
+private:
+    DRW_TextCodec encoder;
+};
+
+class dxfWriterBinary : public dxfWriter {
+public:
+    dxfWriterBinary(std::ofstream *stream):dxfWriter(stream){ }
+    virtual ~dxfWriterBinary() {}
+    virtual bool writeString(int code, std::string text);
+    virtual bool writeInt16(int code, int data);
+    virtual bool writeInt32(int code, int data);
+    virtual bool writeInt64(int code, unsigned long long int data);
+    virtual bool writeDouble(int code, double data);
+    virtual bool writeBool(int code, bool data);
+};
+
+class dxfWriterAscii : public dxfWriter {
+public:
+    dxfWriterAscii(std::ofstream *stream):dxfWriter(stream){ }
+    virtual ~dxfWriterAscii(){}
+    virtual bool writeString(int code, std::string text);
+    virtual bool writeInt16(int code, int data);
+    virtual bool writeInt32(int code, int data);
+    virtual bool writeInt64(int code, unsigned long long int data);
+    virtual bool writeDouble(int code, double data);
+    virtual bool writeBool(int code, bool data);
+};
+
+#endif // DXFWRITER_H

lib_dxf/libdxfrw.cpp

+/******************************************************************************
+**  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/>.    **
+******************************************************************************/
+
+
+#include "libdxfrw.h"
+#include <fstream>
+#include <algorithm>
+#include <sstream>
+#include "intern/drw_textcodec.h"
+#include "intern/dxfreader.h"
+#include "intern/dxfwriter.h"
+#include <assert.h>
+
+#ifdef DRW_DBG
+#include <iostream>    // for debug
+#define DBG( a ) std::cerr << a
+#else
+#define DBG( a )
+#endif
+
+#define FIRSTHANDLE 48
+
+/*enum sections {
+ *   secUnknown,
+ *   secHeader,
+ *   secTables,
+ *   secBlocks,
+ *   secEntities,
+ *   secObjects
+ *  };*/
+
+dxfRW::dxfRW( const char* name )
+{
+    fileName    = name;
+    reader      = NULL;
+    writer      = NULL;
+    applyExt    = false;
+    elParts     = 128; // parts munber when convert ellipse to polyline
+}
+
+
+dxfRW::~dxfRW()
+{
+    if( reader != NULL )
+        delete reader;
+}
+
+
+bool dxfRW::read( DRW_Interface* interface_, bool ext )
+{
+    assert( fileName.empty() == false );
+    bool            isOk = false;
+    applyExt = ext;
+    std::ifstream   filestr;
+
+    if( interface_ == NULL )
+        return isOk;
+
+    DBG( "dxfRW::read 1def\n" );
+    filestr.open( fileName.c_str(), std::ios_base::in | std::ios::binary );
+
+    if( !filestr.is_open() )
+        return isOk;
+
+    if( !filestr.good() )
+        return isOk;
+
+    char    line[22];
+    char    line2[22] = "AutoCAD Binary DXF\r\n";
+    line2[20]   = (char) 26;
+    line2[21]   = '\0';
+    filestr.read( line, 22 );
+    filestr.close();
+    iface = interface_;
+    DBG( "dxfRW::read 2\n" );
+
+    if( strcmp( line, line2 ) == 0 )
+    {
+        filestr.open( fileName.c_str(), std::ios_base::in | std::ios::binary );
+        binary = true;
+        // skip sentinel
+        filestr.seekg( 22, std::ios::beg );
+        reader = new dxfReaderBinary( &filestr );
+        DBG( "dxfRW::read binary file\n" );
+    }
+    else
+    {
+        binary = false;
+        filestr.open( fileName.c_str(), std::ios_base::in );
+        reader = new dxfReaderAscii( &filestr );
+    }
+
+    isOk = processDxf();
+    filestr.close();
+    delete reader;
+    reader = NULL;
+    return isOk;
+}
+
+
+bool dxfRW::write( DRW_Interface* interface_, DRW::Version ver, bool bin )
+{
+    bool            isOk = false;
+    std::ofstream   filestr;
+
+    version = ver;
+    binary  = bin;
+    iface   = interface_;
+
+    if( binary )
+    {
+        filestr.open( fileName.c_str(), std::ios_base::out | std::ios::binary | std::ios::trunc );
+        // write sentinel
+        filestr << "AutoCAD Binary DXF\r\n" << (char) 26 << '\0';
+        writer = new dxfWriterBinary( &filestr );
+        DBG( "dxfRW::read binary file\n" );
+    }
+    else
+    {
+        filestr.open( fileName.c_str(), std::ios_base::out | std::ios::trunc );
+        writer = new dxfWriterAscii( &filestr );
+        std::string comm = std::string( "dxfrw " ) + std::string( DRW_VERSION );
+        writer->writeString( 999, comm );
+    }
+
+    DRW_Header header;
+    iface->writeHeader( header );
+    writer->writeString( 0, "SECTION" );
+    entCount = FIRSTHANDLE;
+    header.write( writer, version );
+    writer->writeString( 0, "ENDSEC" );
+    writer->writeString( 0, "SECTION" );
+    writer->writeString( 2, "CLASSES" );
+    writer->writeString( 0, "ENDSEC" );
+    writer->writeString( 0, "SECTION" );
+    writer->writeString( 2, "TABLES" );
+    writeTables();
+    writer->writeString( 0, "ENDSEC" );
+    writer->writeString( 0, "SECTION" );
+    writer->writeString( 2, "BLOCKS" );
+    writeBlocks();
+    writer->writeString( 0, "ENDSEC" );
+
+    writer->writeString( 0, "SECTION" );
+    writer->writeString( 2, "ENTITIES" );
+    iface->writeEntities();
+    writer->writeString( 0, "ENDSEC" );
+
+    if( version > DRW::AC1009 )
+    {
+        writer->writeString( 0, "SECTION" );
+        writer->writeString( 2, "OBJECTS" );
+        writeObjects();
+        writer->writeString( 0, "ENDSEC" );
+    }
+
+    writer->writeString( 0, "EOF" );
+    filestr.flush();
+    filestr.close();
+    isOk = true;
+    delete writer;
+    writer = NULL;
+    return isOk;
+}
+
+
+bool dxfRW::writeEntity( DRW_Entity* ent )
+{
+    ent->handle = ++entCount;
+    writer->writeString( 5, toHexStr( ent->handle ) );
+
+    if( version > DRW::AC1009 )
+    {
+        writer->writeString( 100, "AcDbEntity" );
+    }
+
+    if( ent->space == 1 )
+        writer->writeInt16( 67, 1 );
+
+    if( version > DRW::AC1009 )
+    {
+        writer->writeUtf8String( 8, ent->layer );
+        writer->writeUtf8String( 6, ent->lineType );
+    }
+    else
+    {
+        writer->writeUtf8Caps( 8, ent->layer );
+        writer->writeUtf8Caps( 6, ent->lineType );
+    }
+
+    writer->writeInt16( 62, ent->color );
+
+    if( version > DRW::AC1015 && ent->color24 >= 0 )
+    {
+        writer->writeInt32( 420, ent->color24 );
+    }
+
+    if( version > DRW::AC1014 )
+    {
+        writer->writeInt16( 370, DRW_LW_Conv::lineWidth2dxfInt( ent->lWeight ) );
+    }
+
+    return true;
+}
+
+
+bool dxfRW::writeLineType( DRW_LType* ent )
+{
+    string strname = ent->name;
+
+    transform( strname.begin(), strname.end(), strname.begin(), ::toupper );
+
+// do not write linetypes handled by library
+    if( strname == "BYLAYER" || strname == "BYBLOCK" || strname == "CONTINUOUS" )
+    {
+        return true;
+    }
+
+    writer->writeString( 0, "LTYPE" );
+
+    if( version > DRW::AC1009 )
+    {
+        writer->writeString( 5, toHexStr( ++entCount ) );
+
+        if( version > DRW::AC1012 )
+        {
+            writer->writeString( 330, "5" );
+        }
+
+        writer->writeString( 100, "AcDbSymbolTableRecord" );
+        writer->writeString( 100, "AcDbLinetypeTableRecord" );
+        writer->writeUtf8String( 2, ent->name );
+    }
+    else
+        writer->writeUtf8Caps( 2, ent->name );
+
+    writer->writeInt16( 70, ent->flags );
+    writer->writeUtf8String( 3, ent->desc );
+    ent->update();
+    writer->writeInt16( 72, 65 );
+    writer->writeInt16( 73, ent->size );
+    writer->writeDouble( 40, ent->length );
+
+    for( unsigned int i = 0; i< ent->path.size(); i++ )
+    {
+        writer->writeDouble( 49, ent->path.at( i ) );
+
+        if( version > DRW::AC1009 )
+        {
+            writer->writeInt16( 74, 0 );
+        }
+    }
+
+    return true;
+}
+
+
+bool dxfRW::writeLayer( DRW_Layer* ent )
+{
+    writer->writeString( 0, "LAYER" );
+
+    if( !wlayer0 && ent->name == "0" )
+    {
+        wlayer0 = true;
+
+        if( version > DRW::AC1009 )
+        {
+            writer->writeString( 5, "10" );
+        }
+    }
+    else
+    {
+        if( version > DRW::AC1009 )
+        {
+            writer->writeString( 5, toHexStr( ++entCount ) );
+        }
+    }
+
+    if( version > DRW::AC1012 )
+    {
+        writer->writeString( 330, "2" );
+    }
+
+    if( version > DRW::AC1009 )
+    {
+        writer->writeString( 100, "AcDbSymbolTableRecord" );
+        writer->writeString( 100, "AcDbLayerTableRecord" );
+        writer->writeUtf8String( 2, ent->name );
+    }
+    else
+    {
+        writer->writeUtf8Caps( 2, ent->name );
+    }
+
+    writer->writeInt16( 70, ent->flags );
+    writer->writeInt16( 62, ent->color );
+
+    if( version > DRW::AC1015 && ent->color24 >= 0 )
+    {
+        writer->writeInt32( 420, ent->color24 );
+    }
+
+    if( version > DRW::AC1009 )
+    {
+        writer->writeUtf8String( 6, ent->lineType );
+
+        if( !ent->plotF )
+            writer->writeBool( 290, ent->plotF );
+
+        writer->writeInt16( 370, DRW_LW_Conv::lineWidth2dxfInt( ent->lWeight ) );
+        writer->writeString( 390, "F" );
+    }
+    else
+        writer->writeUtf8Caps( 6, ent->lineType );
+
+// writer->writeString(347, "10012");
+    return true;
+}
+
+
+bool dxfRW::writeTextstyle( DRW_Textstyle* ent )
+{
+    writer->writeString( 0, "STYLE" );
+
+    if( !dimstyleStd )
+    {
+        // stringstream cause crash in OS/X, bug#3597944
+        std::string name = ent->name;
+        transform( name.begin(), name.end(), name.begin(), toupper );
+
+        if( name == "STANDARD" )
+            dimstyleStd = true;
+    }
+
+    if( version > DRW::AC1009 )
+    {
+        writer->writeString( 5, toHexStr( ++entCount ) );
+    }
+
+    if( version > DRW::AC1012 )
+    {
+        writer->writeString( 330, "2" );
+    }
+
+    if( version > DRW::AC1009 )
+    {
+        writer->writeString( 100, "AcDbSymbolTableRecord" );
+        writer->writeString( 100, "AcDbTextStyleTableRecord" );
+        writer->writeUtf8String( 2, ent->name );
+    }
+    else
+    {
+        writer->writeUtf8Caps( 2, ent->name );
+    }
+
+    writer->writeInt16( 70, ent->flags );
+    writer->writeDouble( 40, ent->height );
+    writer->writeDouble( 41, ent->width );
+    writer->writeDouble( 50, ent->oblique );
+    writer->writeInt16( 71, ent->genFlag );
+    writer->writeDouble( 42, ent->lastHeight );
+
+    if( version > DRW::AC1009 )
+    {
+        writer->writeUtf8String( 3, ent->font );
+        writer->writeUtf8String( 4, ent->bigFont );
+
+        if( ent->fontFamily != 0 )
+            writer->writeInt32( 1071, ent->fontFamily );
+    }
+    else
+    {
+        writer->writeUtf8Caps( 3, ent->font );
+        writer->writeUtf8Caps( 4, ent->bigFont );
+    }
+
+    return true;
+}
+
+
+bool dxfRW::writeVport( DRW_Vport* ent )
+{
+    if( !dimstyleStd )
+    {
+        ent->name   = "*ACTIVE";
+        dimstyleStd = true;
+    }
+
+    writer->writeString( 0, "VPORT" );
+
+    if( version > DRW::AC1009 )
+    {
+        writer->writeString( 5, toHexStr( ++entCount ) );
+
+        if( version > DRW::AC1012 )
+            writer->writeString( 330, "2" );
+
+        writer->writeString( 100, "AcDbSymbolTableRecord" );
+        writer->writeString( 100, "AcDbViewportTableRecord" );
+        writer->writeUtf8String( 2, ent->name );
+    }
+    else
+        writer->writeUtf8Caps( 2, ent->name );
+
+    writer->writeInt16( 70, ent->flags );
+    writer->writeDouble( 10, ent->lowerLeft.x );
+    writer->writeDouble( 20, ent->lowerLeft.y );
+    writer->writeDouble( 11, ent->UpperRight.x );
+    writer->writeDouble( 21, ent->UpperRight.y );
+    writer->writeDouble( 12, ent->center.x );
+    writer->writeDouble( 22, ent->center.y );
+    writer->writeDouble( 13, ent->snapBase.x );
+    writer->writeDouble( 23, ent->snapBase.y );
+    writer->writeDouble( 14, ent->snapSpacing.x );
+    writer->writeDouble( 24, ent->snapSpacing.y );
+    writer->writeDouble( 15, ent->gridSpacing.x );
+    writer->writeDouble( 25, ent->gridSpacing.y );
+    writer->writeDouble( 16, ent->viewDir.x );
+    writer->writeDouble( 26, ent->viewDir.y );
+    writer->writeDouble( 36, ent->viewDir.z );
+    writer->writeDouble( 17, ent->viewTarget.z );
+    writer->writeDouble( 27, ent->viewTarget.z );
+    writer->writeDouble( 37, ent->viewTarget.z );
+    writer->writeDouble( 40, ent->height );
+    writer->writeDouble( 41, ent->ratio );
+    writer->writeDouble( 42, ent->lensHeight );
+    writer->writeDouble( 43, ent->frontClip );
+    writer->writeDouble( 44, ent->backClip );
+    writer->writeDouble( 50, ent->snapAngle );
+    writer->writeDouble( 51, ent->twistAngle );
+    writer->writeInt16( 71, ent->viewMode );
+    writer->writeInt16( 72, ent->circleZoom );
+    writer->writeInt16( 73, ent->fastZoom );
+    writer->writeInt16( 74, ent->ucsIcon );
+    writer->writeInt16( 75, ent->snap );
+    writer->writeInt16( 76, ent->grid );
+    writer->writeInt16( 77, ent->snapStyle );
+    writer->writeInt16( 78, ent->snapIsopair );
+
+    if( version > DRW::AC1014 )
+    {
+        writer->writeInt16( 281, 0 );
+        writer->writeInt16( 65, 1 );
+        writer->writeDouble( 110, 0.0 );
+        writer->writeDouble( 120, 0.0 );
+        writer->writeDouble( 130, 0.0 );
+        writer->writeDouble( 111, 1.0 );
+        writer->writeDouble( 121, 0.0 );
+        writer->writeDouble( 131, 0.0 );
+        writer->writeDouble( 112, 0.0 );
+        writer->writeDouble( 122, 1.0 );
+        writer->writeDouble( 132, 0.0 );
+        writer->writeInt16( 79, 0 );
+        writer->writeDouble( 146, 0.0 );
+
+        if( version > DRW::AC1018 )
+        {
+            writer->writeString( 348, "10020" );
+            writer->writeInt16( 60, ent->gridBehavior );    // v2007 undocummented see DRW_Vport class
+            writer->writeInt16( 61, 5 );
+            writer->writeBool( 292, 1 );
+            writer->writeInt16( 282, 1 );
+            writer->writeDouble( 141, 0.0 );
+            writer->writeDouble( 142, 0.0 );
+            writer->writeInt16( 63, 250 );
+            writer->writeInt32( 421, 3358443 );
+        }
+    }
+
+    return true;
+}
+
+
+bool dxfRW::writeDimstyle( DRW_Dimstyle* ent )
+{
+    writer->writeString( 0, "DIMSTYLE" );
+
+    if( !dimstyleStd )
+    {
+        std::string name = ent->name;
+        std::transform( name.begin(), name.end(), name.begin(), ::toupper );
+
+        if( name == "STANDARD" )
+            dimstyleStd = true;
+    }
+
+    if( version > DRW::AC1009 )
+    {
+        writer->writeString( 105, toHexStr( ++entCount ) );
+    }
+
+    if( version > DRW::AC1012 )
+    {
+        writer->writeString( 330, "A" );
+    }
+
+    if( version > DRW::AC1009 )
+    {
+        writer->writeString( 100, "AcDbSymbolTableRecord" );
+        writer->writeString( 100, "AcDbDimStyleTableRecord" );
+        writer->writeUtf8String( 2, ent->name );
+    }
+    else
+        writer->writeUtf8Caps( 2, ent->name );
+
+    writer->writeInt16( 70, ent->flags );
+
+    if( version == DRW::AC1009 || !( ent->dimpost.empty() ) )
+        writer->writeUtf8String( 3, ent->dimpost );
+
+    if( version == DRW::AC1009 || !( ent->dimapost.empty() ) )
+        writer->writeUtf8String( 4, ent->dimapost );
+
+    if( version == DRW::AC1009 || !( ent->dimblk.empty() ) )
+        writer->writeUtf8String( 5, ent->dimblk );
+
+    if( version == DRW::AC1009 || !( ent->dimblk1.empty() ) )
+        writer->writeUtf8String( 6, ent->dimblk1 );
+
+    if( version == DRW::AC1009 || !( ent->dimblk2.empty() ) )
+        writer->writeUtf8String( 7, ent->dimblk2 );
+
+    writer->writeDouble( 40, ent->dimscale );
+    writer->writeDouble( 41, ent->dimasz );
+    writer->writeDouble( 42, ent->dimexo );
+    writer->writeDouble( 43, ent->dimdli );
+    writer->writeDouble( 44, ent->dimexe );
+    writer->writeDouble( 45, ent->dimrnd );
+    writer->writeDouble( 46, ent->dimdle );
+    writer->writeDouble( 47, ent->dimtp );
+    writer->writeDouble( 48, ent->dimtm );
+    writer->writeDouble( 140, ent->dimtxt );
+    writer->writeDouble( 141, ent->dimcen );
+    writer->writeDouble( 142, ent->dimtsz );
+    writer->writeDouble( 143, ent->dimaltf );
+    writer->writeDouble( 144, ent->dimlfac );
+    writer->writeDouble( 145, ent->dimtvp );
+    writer->writeDouble( 146, ent->dimtfac );
+    writer->writeDouble( 147, ent->dimgap );
+
+    if( version > DRW::AC1014 )
+    {
+        writer->writeDouble( 148, ent->dimaltrnd );
+    }
+
+    writer->writeInt16( 71, ent->dimtol );
+    writer->writeInt16( 72, ent->dimlim );
+    writer->writeInt16( 73, ent->dimtih );
+    writer->writeInt16( 74, ent->dimtoh );
+    writer->writeInt16( 75, ent->dimse1 );
+    writer->writeInt16( 76, ent->dimse2 );
+    writer->writeInt16( 77, ent->dimtad );
+    writer->writeInt16( 78, ent->dimzin );
+
+    if( version > DRW::AC1014 )
+    {
+        writer->writeInt16( 79, ent->dimazin );
+    }
+
+    writer->writeInt16( 170, ent->dimalt );
+    writer->writeInt16( 171, ent->dimaltd );
+    writer->writeInt16( 172, ent->dimtofl );
+    writer->writeInt16( 173, ent->dimsah );
+    writer->writeInt16( 174, ent->dimtix );
+    writer->writeInt16( 175, ent->dimsoxd );
+    writer->writeInt16( 176, ent->dimclrd );
+    writer->writeInt16( 177, ent->dimclre );
+    writer->writeInt16( 178, ent->dimclrt );
+
+    if( version > DRW::AC1014 )
+    {
+        writer->writeInt16( 179, ent->dimadec );
+    }
+
+    if( version > DRW::AC1009 )
+    {
+        if( version < DRW::AC1015 )
+            writer->writeInt16( 270, ent->dimunit );
+
+        writer->writeInt16( 271, ent->dimdec );
+        writer->writeInt16( 272, ent->dimtdec );
+        writer->writeInt16( 273, ent->dimaltu );
+        writer->writeInt16( 274, ent->dimalttd );
+        writer->writeInt16( 275, ent->dimaunit );
+    }
+
+    if( version > DRW::AC1014 )
+    {
+        writer->writeInt16( 276, ent->dimfrac );
+        writer->writeInt16( 277, ent->dimlunit );
+        writer->writeInt16( 278, ent->dimdsep );
+        writer->writeInt16( 279, ent->dimtmove );
+    }
+
+    if( version > DRW::AC1009 )
+    {
+        writer->writeInt16( 280, ent->dimjust );
+        writer->writeInt16( 281, ent->dimsd1 );
+        writer->writeInt16( 282, ent->dimsd2 );
+        writer->writeInt16( 283, ent->dimtolj );
+        writer->writeInt16( 284, ent->dimtzin );
+        writer->writeInt16( 285, ent->dimaltz );
+        writer->writeInt16( 286, ent->dimaltttz );
+
+        if( version < DRW::AC1015 )
+            writer->writeInt16( 287, ent->dimfit );
+
+        writer->writeInt16( 288, ent->dimupt );
+    }
+
+    if( version > DRW::AC1014 )
+    {
+        writer->writeInt16( 289, ent->dimatfit );
+    }
+
+    if( version > DRW::AC1009 )
+    {
+        writer->writeUtf8String( 340, ent->dimtxsty );
+    }
+
+    if( version > DRW::AC1014 )
+    {
+        writer->writeUtf8String( 341, ent->dimldrblk );
+        writer->writeInt16( 371, ent->dimlwd );
+        writer->writeInt16( 372, ent->dimlwe );
+    }
+
+    return true;
+}
+
+
+bool dxfRW::writePoint( DRW_Point* ent )
+{
+    writer->writeString( 0, "POINT" );
+    writeEntity( ent );
+
+    if( version > DRW::AC1009 )
+    {
+        writer->writeString( 100, "AcDbPoint" );
+    }
+
+    writer->writeDouble( 10, ent->basePoint.x );
+    writer->writeDouble( 20, ent->basePoint.y );
+
+    if( ent->basePoint.z != 0.0 )
+    {
+        writer->writeDouble( 30, ent->basePoint.z );
+    }
+
+    return true;
+}
+
+
+bool dxfRW::writeLine( DRW_Line* ent )
+{
+    writer->writeString( 0, "LINE" );
+    writeEntity( ent );
+
+    if( version > DRW::AC1009 )
+    {
+        writer->writeString( 100, "AcDbLine" );
+    }
+
+    writer->writeDouble( 10, ent->basePoint.x );
+    writer->writeDouble( 20, ent->basePoint.y );
+
+    if( ent->basePoint.z != 0.0 || ent->secPoint.z != 0.0 )
+    {
+        writer->writeDouble( 30, ent->basePoint.z );
+        writer->writeDouble( 11, ent->secPoint.x );
+        writer->writeDouble( 21, ent->secPoint.y );
+        writer->writeDouble( 31, ent->secPoint.z );
+    }
+    else
+    {
+        writer->writeDouble( 11, ent->secPoint.x );
+        writer->writeDouble( 21, ent->secPoint.y );
+    }
+
+    return true;
+}
+
+
+bool dxfRW::writeRay( DRW_Ray* ent )
+{
+    writer->writeString( 0, "RAY" );
+    writeEntity( ent );
+
+    if( version > DRW::AC1009 )
+    {
+        writer->writeString( 100, "AcDbRay" );
+    }
+
+    DRW_Coord crd = ent->secPoint;
+    crd.unitize();
+    writer->writeDouble( 10, ent->basePoint.x );
+    writer->writeDouble( 20, ent->basePoint.y );
+
+    if( ent->basePoint.z != 0.0 || ent->secPoint.z != 0.0 )
+    {
+        writer->writeDouble( 30, ent->basePoint.z );
+        writer->writeDouble( 11, crd.x );
+        writer->writeDouble( 21, crd.y );
+        writer->writeDouble( 31, crd.z );
+    }
+    else
+    {
+        writer->writeDouble( 11, crd.x );
+        writer->writeDouble( 21, crd.y );
+    }
+
+    return true;
+}
+
+
+bool dxfRW::writeXline( DRW_Xline* ent )
+{
+    writer->writeString( 0, "XLINE" );
+    writeEntity( ent );
+
+    if( version > DRW::AC1009 )
+    {
+        writer->writeString( 100, "AcDbXline" );
+    }
+
+    DRW_Coord crd = ent->secPoint;
+    crd.unitize();
+    writer->writeDouble( 10, ent->basePoint.x );
+    writer->writeDouble( 20, ent->basePoint.y );
+
+    if( ent->basePoint.z != 0.0 || ent->secPoint.z != 0.0 )
+    {
+        writer->writeDouble( 30, ent->basePoint.z );
+        writer->writeDouble( 11, crd.x );
+        writer->writeDouble( 21, crd.y );
+        writer->writeDouble( 31, crd.z );
+    }
+    else
+    {
+        writer->writeDouble( 11, crd.x );
+        writer->writeDouble( 21, crd.y );
+    }
+
+    return true;
+}
+
+
+bool dxfRW::writeCircle( DRW_Circle* ent )
+{
+    writer->writeString( 0, "CIRCLE" );
+    writeEntity( ent );
+
+    if( version > DRW::AC1009 )
+    {
+        writer->writeString( 100, "AcDbCircle" );
+    }
+
+    writer->writeDouble( 10, ent->basePoint.x );
+    writer->writeDouble( 20, ent->basePoint.y );
+
+    if( ent->basePoint.z != 0.0 )
+    {
+        writer->writeDouble( 30, ent->basePoint.z );
+    }
+
+    writer->writeDouble( 40, ent->radious );
+    return true;
+}
+
+
+bool dxfRW::writeArc( DRW_Arc* ent )
+{
+    writer->writeString( 0, "ARC" );
+    writeEntity( ent );
+
+    if( version > DRW::AC1009 )
+    {
+        writer->writeString( 100, "AcDbCircle" );
+    }
+
+    writer->writeDouble( 10, ent->basePoint.x );
+    writer->writeDouble( 20, ent->basePoint.y );
+
+    if( ent->basePoint.z != 0.0 )
+    {
+        writer->writeDouble( 30, ent->basePoint.z );
+    }
+
+    writer->writeDouble( 40, ent->radious );
+
+    if( version > DRW::AC1009 )
+    {
+        writer->writeString( 100, "AcDbArc" );
+    }
+
+    writer->writeDouble( 50, ent->staangle * ARAD );
+    writer->writeDouble( 51, ent->endangle * ARAD );
+    return true;
+}
+
+
+bool dxfRW::writeEllipse( DRW_Ellipse* ent )
+{
+    // verify axis/ratio and params for full ellipse
+    ent->correctAxis();
+
+    if( version > DRW::AC1009 )
+    {
+        writer->writeString( 0, "ELLIPSE" );
+        writeEntity( ent );
+
+        if( version > DRW::AC1009 )
+        {
+            writer->writeString( 100, "AcDbEllipse" );
+        }
+
+        writer->writeDouble( 10, ent->basePoint.x );
+        writer->writeDouble( 20, ent->basePoint.y );
+        writer->writeDouble( 30, ent->basePoint.z );
+        writer->writeDouble( 11, ent->secPoint.x );
+        writer->writeDouble( 21, ent->secPoint.y );
+        writer->writeDouble( 31, ent->secPoint.z );
+        writer->writeDouble( 40, ent->ratio );
+        writer->writeDouble( 41, ent->staparam );
+        writer->writeDouble( 42, ent->endparam );
+    }
+    else
+    {
+        DRW_Polyline pol;
+        // RLZ: copy properties
+        ent->toPolyline( &pol, elParts );
+        writePolyline( &pol );
+    }
+
+    return true;
+}
+
+
+bool dxfRW::writeTrace( DRW_Trace* ent )
+{
+    writer->writeString( 0, "TRACE" );
+    writeEntity( ent );
+
+    if( version > DRW::AC1009 )
+    {
+        writer->writeString( 100, "AcDbTrace" );
+    }
+
+    writer->writeDouble( 10, ent->basePoint.x );
+    writer->writeDouble( 20, ent->basePoint.y );
+    writer->writeDouble( 30, ent->basePoint.z );
+    writer->writeDouble( 11, ent->secPoint.x );
+    writer->writeDouble( 21, ent->secPoint.y );
+    writer->writeDouble( 31, ent->secPoint.z );
+    writer->writeDouble( 12, ent->thirdPoint.x );
+    writer->writeDouble( 22, ent->thirdPoint.y );
+    writer->writeDouble( 32, ent->thirdPoint.z );
+    writer->writeDouble( 13, ent->fourPoint.x );
+    writer->writeDouble( 23, ent->fourPoint.y );
+    writer->writeDouble( 33, ent->fourPoint.z );
+    return true;
+}
+
+
+bool dxfRW::writeSolid( DRW_Solid* ent )
+{
+    writer->writeString( 0, "SOLID" );
+    writeEntity( ent );
+
+    if( version > DRW::AC1009 )
+    {
+        writer->writeString( 100, "AcDbTrace" );
+    }
+
+    writer->writeDouble( 10, ent->basePoint.x );
+    writer->writeDouble( 20, ent->basePoint.y );
+    writer->writeDouble( 30, ent->basePoint.z );
+    writer->writeDouble( 11, ent->secPoint.x );
+    writer->writeDouble( 21, ent->secPoint.y );
+    writer->writeDouble( 31, ent->secPoint.z );
+    writer->writeDouble( 12, ent->thirdPoint.x );
+    writer->writeDouble( 22, ent->thirdPoint.y );
+    writer->writeDouble( 32, ent->thirdPoint.z );
+    writer->writeDouble( 13, ent->fourPoint.x );
+    writer->writeDouble( 23, ent->fourPoint.y );
+    writer->writeDouble( 33, ent->fourPoint.z );
+    return true;
+}
+
+
+bool dxfRW::write3dface( DRW_3Dface* ent )
+{
+    writer->writeString( 0, "3DFACE" );
+    writeEntity( ent );
+
+    if( version > DRW::AC1009 )
+    {
+        writer->writeString( 100, "AcDbFace" );
+    }
+
+    writer->writeDouble( 10, ent->basePoint.x );
+    writer->writeDouble( 20, ent->basePoint.y );
+    writer->writeDouble( 30, ent->basePoint.z );
+    writer->writeDouble( 11, ent->secPoint.x );
+    writer->writeDouble( 21, ent->secPoint.y );
+    writer->writeDouble( 31, ent->secPoint.z );
+    writer->writeDouble( 12, ent->thirdPoint.x );
+    writer->writeDouble( 22, ent->thirdPoint.y );
+    writer->writeDouble( 32, ent->thirdPoint.z );
+    writer->writeDouble( 13, ent->fourPoint.x );
+    writer->writeDouble( 23, ent->fourPoint.y );
+    writer->writeDouble( 33, ent->fourPoint.z );
+    writer->writeInt16( 70, ent->invisibleflag );
+    return true;
+}
+
+
+bool dxfRW::writeLWPolyline( DRW_LWPolyline* ent )
+{
+    if( version > DRW::AC1009 )
+    {
+        writer->writeString( 0, "LWPOLYLINE" );
+        writeEntity( ent );
+
+        if( version > DRW::AC1009 )
+        {
+            writer->writeString( 100, "AcDbPolyline" );
+        }
+
+        ent->vertexnum = ent->vertlist.size();
+        writer->writeInt32( 90, ent->vertexnum );
+        writer->writeInt16( 70, ent->flags );
+        writer->writeDouble( 43, ent->width );
+
+        if( ent->elevation != 0 )
+            writer->writeDouble( 38, ent->elevation );
+
+        if( ent->thickness != 0 )
+            writer->writeDouble( 39, ent->thickness );
+
+        for( int i = 0; i< ent->vertexnum; i++ )
+        {
+            DRW_Vertex2D* v = ent->vertlist.at( i );
+            writer->writeDouble( 10, v->x );
+            writer->writeDouble( 20, v->y );
+
+            if( v->stawidth != 0 )
+                writer->writeDouble( 40, v->stawidth );
+
+            if( v->endwidth != 0 )
+                writer->writeDouble( 41, v->endwidth );
+
+            if( v->bulge != 0 )
+                writer->writeDouble( 42, v->bulge );
+        }
+    }
+    else
+    {
+        // RLZ: TODO convert lwpolyline in polyline (not exist in acad 12)
+    }
+
+    return true;
+}
+
+
+bool dxfRW::writePolyline( DRW_Polyline* ent )
+{
+    writer->writeString( 0, "POLYLINE" );
+    writeEntity( ent );
+
+    if( version > DRW::AC1009 )
+    {
+        if( ent->flags & 8 || ent->flags & 16 )
+            writer->writeString( 100, "AcDb2dPolyline" );
+        else
+            writer->writeString( 100, "AcDb3dPolyline" );
+    }
+    else
+        writer->writeInt16( 66, 1 );
+
+    writer->writeDouble( 10, 0.0 );
+    writer->writeDouble( 20, 0.0 );
+    writer->writeDouble( 30, ent->basePoint.z );
+
+    if( ent->thickness != 0 )
+    {
+        writer->writeDouble( 39, ent->thickness );
+    }
+
+    writer->writeInt16( 70, ent->flags );
+
+    if( ent->defstawidth != 0 )
+    {
+        writer->writeDouble( 40, ent->defstawidth );
+    }
+
+    if( ent->defendwidth != 0 )
+    {
+        writer->writeDouble( 41, ent->defendwidth );
+    }
+
+    if( ent->flags & 16 || ent->flags & 32 )
+    {
+        writer->writeInt16( 71, ent->vertexcount );
+        writer->writeInt16( 72, ent->facecount );
+    }
+
+    if( ent->smoothM != 0 )
+    {
+        writer->writeInt16( 73, ent->smoothM );
+    }
+
+    if( ent->smoothN != 0 )
+    {
+        writer->writeInt16( 74, ent->smoothN );
+    }
+
+    if( ent->curvetype != 0 )
+    {
+        writer->writeInt16( 75, ent->curvetype );
+    }
+
+    DRW_Coord crd = ent->extPoint;
+
+    if( crd.x != 0 || crd.y != 0 || crd.z != 1 )
+    {
+        writer->writeDouble( 210, crd.x );
+        writer->writeDouble( 220, crd.y );
+        writer->writeDouble( 230, crd.z );
+    }
+
+    int vertexnum = ent->vertlist.size();
+
+    for( int i = 0; i< vertexnum; i++ )
+    {
+        DRW_Vertex* v = ent->vertlist.at( i );
+        writer->writeString( 0, "VERTEX" );
+        writeEntity( ent );
+
+        if( version > DRW::AC1009 )
+            writer->writeString( 100, "AcDbVertex" );
+
+        if( (v->flags & 128) && !(v->flags & 64) )
+        {
+            writer->writeDouble( 10, 0 );
+            writer->writeDouble( 20, 0 );
+            writer->writeDouble( 30, 0 );
+        }
+        else
+        {
+            writer->writeDouble( 10, v->basePoint.x );
+            writer->writeDouble( 20, v->basePoint.y );
+            writer->writeDouble( 30, v->basePoint.z );
+        }
+
+        if( v->stawidth != 0 )
+            writer->writeDouble( 40, v->stawidth );
+
+        if( v->endwidth != 0 )
+            writer->writeDouble( 41, v->endwidth );
+
+        if( v->bulge != 0 )
+            writer->writeDouble( 42, v->bulge );
+
+        if( v->flags != 0 )
+        {
+            writer->writeInt16( 70, ent->flags );
+        }
+
+        if( v->flags & 2 )
+        {
+            writer->writeDouble( 50, v->tgdir );
+        }
+
+        if( v->flags & 128 )
+        {
+            if( v->vindex1 != 0 )
+            {
+                writer->writeInt16( 71, v->vindex1 );
+            }
+
+            if( v->vindex2 != 0 )
+            {
+                writer->writeInt16( 72, v->vindex2 );
+            }
+
+            if( v->vindex3 != 0 )
+            {
+                writer->writeInt16( 73, v->vindex3 );
+            }
+
+            if( v->vindex4 != 0 )
+            {
+                writer->writeInt16( 74, v->vindex4 );
+            }
+
+            if( !(v->flags & 64) )
+            {
+                writer->writeInt32( 91, v->identifier );
+            }
+        }
+    }
+
+    writer->writeString( 0, "SEQEND" );
+    writeEntity( ent );
+    return true;
+}
+
+
+bool dxfRW::writeSpline( DRW_Spline* ent )
+{
+    if( version > DRW::AC1009 )
+    {
+        writer->writeString( 0, "SPLINE" );
+        writeEntity( ent );
+
+        if( version > DRW::AC1009 )
+        {
+            writer->writeString( 100, "AcDbSpline" );
+        }
+
+        writer->writeDouble( 210, ent->ex );
+        writer->writeDouble( 220, ent->ey );
+        writer->writeDouble( 230, ent->ez );
+        writer->writeInt16( 70, ent->flags );
+        writer->writeInt16( 71, ent->degree );
+        writer->writeInt16( 72, ent->nknots );
+        writer->writeInt16( 73, ent->ncontrol );
+        writer->writeInt16( 74, ent->nfit );
+        writer->writeDouble( 42, ent->tolknot );
+        writer->writeDouble( 43, ent->tolcontrol );
+
+        // RLZ: warning check if nknots are correct and ncontrol
+        for( int i = 0; i< ent->nknots; i++ )
+        {
+            writer->writeDouble( 40, ent->knotslist.at( i ) );
+        }
+
+        for( int i = 0; i< ent->ncontrol; i++ )
+        {
+            DRW_Coord* crd = ent->controllist.at( i );
+            writer->writeDouble( 10, crd->x );
+            writer->writeDouble( 20, crd->y );
+            writer->writeDouble( 30, crd->z );
+        }
+    }
+    else
+    {
+        // RLZ: TODO convert spline in polyline (not exist in acad 12)
+    }
+
+    return true;
+}
+
+
+bool dxfRW::writeHatch( DRW_Hatch* ent )
+{
+    if( version > DRW::AC1009 )
+    {
+        writer->writeString( 0, "HATCH" );
+        writeEntity( ent );
+        writer->writeString( 100, "AcDbHatch" );
+        writer->writeDouble( 10, 0.0 );
+        writer->writeDouble( 20, 0.0 );
+        writer->writeDouble( 30, ent->basePoint.z );
+        writer->writeDouble( 210, ent->extPoint.x );
+        writer->writeDouble( 220, ent->extPoint.y );
+        writer->writeDouble( 230, ent->extPoint.z );
+        writer->writeString( 2, ent->name );
+        writer->writeInt16( 70, ent->solid );
+        writer->writeInt16( 71, ent->associative );
+        ent->loopsnum = ent->looplist.size();
+        writer->writeInt16( 91, ent->loopsnum );
+
+        // write paths data
+        for( int i = 0; i< ent->loopsnum; i++ )
+        {
+            DRW_HatchLoop* loop = ent->looplist.at( i );
+            writer->writeInt16( 92, loop->type );
+
+            if( (loop->type & 2) == 2 )
+            {
+                // RLZ: polyline boundary writeme
+            }
+            else
+            {
+                // boundary path
+                loop->update();
+                writer->writeInt16( 93, loop->numedges );
+
+                for( int j = 0; j<loop->numedges; ++j )
+                {
+                    switch( ( loop->objlist.at( j ) )->eType )
+                    {
+                    case DRW::LINE:
+                        {
+                            writer->writeInt16( 72, 1 );
+                            DRW_Line* l = (DRW_Line*) loop->objlist.at( j );
+                            writer->writeDouble( 10, l->basePoint.x );
+                            writer->writeDouble( 20, l->basePoint.y );
+                            writer->writeDouble( 11, l->secPoint.x );
+                            writer->writeDouble( 21, l->secPoint.y );
+                            break;
+                        }
+
+                    case DRW::ARC:
+                        {
+                            writer->writeInt16( 72, 2 );
+                            DRW_Arc* a = (DRW_Arc*) loop->objlist.at( j );
+                            writer->writeDouble( 10, a->basePoint.x );
+                            writer->writeDouble( 20, a->basePoint.y );
+                            writer->writeDouble( 40, a->radious );
+                            writer->writeDouble( 50, a->staangle * ARAD );
+                            writer->writeDouble( 51, a->endangle * ARAD );
+                            writer->writeInt16( 73, a->isccw );
+                            break;
+                        }
+
+                    case DRW::ELLIPSE:
+                        {
+                            writer->writeInt16( 72, 3 );
+                            DRW_Ellipse* a = (DRW_Ellipse*) loop->objlist.at( j );
+                            a->correctAxis();
+                            writer->writeDouble( 10, a->basePoint.x );
+                            writer->writeDouble( 20, a->basePoint.y );
+                            writer->writeDouble( 11, a->secPoint.x );
+                            writer->writeDouble( 21, a->secPoint.y );
+                            writer->writeDouble( 40, a->ratio );
+                            writer->writeDouble( 50, a->staparam * ARAD );
+                            writer->writeDouble( 51, a->endparam * ARAD );
+                            writer->writeInt16( 73, a->isccw );
+                            break;
+                        }
+
+                    case DRW::SPLINE:
+                        // RLZ: spline boundary writeme
+// writer->writeInt16(72, 4);
+                        break;
+
+                    default:
+                        break;
+                    }
+                }
+
+                writer->writeInt16( 97, 0 );
+            }
+        }
+
+        writer->writeInt16( 75, ent->hstyle );
+        writer->writeInt16( 76, ent->hpattern );
+
+        if( !ent->solid )
+        {
+            writer->writeDouble( 52, ent->angle );
+            writer->writeDouble( 41, ent->scale );
+            writer->writeInt16( 77, ent->doubleflag );
+            writer->writeInt16( 78, ent->deflines );
+        }
+
+/*        if (ent->deflines > 0){
+ *           writer->writeInt16(78, ent->deflines);
+ *       }*/
+        writer->writeInt32( 98, 0 );
+    }
+    else
+    {
+        // RLZ: TODO verify in acad12
+    }
+
+    return true;
+}
+
+
+bool dxfRW::writeLeader( DRW_Leader* ent )
+{
+    if( version > DRW::AC1009 )
+    {
+        writer->writeString( 0, "LEADER" );
+        writeEntity( ent );
+        writer->writeString( 100, "AcDbLeader" );
+        writer->writeUtf8String( 3, ent->style );
+        writer->writeInt16( 71, ent->arrow );
+        writer->writeInt16( 72, ent->leadertype );
+        writer->writeInt16( 73, ent->flag );
+        writer->writeInt16( 74, ent->hookline );
+        writer->writeInt16( 75, ent->hookflag );
+        writer->writeDouble( 40, ent->textheight );
+        writer->writeDouble( 41, ent->textwidth );
+        writer->writeDouble( 76, ent->vertnum );
+        writer->writeDouble( 76, ent->vertexlist.size() );
+
+        for( unsigned int i = 0; i<ent->vertexlist.size(); i++ )
+        {
+            DRW_Coord* vert = ent->vertexlist.at( i );
+            writer->writeDouble( 10, vert->x );
+            writer->writeDouble( 20, vert->y );
+            writer->writeDouble( 30, vert->z );
+        }
+    }
+    else
+    {
+        // RLZ: todo not supported by acad 12 saved as unnamed block
+    }
+
+    return true;
+}
+
+
+bool dxfRW::writeDimension( DRW_Dimension* ent )
+{
+    if( version > DRW::AC1009 )
+    {
+        writer->writeString( 0, "DIMENSION" );
+        writeEntity( ent );
+        writer->writeString( 100, "AcDbDimension" );
+// writer->writeString(2, ent->name);
+        writer->writeDouble( 10, ent->getDefPoint().x );
+        writer->writeDouble( 20, ent->getDefPoint().y );
+        writer->writeDouble( 30, ent->getDefPoint().z );
+        writer->writeDouble( 11, ent->getTextPoint().x );
+        writer->writeDouble( 21, ent->getTextPoint().y );
+        writer->writeDouble( 31, ent->getTextPoint().z );
+
+        if( !(ent->type & 32) )
+            ent->type = ent->type + 32;
+
+        writer->writeInt16( 70, ent->type );
+
+        if( !( ent->getText().empty() ) )
+            writer->writeUtf8String( 1, ent->getText() );
+
+        writer->writeInt16( 71, ent->getAlign() );
+
+        if( ent->getTextLineStyle() != 1 )
+            writer->writeInt16( 72, ent->getTextLineStyle() );
+
+        if( ent->getTextLineFactor() != 1 )
+            writer->writeDouble( 41, ent->getTextLineFactor() );
+
+        writer->writeUtf8String( 3, ent->getStyle() );
+
+        if( ent->getTextLineFactor() != 0 )
+            writer->writeDouble( 53, ent->getDir() );
+
+        writer->writeDouble( 210, ent->getExtrusion().x );
+        writer->writeDouble( 220, ent->getExtrusion().y );
+        writer->writeDouble( 230, ent->getExtrusion().z );
+
+        switch( ent->eType )
+        {
+        case DRW::DIMALIGNED:
+        case DRW::DIMLINEAR:
+            {
+                DRW_DimAligned* dd = (DRW_DimAligned*) ent;
+                writer->writeString( 100, "AcDbAlignedDimension" );
+                DRW_Coord       crd = dd->getClonepoint();
+
+                if( crd.x != 0 || crd.y != 0 || crd.z != 0 )
+                {
+                    writer->writeDouble( 12, crd.x );
+                    writer->writeDouble( 22, crd.y );
+                    writer->writeDouble( 32, crd.z );
+                }
+
+                writer->writeDouble( 13, dd->getDef1Point().x );
+                writer->writeDouble( 23, dd->getDef1Point().y );
+                writer->writeDouble( 33, dd->getDef1Point().z );
+                writer->writeDouble( 14, dd->getDef2Point().x );
+                writer->writeDouble( 24, dd->getDef2Point().y );
+                writer->writeDouble( 34, dd->getDef2Point().z );
+
+                if( ent->eType == DRW::DIMLINEAR )
+                {
+                    DRW_DimLinear* dl = (DRW_DimLinear*) ent;
+
+                    if( dl->getAngle() != 0 )
+                        writer->writeDouble( 50, dl->getAngle() );
+
+                    if( dl->getOblique() != 0 )
+                        writer->writeDouble( 52, dl->getOblique() );
+
+                    writer->writeString( 100, "AcDbRotatedDimension" );
+                }
+
+                break;
+            }
+
+        case DRW::DIMRADIAL:
+            {
+                DRW_DimRadial* dd = (DRW_DimRadial*) ent;
+                writer->writeString( 100, "AcDbRadialDimension" );
+                writer->writeDouble( 15, dd->getDiameterPoint().x );
+                writer->writeDouble( 25, dd->getDiameterPoint().y );
+                writer->writeDouble( 35, dd->getDiameterPoint().z );
+                writer->writeDouble( 40, dd->getLeaderLength() );
+                break;
+            }
+
+        case DRW::DIMDIAMETRIC:
+            {
+                DRW_DimDiametric* dd = (DRW_DimDiametric*) ent;
+                writer->writeString( 100, "AcDbDiametricDimension" );
+                writer->writeDouble( 15, dd->getDiameter1Point().x );
+                writer->writeDouble( 25, dd->getDiameter1Point().y );
+                writer->writeDouble( 35, dd->getDiameter1Point().z );
+                writer->writeDouble( 40, dd->getLeaderLength() );
+                break;
+            }
+
+        case DRW::DIMANGULAR:
+            {
+                DRW_DimAngular* dd = (DRW_DimAngular*) ent;
+                writer->writeString( 100, "AcDb2LineAngularDimension" );
+                writer->writeDouble( 13, dd->getFirstLine1().x );
+                writer->writeDouble( 23, dd->getFirstLine1().y );
+                writer->writeDouble( 33, dd->getFirstLine1().z );
+                writer->writeDouble( 14, dd->getFirstLine2().x );
+                writer->writeDouble( 24, dd->getFirstLine2().y );
+                writer->writeDouble( 34, dd->getFirstLine2().z );
+                writer->writeDouble( 15, dd->getSecondLine1().x );
+                writer->writeDouble( 25, dd->getSecondLine1().y );
+                writer->writeDouble( 35, dd->getSecondLine1().z );
+                writer->writeDouble( 16, dd->getDimPoint().x );
+                writer->writeDouble( 26, dd->getDimPoint().y );
+                writer->writeDouble( 36, dd->getDimPoint().z );
+                break;
+            }
+
+        case DRW::DIMANGULAR3P:
+            {
+                DRW_DimAngular3p* dd = (DRW_DimAngular3p*) ent;
+                writer->writeDouble( 13, dd->getFirstLine().x );
+                writer->writeDouble( 23, dd->getFirstLine().y );
+                writer->writeDouble( 33, dd->getFirstLine().z );
+                writer->writeDouble( 14, dd->getSecondLine().x );
+                writer->writeDouble( 24, dd->getSecondLine().y );
+                writer->writeDouble( 34, dd->getSecondLine().z );
+                writer->writeDouble( 15, dd->getVertexPoint().x );
+                writer->writeDouble( 25, dd->getVertexPoint().y );
+                writer->writeDouble( 35, dd->getVertexPoint().z );
+                break;
+            }
+
+        case DRW::DIMORDINATE:
+            {
+                DRW_DimOrdinate* dd = (DRW_DimOrdinate*) ent;
+                writer->writeString( 100, "AcDbOrdinateDimension" );
+                writer->writeDouble( 13, dd->getFirstLine().x );
+                writer->writeDouble( 23, dd->getFirstLine().y );
+                writer->writeDouble( 33, dd->getFirstLine().z );
+                writer->writeDouble( 14, dd->getSecondLine().x );
+                writer->writeDouble( 24, dd->getSecondLine().y );
+                writer->writeDouble( 34, dd->getSecondLine().z );
+                break;
+            }
+
+        default:
+            break;
+        }
+    }
+    else
+    {
+        // RLZ: todo not supported by acad 12 saved as unnamed block
+    }
+
+    return true;
+}
+
+
+bool dxfRW::writeInsert( DRW_Insert* ent )
+{
+    writer->writeString( 0, "INSERT" );
+    writeEntity( ent );
+
+    if( version > DRW::AC1009 )
+    {
+        writer->writeString( 100, "AcDbBlockReference" );
+        writer->writeUtf8String( 2, ent->name );
+    }
+    else
+        writer->writeUtf8Caps( 2, ent->name );
+
+    writer->writeDouble( 10, ent->basePoint.x );
+    writer->writeDouble( 20, ent->basePoint.y );
+    writer->writeDouble( 30, ent->basePoint.z );
+    writer->writeDouble( 41, ent->xscale );
+    writer->writeDouble( 42, ent->yscale );
+    writer->writeDouble( 43, ent->zscale );
+    writer->writeDouble( 50, ent->angle );
+    writer->writeInt16( 70, ent->colcount );
+    writer->writeInt16( 71, ent->rowcount );
+    writer->writeDouble( 44, ent->colspace );
+    writer->writeDouble( 45, ent->rowspace );
+    return true;
+}
+
+
+bool dxfRW::writeText( DRW_Text* ent )
+{
+    writer->writeString( 0, "TEXT" );
+    writeEntity( ent );
+
+    if( version > DRW::AC1009 )
+    {
+        writer->writeString( 100, "AcDbText" );
+    }
+
+// writer->writeDouble(39, ent->thickness);
+    writer->writeDouble( 10, ent->basePoint.x );
+    writer->writeDouble( 20, ent->basePoint.y );
+    writer->writeDouble( 30, ent->basePoint.z );
+    writer->writeDouble( 40, ent->height );
+    writer->writeUtf8String( 1, ent->text );
+    writer->writeDouble( 50, ent->angle );
+    writer->writeDouble( 41, ent->widthscale );
+    writer->writeDouble( 51, ent->oblique );
+
+    if( version > DRW::AC1009 )
+        writer->writeUtf8String( 7, ent->style );
+    else
+        writer->writeUtf8Caps( 7, ent->style );
+
+    writer->writeInt16( 71, ent->textgen );
+
+    if( ent->alignH != DRW_Text::HLeft )
+    {
+        writer->writeInt16( 72, ent->alignH );
+    }
+
+    if( ent->alignH != DRW_Text::HLeft || ent->alignV != DRW_Text::VBaseLine )
+    {
+        writer->writeDouble( 11, ent->secPoint.x );
+        writer->writeDouble( 21, ent->secPoint.y );
+        writer->writeDouble( 31, ent->secPoint.z );
+    }
+
+    writer->writeDouble( 210, ent->extPoint.x );
+    writer->writeDouble( 220, ent->extPoint.y );
+    writer->writeDouble( 230, ent->extPoint.z );
+
+    if( version > DRW::AC1009 )
+    {
+        writer->writeString( 100, "AcDbText" );
+    }
+
+    if( ent->alignV != DRW_Text::VBaseLine )
+    {
+        writer->writeInt16( 73, ent->alignV );
+    }
+
+    return true;
+}
+
+
+bool dxfRW::writeMText( DRW_MText* ent )
+{
+    if( version > DRW::AC1009 )
+    {
+        writer->writeString( 0, "MTEXT" );
+        writeEntity( ent );
+        writer->writeString( 100, "AcDbMText" );
+        writer->writeDouble( 10, ent->basePoint.x );
+        writer->writeDouble( 20, ent->basePoint.y );
+        writer->writeDouble( 30, ent->basePoint.z );
+        writer->writeDouble( 40, ent->height );
+        writer->writeDouble( 41, ent->widthscale );
+        writer->writeInt16( 71, ent->textgen );
+        writer->writeInt16( 72, ent->alignH );
+        std::string text = writer->fromUtf8String( ent->text );
+
+        int         i;
+
+        for( i = 0; (text.size() - i) > 250; )
+        {
+            writer->writeString( 3, text.substr( i, 250 ) );
+            i += 250;
+        }
+
+        writer->writeString( 1, text.substr( i ) );
+        writer->writeString( 7, ent->style );
+        writer->writeDouble( 210, ent->extPoint.x );
+        writer->writeDouble( 220, ent->extPoint.y );
+        writer->writeDouble( 230, ent->extPoint.z );
+        writer->writeDouble( 50, ent->angle );
+        writer->writeInt16( 73, ent->alignV );
+        writer->writeDouble( 44, ent->interlin );
+// RLZ ... 11, 21, 31 needed?
+    }
+    else
+    {
+        // RLZ: TODO convert mtext in text lines (not exist in acad 12)
+    }
+
+    return true;
+}
+
+
+bool dxfRW::writeViewport( DRW_Viewport* ent )
+{
+    writer->writeString( 0, "VIEWPORT" );
+    writeEntity( ent );
+
+    if( version > DRW::AC1009 )
+    {
+        writer->writeString( 100, "AcDbViewport" );
+    }
+
+    writer->writeDouble( 10, ent->basePoint.x );
+    writer->writeDouble( 20, ent->basePoint.y );
+
+    if( ent->basePoint.z != 0.0 )
+        writer->writeDouble( 30, ent->basePoint.z );
+
+    writer->writeDouble( 40, ent->pswidth );
+    writer->writeDouble( 41, ent->psheight );
+    writer->writeInt16( 68, ent->vpstatus );
+    writer->writeInt16( 69, ent->vpID );
+    writer->writeDouble( 12, ent->centerPX );       // RLZ: verify if exist in V12
+    writer->writeDouble( 22, ent->centerPY );       // RLZ: verify if exist in V12
+    return true;
+}
+
+
+DRW_ImageDef* dxfRW::writeImage( DRW_Image* ent, std::string name )
+{
+    if( version > DRW::AC1009 )
+    {
+        // search if exist imagedef with this mane (image inserted more than 1 time)
+        // RLZ: imagedef_reactor seem needed to read in acad
+        DRW_ImageDef* id = NULL;
+
+        for( unsigned int i = 0; i<imageDef.size(); i++ )
+        {
+            if( imageDef.at( i )->name == name )
+            {
+                id = imageDef.at( i );
+                continue;
+            }
+        }
+
+        if( id == NULL )
+        {
+            id = new DRW_ImageDef();
+            imageDef.push_back( id );
+            id->handle = toHexStr( ++entCount );
+        }
+
+        id->name = name;
+        std::string idReactor = toHexStr( ++entCount );
+
+        writer->writeString( 0, "IMAGE" );
+        writeEntity( ent );
+        writer->writeString( 100, "AcDbRasterImage" );
+        writer->writeDouble( 10, ent->basePoint.x );
+        writer->writeDouble( 20, ent->basePoint.y );
+        writer->writeDouble( 30, ent->basePoint.z );
+        writer->writeDouble( 11, ent->secPoint.x );
+        writer->writeDouble( 21, ent->secPoint.y );
+        writer->writeDouble( 31, ent->secPoint.z );
+        writer->writeDouble( 12, ent->vx );
+        writer->writeDouble( 22, ent->vy );
+        writer->writeDouble( 32, ent->vz );
+        writer->writeDouble( 13, ent->sizeu );
+        writer->writeDouble( 23, ent->sizev );
+        writer->writeString( 340, id->handle );
+        writer->writeInt16( 70, 1 );
+        writer->writeInt16( 280, ent->clip );
+        writer->writeInt16( 281, ent->brightness );
+        writer->writeInt16( 282, ent->contrast );
+        writer->writeInt16( 283, ent->fade );
+        writer->writeString( 360, idReactor );
+        id->reactors[idReactor] = ent->handle;
+        return id;
+    }
+
+    return NULL;    // not exist in acad 12
+}
+
+
+bool dxfRW::writeBlockRecord( std::string name )
+{
+    if( version > DRW::AC1009 )
+    {
+        writer->writeString( 0, "BLOCK_RECORD" );
+        writer->writeString( 5, toHexStr( ++entCount ) );
+
+        blockMap[name] = entCount;
+        entCount = 2 + entCount;    // reserve 2 for BLOCK & ENDBLOCK
+
+        if( version > DRW::AC1014 )
+        {
+            writer->writeString( 330, "1" );
+        }
+
+        writer->writeString( 100, "AcDbSymbolTableRecord" );
+        writer->writeString( 100, "AcDbBlockTableRecord" );
+        writer->writeUtf8String( 2, name );
+
+        if( version > DRW::AC1018 )
+        {
+            // writer->writeInt16(340, 22);
+            writer->writeInt16( 70, 0 );
+            writer->writeInt16( 280, 1 );
+            writer->writeInt16( 281, 0 );
+        }
+    }
+
+    return true;
+}
+
+
+bool dxfRW::writeBlock( DRW_Block* bk )
+{
+    if( writingBlock )
+    {
+        writer->writeString( 0, "ENDBLK" );
+
+        if( version > DRW::AC1009 )
+        {
+            writer->writeString( 5, toHexStr( currHandle + 2 ) );
+
+            if( version > DRW::AC1014 )
+            {
+                writer->writeString( 330, toHexStr( currHandle ) );
+            }
+
+            writer->writeString( 100, "AcDbEntity" );
+        }
+
+        writer->writeString( 8, "0" );
+
+        if( version > DRW::AC1009 )
+        {
+            writer->writeString( 100, "AcDbBlockEnd" );
+        }
+    }
+
+    writingBlock = true;
+    writer->writeString( 0, "BLOCK" );
+
+    if( version > DRW::AC1009 )
+    {
+        currHandle = ( *( blockMap.find( bk->name ) ) ).second;
+        writer->writeString( 5, toHexStr( currHandle + 1 ) );
+
+        if( version > DRW::AC1014 )
+        {
+            writer->writeString( 330, toHexStr( currHandle ) );
+        }
+
+        writer->writeString( 100, "AcDbEntity" );
+    }
+
+    writer->writeString( 8, "0" );
+
+    if( version > DRW::AC1009 )
+    {
+        writer->writeString( 100, "AcDbBlockBegin" );
+        writer->writeUtf8String( 2, bk->name );
+    }
+    else
+        writer->writeUtf8Caps( 2, bk->name );
+
+    writer->writeInt16( 70, bk->flags );
+    writer->writeDouble( 10, bk->basePoint.x );
+    writer->writeDouble( 20, bk->basePoint.y );
+
+    if( bk->basePoint.z != 0.0 )
+    {
+        writer->writeDouble( 30, bk->basePoint.z );
+    }
+
+    if( version > DRW::AC1009 )
+        writer->writeUtf8String( 3, bk->name );
+    else
+        writer->writeUtf8Caps( 3, bk->name );
+
+    writer->writeString( 1, "" );
+
+    return true;
+}
+
+
+bool dxfRW::writeTables()
+{
+    writer->writeString( 0, "TABLE" );
+    writer->writeString( 2, "VPORT" );
+
+    if( version > DRW::AC1009 )
+    {
+        writer->writeString( 5, "8" );
+
+        if( version > DRW::AC1014 )
+        {
+            writer->writeString( 330, "0" );
+        }
+
+        writer->writeString( 100, "AcDbSymbolTable" );
+    }
+
+    writer->writeInt16( 70, 1 );    // end table def
+/*** VPORT ***/
+    dimstyleStd = false;
+    iface->writeVports();
+
+    if( !dimstyleStd )
+    {
+        DRW_Vport portact;
+        portact.name = "*ACTIVE";
+        writeVport( &portact );
+    }
+
+    writer->writeString( 0, "ENDTAB" );
+/*** LTYPE ***/
+    writer->writeString( 0, "TABLE" );
+    writer->writeString( 2, "LTYPE" );
+
+    if( version > DRW::AC1009 )
+    {
+        writer->writeString( 5, "5" );
+
+        if( version > DRW::AC1014 )
+        {
+            writer->writeString( 330, "0" );
+        }
+
+        writer->writeString( 100, "AcDbSymbolTable" );
+    }
+
+    writer->writeInt16( 70, 4 );    // end table def
+// Mandatory linetypes
+    writer->writeString( 0, "LTYPE" );
+
+    if( version > DRW::AC1009 )
+    {
+        writer->writeString( 5, "14" );
+
+        if( version > DRW::AC1014 )
+        {
+            writer->writeString( 330, "5" );
+        }
+
+        writer->writeString( 100, "AcDbSymbolTableRecord" );
+        writer->writeString( 100, "AcDbLinetypeTableRecord" );
+        writer->writeString( 2, "ByBlock" );
+    }
+    else
+        writer->writeString( 2, "BYBLOCK" );
+
+    writer->writeInt16( 70, 0 );
+    writer->writeString( 3, "" );
+    writer->writeInt16( 72, 65 );
+    writer->writeInt16( 73, 0 );
+    writer->writeDouble( 40, 0.0 );
+
+    writer->writeString( 0, "LTYPE" );
+
+    if( version > DRW::AC1009 )
+    {
+        writer->writeString( 5, "15" );
+
+        if( version > DRW::AC1014 )
+        {
+            writer->writeString( 330, "5" );
+        }
+
+        writer->writeString( 100, "AcDbSymbolTableRecord" );
+        writer->writeString( 100, "AcDbLinetypeTableRecord" );
+        writer->writeString( 2, "ByLayer" );
+    }
+    else
+        writer->writeString( 2, "BYLAYER" );
+
+    writer->writeInt16( 70, 0 );
+    writer->writeString( 3, "" );
+    writer->writeInt16( 72, 65 );
+    writer->writeInt16( 73, 0 );
+    writer->writeDouble( 40, 0.0 );
+
+    writer->writeString( 0, "LTYPE" );
+
+    if( version > DRW::AC1009 )
+    {
+        writer->writeString( 5, "16" );
+
+        if( version > DRW::AC1014 )
+        {
+            writer->writeString( 330, "5" );
+        }
+
+        writer->writeString( 100, "AcDbSymbolTableRecord" );
+        writer->writeString( 100, "AcDbLinetypeTableRecord" );
+        writer->writeString( 2, "Continuous" );
+    }
+    else
+    {
+        writer->writeString( 2, "CONTINUOUS" );
+    }
+
+    writer->writeInt16( 70, 0 );
+    writer->writeString( 3, "Solid line" );
+    writer->writeInt16( 72, 65 );
+    writer->writeInt16( 73, 0 );
+    writer->writeDouble( 40, 0.0 );
+// Aplication linetypes
+    iface->writeLTypes();
+    writer->writeString( 0, "ENDTAB" );
+/*** LAYER ***/
+    writer->writeString( 0, "TABLE" );
+    writer->writeString( 2, "LAYER" );
+
+    if( version > DRW::AC1009 )
+    {
+        writer->writeString( 5, "2" );
+
+        if( version > DRW::AC1014 )
+        {
+            writer->writeString( 330, "0" );
+        }
+
+        writer->writeString( 100, "AcDbSymbolTable" );
+    }
+
+    writer->writeInt16( 70, 1 );    // end table def
+    wlayer0 = false;
+    iface->writeLayers();
+
+    if( !wlayer0 )
+    {
+        DRW_Layer lay0;
+        lay0.name = "0";
+        writeLayer( &lay0 );
+    }
+
+    writer->writeString( 0, "ENDTAB" );
+/*** STYLE ***/
+    writer->writeString( 0, "TABLE" );
+    writer->writeString( 2, "STYLE" );
+
+    if( version > DRW::AC1009 )
+    {
+        writer->writeString( 5, "3" );
+
+        if( version > DRW::AC1014 )
+        {
+            writer->writeString( 330, "0" );
+        }
+
+        writer->writeString( 100, "AcDbSymbolTable" );
+    }
+
+    writer->writeInt16( 70, 3 );    // end table def
+    dimstyleStd = false;
+    iface->writeTextstyles();
+
+    if( !dimstyleStd )
+    {
+        DRW_Textstyle tsty;
+        tsty.name = "Standard";
+        writeTextstyle( &tsty );
+    }
+
+    writer->writeString( 0, "ENDTAB" );
+
+    writer->writeString( 0, "TABLE" );
+    writer->writeString( 2, "VIEW" );
+
+    if( version > DRW::AC1009 )
+    {
+        writer->writeString( 5, "6" );
+
+        if( version > DRW::AC1014 )
+        {
+            writer->writeString( 330, "0" );
+        }
+
+        writer->writeString( 100, "AcDbSymbolTable" );
+    }
+
+    writer->writeInt16( 70, 0 );    // end table def
+    writer->writeString( 0, "ENDTAB" );
+
+    writer->writeString( 0, "TABLE" );
+    writer->writeString( 2, "UCS" );
+
+    if( version > DRW::AC1009 )
+    {
+        writer->writeString( 5, "7" );
+
+        if( version > DRW::AC1014 )
+        {
+            writer->writeString( 330, "0" );
+        }
+
+        writer->writeString( 100, "AcDbSymbolTable" );
+    }
+
+    writer->writeInt16( 70, 0 );    // end table def
+    writer->writeString( 0, "ENDTAB" );
+
+    writer->writeString( 0, "TABLE" );
+    writer->writeString( 2, "APPID" );
+
+    if( version > DRW::AC1009 )
+    {
+        writer->writeString( 5, "9" );
+
+        if( version > DRW::AC1014 )
+        {
+            writer->writeString( 330, "0" );
+        }
+
+        writer->writeString( 100, "AcDbSymbolTable" );
+    }
+
+    writer->writeInt16( 70, 1 );    // end table def
+    writer->writeString( 0, "APPID" );
+
+    if( version > DRW::AC1009 )
+    {
+        writer->writeString( 5, "12" );
+
+        if( version > DRW::AC1014 )
+        {
+            writer->writeString( 330, "9" );
+        }
+
+        writer->writeString( 100, "AcDbSymbolTableRecord" );
+        writer->writeString( 100, "AcDbRegAppTableRecord" );
+    }
+
+    writer->writeString( 2, "ACAD" );
+    writer->writeInt16( 70, 0 );
+    writer->writeString( 0, "ENDTAB" );
+
+    writer->writeString( 0, "TABLE" );
+    writer->writeString( 2, "DIMSTYLE" );
+
+    if( version > DRW::AC1009 )
+    {
+        writer->writeString( 5, "A" );
+
+        if( version > DRW::AC1014 )
+        {
+            writer->writeString( 330, "0" );
+        }
+
+        writer->writeString( 100, "AcDbSymbolTable" );
+    }
+
+    writer->writeInt16( 70, 1 );    // end table def
+
+    if( version > DRW::AC1014 )
+    {
+        writer->writeString( 100, "AcDbDimStyleTable" );
+        writer->writeInt16( 71, 1 );    // end table def
+    }
+
+    dimstyleStd = false;
+    iface->writeDimstyles();
+
+    if( !dimstyleStd )
+    {
+        DRW_Dimstyle dsty;
+        dsty.name = "Standard";
+        writeDimstyle( &dsty );
+    }
+
+    writer->writeString( 0, "ENDTAB" );
+
+    if( version > DRW::AC1009 )
+    {
+        writer->writeString( 0, "TABLE" );
+        writer->writeString( 2, "BLOCK_RECORD" );
+        writer->writeString( 5, "1" );
+
+        if( version > DRW::AC1014 )
+        {
+            writer->writeString( 330, "0" );
+        }
+
+        writer->writeString( 100, "AcDbSymbolTable" );
+        writer->writeInt16( 70, 2 );    // end table def
+        writer->writeString( 0, "BLOCK_RECORD" );
+        writer->writeString( 5, "1F" );
+
+        if( version > DRW::AC1014 )
+        {
+            writer->writeString( 330, "1" );
+        }
+
+        writer->writeString( 100, "AcDbSymbolTableRecord" );
+        writer->writeString( 100, "AcDbBlockTableRecord" );
+        writer->writeString( 2, "*Model_Space" );
+
+        if( version > DRW::AC1018 )
+        {
+            // writer->writeInt16(340, 22);
+            writer->writeInt16( 70, 0 );
+            writer->writeInt16( 280, 1 );
+            writer->writeInt16( 281, 0 );
+        }
+
+        writer->writeString( 0, "BLOCK_RECORD" );
+        writer->writeString( 5, "1E" );
+
+        if( version > DRW::AC1014 )
+        {
+            writer->writeString( 330, "1" );
+        }
+
+        writer->writeString( 100, "AcDbSymbolTableRecord" );
+        writer->writeString( 100, "AcDbBlockTableRecord" );
+        writer->writeString( 2, "*Paper_Space" );
+
+        if( version > DRW::AC1018 )
+        {
+            // writer->writeInt16(340, 22);
+            writer->writeInt16( 70, 0 );
+            writer->writeInt16( 280, 1 );
+            writer->writeInt16( 281, 0 );
+        }
+
+        iface->writeBlockRecords();
+        writer->writeString( 0, "ENDTAB" );
+    }
+
+    return true;
+}
+
+
+bool dxfRW::writeBlocks()
+{
+    writer->writeString( 0, "BLOCK" );
+
+    if( version > DRW::AC1009 )
+    {
+        writer->writeString( 5, "20" );
+
+        if( version > DRW::AC1014 )
+        {
+            writer->writeString( 330, "1F" );
+        }
+
+        writer->writeString( 100, "AcDbEntity" );
+    }
+
+    writer->writeString( 8, "0" );
+
+    if( version > DRW::AC1009 )
+    {
+        writer->writeString( 100, "AcDbBlockBegin" );
+        writer->writeString( 2, "*Model_Space" );
+    }
+    else
+        writer->writeString( 2, "$MODEL_SPACE" );
+
+    writer->writeInt16( 70, 0 );
+    writer->writeDouble( 10, 0.0 );
+    writer->writeDouble( 20, 0.0 );
+    writer->writeDouble( 30, 0.0 );
+
+    if( version > DRW::AC1009 )
+        writer->writeString( 3, "*Model_Space" );
+    else
+        writer->writeString( 3, "$MODEL_SPACE" );
+
+    writer->writeString( 1, "" );
+    writer->writeString( 0, "ENDBLK" );
+
+    if( version > DRW::AC1009 )
+    {
+        writer->writeString( 5, "21" );
+
+        if( version > DRW::AC1014 )
+        {
+            writer->writeString( 330, "1F" );
+        }
+
+        writer->writeString( 100, "AcDbEntity" );
+    }
+
+    writer->writeString( 8, "0" );
+
+    if( version > DRW::AC1009 )
+        writer->writeString( 100, "AcDbBlockEnd" );
+
+    writer->writeString( 0, "BLOCK" );
+
+    if( version > DRW::AC1009 )
+    {
+        writer->writeString( 5, "1C" );
+
+        if( version > DRW::AC1014 )
+        {
+            writer->writeString( 330, "1B" );
+        }
+
+        writer->writeString( 100, "AcDbEntity" );
+    }
+
+    writer->writeString( 8, "0" );
+
+    if( version > DRW::AC1009 )
+    {
+        writer->writeString( 100, "AcDbBlockBegin" );
+        writer->writeString( 2, "*Paper_Space" );
+    }
+    else
+        writer->writeString( 2, "$PAPER_SPACE" );
+
+    writer->writeInt16( 70, 0 );
+    writer->writeDouble( 10, 0.0 );
+    writer->writeDouble( 20, 0.0 );
+    writer->writeDouble( 30, 0.0 );
+
+    if( version > DRW::AC1009 )
+        writer->writeString( 3, "*Paper_Space" );
+    else
+        writer->writeString( 3, "$PAPER_SPACE" );
+
+    writer->writeString( 1, "" );
+    writer->writeString( 0, "ENDBLK" );
+
+    if( version > DRW::AC1009 )
+    {
+        writer->writeString( 5, "1D" );
+
+        if( version > DRW::AC1014 )
+        {
+            writer->writeString( 330, "1F" );
+        }
+
+        writer->writeString( 100, "AcDbEntity" );
+    }
+
+    writer->writeString( 8, "0" );
+
+    if( version > DRW::AC1009 )
+        writer->writeString( 100, "AcDbBlockEnd" );
+
+    writingBlock = false;
+    iface->writeBlocks();
+
+    if( writingBlock )
+    {
+        writingBlock = false;
+        writer->writeString( 0, "ENDBLK" );
+
+        if( version > DRW::AC1009 )
+        {
+            writer->writeString( 5, toHexStr( currHandle + 2 ) );
+
+// writer->writeString(5, "1D");
+            if( version > DRW::AC1014 )
+            {
+                writer->writeString( 330, toHexStr( currHandle ) );
+            }
+
+            writer->writeString( 100, "AcDbEntity" );
+        }
+
+        writer->writeString( 8, "0" );
+
+        if( version > DRW::AC1009 )
+            writer->writeString( 100, "AcDbBlockEnd" );
+    }
+
+    return true;
+}
+
+
+bool dxfRW::writeObjects()
+{
+    writer->writeString( 0, "DICTIONARY" );
+    std::string imgDictH;
+    writer->writeString( 5, "C" );
+
+    if( version > DRW::AC1014 )
+    {
+        writer->writeString( 330, "0" );
+    }
+
+    writer->writeString( 100, "AcDbDictionary" );
+    writer->writeInt16( 281, 1 );
+    writer->writeString( 3, "ACAD_GROUP" );
+    writer->writeString( 350, "D" );
+
+    if( imageDef.size() != 0 )
+    {
+        writer->writeString( 3, "ACAD_IMAGE_DICT" );
+        imgDictH = toHexStr( ++entCount );
+        writer->writeString( 350, imgDictH );
+    }
+
+    writer->writeString( 0, "DICTIONARY" );
+    writer->writeString( 5, "D" );
+    writer->writeString( 330, "C" );
+    writer->writeString( 100, "AcDbDictionary" );
+    writer->writeInt16( 281, 1 );
+
+// write IMAGEDEF_REACTOR
+    for( unsigned int i = 0; i<imageDef.size(); i++ )
+    {
+        DRW_ImageDef* id = imageDef.at( i );
+        std::map<string, string>::iterator it;
+
+        for( it = id->reactors.begin(); it != id->reactors.end(); it++ )
+        {
+            writer->writeString( 0, "IMAGEDEF_REACTOR" );
+            writer->writeString( 5, (*it).first );
+            writer->writeString( 330, (*it).second );
+            writer->writeString( 100, "AcDbRasterImageDefReactor" );
+            writer->writeInt16( 90, 2 );    // version 2=R14 to v2010
+            writer->writeString( 330, (*it).second );
+        }
+    }
+
+    if( imageDef.size() != 0 )
+    {
+        writer->writeString( 0, "DICTIONARY" );
+        writer->writeString( 5, imgDictH );
+        writer->writeString( 330, "C" );
+        writer->writeString( 100, "AcDbDictionary" );
+        writer->writeInt16( 281, 1 );
+
+        for( unsigned int i = 0; i<imageDef.size(); i++ )
+        {
+            size_t f1, f2;
+            f1  = imageDef.at( i )->name.find_last_of( "/\\" );
+            f2  = imageDef.at( i )->name.find_last_of( '.' );
+            ++f1;
+            writer->writeString( 3, imageDef.at( i )->name.substr( f1, f2 - f1 ) );
+            writer->writeString( 350, imageDef.at( i )->handle );
+        }
+    }
+
+    for( unsigned int i = 0; i<imageDef.size(); i++ )
+    {
+        DRW_ImageDef* id = imageDef.at( i );
+        writer->writeString( 0, "IMAGEDEF" );
+        writer->writeString( 5, id->handle );
+
+        if( version > DRW::AC1014 )
+        {
+// writer->writeString(330, "0"); handle to DICTIONARY
+        }
+
+        writer->writeString( 102, "{ACAD_REACTORS" );
+        std::map<string, string>::iterator it;
+
+        for( it = id->reactors.begin(); it != id->reactors.end(); it++ )
+        {
+            writer->writeString( 330, (*it).first );
+        }
+
+        writer->writeString( 102, "}" );
+        writer->writeString( 100, "AcDbRasterImageDef" );
+        writer->writeInt16( 90, 0 );    // version 0=R14 to v2010
+        writer->writeUtf8String( 1, id->name );
+        writer->writeDouble( 10, id->u );
+        writer->writeDouble( 20, id->v );
+        writer->writeDouble( 11, id->up );
+        writer->writeDouble( 21, id->vp );
+        writer->writeInt16( 280, id->loaded );
+        writer->writeInt16( 281, id->resolution );
+    }
+
+    // no more needed imageDef, delete it
+    while( !imageDef.empty() )
+    {
+        imageDef.pop_back();
+    }
+
+    return true;
+}
+
+
+/********* Reader Process *********/
+
+bool dxfRW::processDxf()
+{
+    DBG( "dxfRW::processDxf() start processing dxf\n" );
+    int     code;
+    bool    more = true;
+    string  sectionstr;
+
+// section = secUnknown;
+    while( reader->readRec( &code, !binary ) )
+    {
+        DBG( code ); DBG( " processDxf\n" );
+
+        if( code == 999 )
+        {
+            header.addComment( reader->getString() );
+        }
+        else if( code == 0 )
+        {
+            sectionstr = reader->getString();
+            DBG( sectionstr ); DBG( " processDxf\n" );
+
+            if( sectionstr == "EOF" )
+            {
+                return true;    // found EOF terminate
+            }
+
+            if( sectionstr == "SECTION" )
+            {
+                more = reader->readRec( &code, !binary );
+                DBG( code ); DBG( " processDxf\n" );
+
+                if( !more )
+                    return false; // wrong dxf file
+
+                if( code == 2 )
+                {
+                    sectionstr = reader->getString();
+                    DBG( sectionstr ); DBG( "  processDxf\n" );
+
+                    // found section, process it
+                    if( sectionstr == "HEADER" )
+                    {
+                        processHeader();
+                    }
+                    else if( sectionstr == "CLASSES" )
+                    {
+// processClasses();
+                    }
+                    else if( sectionstr == "TABLES" )
+                    {
+                        processTables();
+                    }
+                    else if( sectionstr == "BLOCKS" )
+                    {
+                        processBlocks();
+                    }
+                    else if( sectionstr == "ENTITIES" )
+                    {
+                        processEntities( false );
+                    }
+                    else if( sectionstr == "OBJECTS" )
+                    {
+                        processObjects();
+                    }
+                }
+            }
+        }
+
+/*    if (!more)
+ *       return true;*/
+    }
+
+    return true;
+}
+
+
+/********* Header Section *********/
+
+bool dxfRW::processHeader()
+{
+    DBG( "dxfRW::processHeader\n" );
+    int     code;
+    string  sectionstr;
+
+    while( reader->readRec( &code, !binary ) )
+    {
+        DBG( code ); DBG( " processHeader\n" );
+
+        if( code == 0 )
+        {
+            sectionstr = reader->getString();
+            DBG( sectionstr ); DBG( " processHeader\n\n" );
+
+            if( sectionstr == "ENDSEC" )
+            {
+                iface->addHeader( &header );
+                return true;    // found ENDSEC terminate
+            }
+        }
+        else
+            header.parseCode( code, reader );
+    }
+
+    return true;
+}
+
+
+/********* Tables Section *********/
+
+bool dxfRW::processTables()
+{
+    DBG( "dxfRW::processTables\n" );
+    int     code;
+    string  sectionstr;
+    bool    more = true;
+
+    while( reader->readRec( &code, !binary ) )
+    {
+        DBG( code ); DBG( "\n" );
+
+        if( code == 0 )
+        {
+            sectionstr = reader->getString();
+            DBG( sectionstr ); DBG( " processHeader\n\n" );
+
+            if( sectionstr == "TABLE" )
+            {
+                more = reader->readRec( &code, !binary );
+                DBG( code ); DBG( "\n" );
+
+                if( !more )
+                    return false; // wrong dxf file
+
+                if( code == 2 )
+                {
+                    sectionstr = reader->getString();
+                    DBG( sectionstr ); DBG( " processHeader\n\n" );
+
+                    // found section, process it
+                    if( sectionstr == "LTYPE" )
+                    {
+                        processLType();
+                    }
+                    else if( sectionstr == "LAYER" )
+                    {
+                        processLayer();
+                    }
+                    else if( sectionstr == "STYLE" )
+                    {
+                        processTextStyle();
+                    }
+                    else if( sectionstr == "VPORT" )
+                    {
+                        processVports();
+                    }
+                    else if( sectionstr == "VIEW" )
+                    {
+// processView();
+                    }
+                    else if( sectionstr == "UCS" )
+                    {
+// processUCS();
+                    }
+                    else if( sectionstr == "APPID" )
+                    {
+// processAppId();
+                    }
+                    else if( sectionstr == "DIMSTYLE" )
+                    {
+                        processDimStyle();
+                    }
+                    else if( sectionstr == "BLOCK_RECORD" )
+                    {
+// processBlockRecord();
+                    }
+                }
+            }
+            else if( sectionstr == "ENDSEC" )
+            {
+                return true;    // found ENDSEC terminate
+            }
+        }
+    }
+
+    return true;
+}
+
+
+bool dxfRW::processLType()
+{
+    DBG( "dxfRW::processLType\n" );
+    int         code;
+    string      sectionstr;
+    bool        reading = false;
+    DRW_LType   ltype;
+
+    while( reader->readRec( &code, !binary ) )
+    {
+        DBG( code ); DBG( "\n" );
+
+        if( code == 0 )
+        {
+            if( reading )
+            {
+                ltype.update();
+                iface->addLType( ltype );
+            }
+
+            sectionstr = reader->getString();
+            DBG( sectionstr ); DBG( "\n" );
+
+            if( sectionstr == "LTYPE" )
+            {
+                reading = true;
+                ltype.reset();
+            }
+            else if( sectionstr == "ENDTAB" )
+            {
+                return true;    // found ENDTAB terminate
+            }
+        }
+        else if( reading )
+            ltype.parseCode( code, reader );
+    }
+
+    return true;
+}
+
+
+bool dxfRW::processLayer()
+{
+    DBG( "dxfRW::processLayer\n" );
+    int         code;
+    string      sectionstr;
+    bool        reading = false;
+    DRW_Layer   layer;
+
+    while( reader->readRec( &code, !binary ) )
+    {
+        DBG( code ); DBG( "\n" );
+
+        if( code == 0 )
+        {
+            if( reading )
+                iface->addLayer( layer );
+
+            sectionstr = reader->getString();
+            DBG( sectionstr ); DBG( "\n" );
+
+            if( sectionstr == "LAYER" )
+            {
+                reading = true;
+                layer.reset();
+            }
+            else if( sectionstr == "ENDTAB" )
+            {
+                return true;    // found ENDTAB terminate
+            }
+        }
+        else if( reading )
+            layer.parseCode( code, reader );
+    }
+
+    return true;
+}
+
+
+bool dxfRW::processDimStyle()
+{
+    DBG( "dxfRW::processDimStyle" );
+    int             code;
+    string          sectionstr;
+    bool            reading = false;
+    DRW_Dimstyle    dimSty;
+
+    while( reader->readRec( &code, !binary ) )
+    {
+        DBG( code ); DBG( "\n" );
+
+        if( code == 0 )
+        {
+            if( reading )
+                iface->addDimStyle( dimSty );
+
+            sectionstr = reader->getString();
+            DBG( sectionstr ); DBG( "\n" );
+
+            if( sectionstr == "DIMSTYLE" )
+            {
+                reading = true;
+                dimSty.reset();
+            }
+            else if( sectionstr == "ENDTAB" )
+            {
+                return true;    // found ENDTAB terminate
+            }
+        }
+        else if( reading )
+            dimSty.parseCode( code, reader );
+    }
+
+    return true;
+}
+
+
+bool dxfRW::processTextStyle()
+{
+    DBG( "dxfRW::processTextStyle" );
+    int             code;
+    string          sectionstr;
+    bool            reading = false;
+    DRW_Textstyle   TxtSty;
+
+    while( reader->readRec( &code, !binary ) )
+    {
+        DBG( code ); DBG( "\n" );
+
+        if( code == 0 )
+        {
+            if( reading )
+                iface->addTextStyle( TxtSty );
+
+            sectionstr = reader->getString();
+            DBG( sectionstr ); DBG( "\n" );
+
+            if( sectionstr == "STYLE" )
+            {
+                reading = true;
+                TxtSty.reset();
+            }
+            else if( sectionstr == "ENDTAB" )
+            {
+                return true;    // found ENDTAB terminate
+            }
+        }
+        else if( reading )
+            TxtSty.parseCode( code, reader );
+    }
+
+    return true;
+}
+
+
+bool dxfRW::processVports()
+{
+    DBG( "dxfRW::processVports" );
+    int         code;
+    string      sectionstr;
+    bool        reading = false;
+    DRW_Vport   vp;
+
+    while( reader->readRec( &code, !binary ) )
+    {
+        DBG( code ); DBG( "\n" );
+
+        if( code == 0 )
+        {
+            if( reading )
+                iface->addVport( vp );
+
+            sectionstr = reader->getString();
+            DBG( sectionstr ); DBG( "\n" );
+
+            if( sectionstr == "VPORT" )
+            {
+                reading = true;
+                vp.reset();
+            }
+            else if( sectionstr == "ENDTAB" )
+            {
+                return true;    // found ENDTAB terminate
+            }
+        }
+        else if( reading )
+            vp.parseCode( code, reader );
+    }
+
+    return true;
+}
+
+
+/********* Block Section *********/
+
+bool dxfRW::processBlocks()
+{
+    DBG( "dxfRW::processBlocks\n" );
+    int     code;
+    string  sectionstr;
+
+    while( reader->readRec( &code, !binary ) )
+    {
+        DBG( code ); DBG( "\n" );
+
+        if( code == 0 )
+        {
+            sectionstr = reader->getString();
+            DBG( sectionstr ); DBG( "\n" );
+
+            if( sectionstr == "BLOCK" )
+            {
+                processBlock();
+            }
+            else if( sectionstr == "ENDSEC" )
+            {
+                return true;    // found ENDSEC terminate
+            }
+        }
+    }
+
+    return true;
+}
+
+
+bool dxfRW::processBlock()
+{
+    DBG( "dxfRW::processBlock" );
+    int         code;
+    DRW_Block   block;
+
+    while( reader->readRec( &code, !binary ) )
+    {
+        DBG( code ); DBG( "\n" );
+
+        switch( code )
+        {
+        case 0:
+            {
+                nextentity = reader->getString();
+                DBG( nextentity ); DBG( "\n" );
+                iface->addBlock( block );
+
+                if( nextentity == "ENDBLK" )
+                {
+                    iface->endBlock();
+                    return true; // found ENDBLK, terminate
+                }
+                else
+                {
+                    processEntities( true );
+                    iface->endBlock();
+                    return true; // found ENDBLK, terminate
+                }
+            }
+
+        default:
+            block.parseCode( code, reader );
+            break;
+        }
+    }
+
+    return true;
+}
+
+
+/********* Entities Section *********/
+
+bool dxfRW::processEntities( bool isblock )
+{
+    DBG( "dxfRW::processEntities\n" );
+    int code;
+
+    if( !reader->readRec( &code, !binary ) )
+    {
+        return false;
+    }
+
+    bool next = true;
+
+    if( code == 0 )
+    {
+        nextentity = reader->getString();
+    }
+    else if( !isblock )
+    {
+        return false;      // first record in entities is 0
+    }
+
+    do {
+        if( nextentity == "ENDSEC" || nextentity == "ENDBLK" )
+        {
+            return true;    // found ENDSEC or ENDBLK terminate
+        }
+        else if( nextentity == "POINT" )
+        {
+            processPoint();
+        }
+        else if( nextentity == "LINE" )
+        {
+            processLine();
+        }
+        else if( nextentity == "CIRCLE" )
+        {
+            processCircle();
+        }
+        else if( nextentity == "ARC" )
+        {
+            processArc();
+        }
+        else if( nextentity == "ELLIPSE" )
+        {
+            processEllipse();
+        }
+        else if( nextentity == "TRACE" )
+        {
+            processTrace();
+        }
+        else if( nextentity == "SOLID" )
+        {
+            processSolid();
+        }
+        else if( nextentity == "INSERT" )
+        {
+            processInsert();
+        }
+        else if( nextentity == "LWPOLYLINE" )
+        {
+            processLWPolyline();
+        }
+        else if( nextentity == "POLYLINE" )
+        {
+            processPolyline();
+        }
+        else if( nextentity == "TEXT" )
+        {
+            processText();
+        }
+        else if( nextentity == "MTEXT" )
+        {
+            processMText();
+        }
+        else if( nextentity == "HATCH" )
+        {
+            processHatch();
+        }
+        else if( nextentity == "SPLINE" )
+        {
+            processSpline();
+        }
+        else if( nextentity == "3DFACE" )
+        {
+            process3dface();
+        }
+        else if( nextentity == "VIEWPORT" )
+        {
+            processViewport();
+        }
+        else if( nextentity == "IMAGE" )
+        {
+            processImage();
+        }
+        else if( nextentity == "DIMENSION" )
+        {
+            processDimension();
+        }
+        else if( nextentity == "LEADER" )
+        {
+            processLeader();
+        }
+        else if( nextentity == "RAY" )
+        {
+            processRay();
+        }
+        else if( nextentity == "XLINE" )
+        {
+            processXline();
+        }
+        else
+        {
+            if( reader->readRec( &code, !binary ) )
+            {
+                if( code == 0 )
+                    nextentity = reader->getString();
+            }
+            else
+                return false; // end of file without ENDSEC
+        }
+    } while( next );
+
+    return true;
+}
+
+
+bool dxfRW::processEllipse()
+{
+    DBG( "dxfRW::processEllipse" );
+    int         code;
+    DRW_Ellipse ellipse;
+
+    while( reader->readRec( &code, !binary ) )
+    {
+        DBG( code ); DBG( "\n" );
+
+        switch( code )
+        {
+        case 0:
+            {
+                nextentity = reader->getString();
+                DBG( nextentity ); DBG( "\n" );
+
+                if( applyExt )
+                    ellipse.applyExtrusion();
+
+                iface->addEllipse( ellipse );
+                return true; // found new entity or ENDSEC, terminate
+            }
+
+        default:
+            ellipse.parseCode( code, reader );
+            break;
+        }
+    }
+
+    return true;
+}
+
+
+bool dxfRW::processTrace()
+{
+    DBG( "dxfRW::processTrace" );
+    int         code;
+    DRW_Trace   trace;
+
+    while( reader->readRec( &code, !binary ) )
+    {
+        DBG( code ); DBG( "\n" );
+
+        switch( code )
+        {
+        case 0:
+            {
+                nextentity = reader->getString();
+                DBG( nextentity ); DBG( "\n" );
+
+                if( applyExt )
+                    trace.applyExtrusion();
+
+                iface->addTrace( trace );
+                return true; // found new entity or ENDSEC, terminate
+            }
+
+        default:
+            trace.parseCode( code, reader );
+            break;
+        }
+    }
+
+    return true;
+}
+
+
+bool dxfRW::processSolid()
+{
+    DBG( "dxfRW::processSolid" );
+    int         code;
+    DRW_Solid   solid;
+
+    while( reader->readRec( &code, !binary ) )
+    {
+        DBG( code ); DBG( "\n" );
+
+        switch( code )
+        {
+        case 0:
+            {
+                nextentity = reader->getString();
+                DBG( nextentity ); DBG( "\n" );
+
+                if( applyExt )
+                    solid.applyExtrusion();
+
+                iface->addSolid( solid );
+                return true; // found new entity or ENDSEC, terminate
+            }
+
+        default:
+            solid.parseCode( code, reader );
+            break;
+        }
+    }
+
+    return true;
+}
+
+
+bool dxfRW::process3dface()
+{
+    DBG( "dxfRW::process3dface" );
+    int         code;
+    DRW_3Dface  face;
+
+    while( reader->readRec( &code, !binary ) )
+    {
+        DBG( code ); DBG( "\n" );
+
+        switch( code )
+        {
+        case 0:
+            {
+                nextentity = reader->getString();
+                DBG( nextentity ); DBG( "\n" );
+                iface->add3dFace( face );
+                return true; // found new entity or ENDSEC, terminate
+            }
+
+        default:
+            face.parseCode( code, reader );
+            break;
+        }
+    }
+
+    return true;
+}
+
+
+bool dxfRW::processViewport()
+{
+    DBG( "dxfRW::processViewport" );
+    int             code;
+    DRW_Viewport    vp;
+
+    while( reader->readRec( &code, !binary ) )
+    {
+        DBG( code ); DBG( "\n" );
+
+        switch( code )
+        {
+        case 0:
+            {
+                nextentity = reader->getString();
+                DBG( nextentity ); DBG( "\n" );
+                iface->addViewport( vp );
+                return true; // found new entity or ENDSEC, terminate
+            }
+
+        default:
+            vp.parseCode( code, reader );
+            break;
+        }
+    }
+
+    return true;
+}
+
+
+bool dxfRW::processPoint()
+{
+    DBG( "dxfRW::processPoint\n" );
+    int         code;
+    DRW_Point   point;
+
+    while( reader->readRec( &code, !binary ) )
+    {
+        DBG( code ); DBG( "\n" );
+
+        switch( code )
+        {
+        case 0:
+            {
+                nextentity = reader->getString();
+                DBG( nextentity ); DBG( "\n" );
+                iface->addPoint( point );
+                return true; // found new entity or ENDSEC, terminate
+            }
+
+        default:
+            point.parseCode( code, reader );
+            break;
+        }
+    }
+
+    return true;
+}
+
+
+bool dxfRW::processLine()
+{
+    DBG( "dxfRW::processLine\n" );
+    int         code;
+    DRW_Line    line;
+
+    while( reader->readRec( &code, !binary ) )
+    {
+        DBG( code ); DBG( "\n" );
+
+        switch( code )
+        {
+        case 0:
+            {
+                nextentity = reader->getString();
+                DBG( nextentity ); DBG( "\n" );
+                iface->addLine( line );
+                return true; // found new entity or ENDSEC, terminate
+            }
+
+        default:
+            line.parseCode( code, reader );
+            break;
+        }
+    }
+
+    return true;
+}
+
+
+bool dxfRW::processRay()
+{
+    DBG( "dxfRW::processRay\n" );
+    int     code;
+    DRW_Ray line;
+
+    while( reader->readRec( &code, !binary ) )
+    {
+        DBG( code ); DBG( "\n" );
+
+        switch( code )
+        {
+        case 0:
+            {
+                nextentity = reader->getString();
+                DBG( nextentity ); DBG( "\n" );
+                iface->addRay( line );
+                return true; // found new entity or ENDSEC, terminate
+            }
+
+        default:
+            line.parseCode( code, reader );
+            break;
+        }
+    }
+
+    return true;
+}
+
+
+bool dxfRW::processXline()
+{
+    DBG( "dxfRW::processXline\n" );
+    int         code;
+    DRW_Xline   line;
+
+    while( reader->readRec( &code, !binary ) )
+    {
+        DBG( code ); DBG( "\n" );
+
+        switch( code )
+        {
+        case 0:
+            {
+                nextentity = reader->getString();
+                DBG( nextentity ); DBG( "\n" );
+                iface->addXline( line );
+                return true; // found new entity or ENDSEC, terminate
+            }
+
+        default:
+            line.parseCode( code, reader );
+            break;
+        }
+    }
+
+    return true;
+}
+
+
+bool dxfRW::processCircle()
+{
+    DBG( "dxfRW::processPoint\n" );
+    int         code;
+    DRW_Circle  circle;
+
+    while( reader->readRec( &code, !binary ) )
+    {
+        DBG( code ); DBG( "\n" );
+
+        switch( code )
+        {
+        case 0:
+            {
+                nextentity = reader->getString();
+                DBG( nextentity ); DBG( "\n" );
+
+                if( applyExt )
+                    circle.applyExtrusion();
+
+                iface->addCircle( circle );
+                return true; // found new entity or ENDSEC, terminate
+            }
+
+        default:
+            circle.parseCode( code, reader );
+            break;
+        }
+    }
+
+    return true;
+}
+
+
+bool dxfRW::processArc()
+{
+    DBG( "dxfRW::processPoint\n" );
+    int     code;
+    DRW_Arc arc;
+
+    while( reader->readRec( &code, !binary ) )
+    {
+        DBG( code ); DBG( "\n" );
+
+        switch( code )
+        {
+        case 0:
+            {
+                nextentity = reader->getString();
+                DBG( nextentity ); DBG( "\n" );
+
+                if( applyExt )
+                    arc.applyExtrusion();
+
+                iface->addArc( arc );
+                return true; // found new entity or ENDSEC, terminate
+            }
+
+        default:
+            arc.parseCode( code, reader );
+            break;
+        }
+    }
+
+    return true;
+}
+
+
+bool dxfRW::processInsert()
+{
+    DBG( "dxfRW::processInsert" );
+    int         code;
+    DRW_Insert  insert;
+
+    while( reader->readRec( &code, !binary ) )
+    {
+        DBG( code ); DBG( "\n" );
+
+        switch( code )
+        {
+        case 0:
+            {
+                nextentity = reader->getString();
+                DBG( nextentity ); DBG( "\n" );
+                iface->addInsert( insert );
+                return true; // found new entity or ENDSEC, terminate
+            }
+
+        default:
+            insert.parseCode( code, reader );
+            break;
+        }
+    }
+
+    return true;
+}
+
+
+bool dxfRW::processLWPolyline()
+{
+    DBG( "dxfRW::processLWPolyline" );
+    int             code;
+    DRW_LWPolyline  pl;
+
+    while( reader->readRec( &code, !binary ) )
+    {
+        DBG( code ); DBG( "\n" );
+
+        switch( code )
+        {
+        case 0:
+            {
+                nextentity = reader->getString();
+                DBG( nextentity ); DBG( "\n" );
+
+                if( applyExt )
+                    pl.applyExtrusion();
+
+                iface->addLWPolyline( pl );
+                return true; // found new entity or ENDSEC, terminate
+            }
+
+        default:
+            pl.parseCode( code, reader );
+            break;
+        }
+    }
+
+    return true;
+}
+
+
+bool dxfRW::processPolyline()
+{
+    DBG( "dxfRW::processPolyline" );
+    int             code;
+    DRW_Polyline    pl;
+
+    while( reader->readRec( &code, !binary ) )
+    {
+        DBG( code ); DBG( "\n" );
+
+        switch( code )
+        {
+        case 0:
+            {
+                nextentity = reader->getString();
+                DBG( nextentity ); DBG( "\n" );
+
+                if( nextentity != "VERTEX" )
+                {
+                    iface->addPolyline( pl );
+                    return true; // found new entity or ENDSEC, terminate
+                }
+                else
+                {
+                    processVertex( &pl );
+                }
+            }
+
+        default:
+            pl.parseCode( code, reader );
+            break;
+        }
+    }
+
+    return true;
+}
+
+
+bool dxfRW::processVertex( DRW_Polyline* pl )
+{
+    DBG( "dxfRW::processVertex" );
+    int         code;
+    DRW_Vertex* v = new DRW_Vertex();
+
+    while( reader->readRec( &code, !binary ) )
+    {
+        DBG( code ); DBG( "\n" );
+
+        switch( code )
+        {
+        case 0:
+            {
+                pl->appendVertex( v );
+                nextentity = reader->getString();
+                DBG( nextentity ); DBG( "\n" );
+
+                if( nextentity == "SEQEND" )
+                {
+                    return true; // found SEQEND no more vertex, terminate
+                }
+                else if( nextentity == "VERTEX" )
+                {
+                    v = new DRW_Vertex(); // another vertex
+                }
+            }
+
+        default:
+            v->parseCode( code, reader );
+            break;
+        }
+    }
+
+    return true;
+}
+
+
+bool dxfRW::processText()
+{
+    DBG( "dxfRW::processText" );
+    int         code;
+    DRW_Text    txt;
+
+    while( reader->readRec( &code, !binary ) )
+    {
+        DBG( code ); DBG( "\n" );
+
+        switch( code )
+        {
+        case 0:
+            {
+                nextentity = reader->getString();
+                DBG( nextentity ); DBG( "\n" );
+                iface->addText( txt );
+                return true; // found new entity or ENDSEC, terminate
+            }
+
+        default:
+            txt.parseCode( code, reader );
+            break;
+        }
+    }
+
+    return true;
+}
+
+
+bool dxfRW::processMText()
+{
+    DBG( "dxfRW::processMText" );
+    int         code;
+    DRW_MText   txt;
+
+    while( reader->readRec( &code, !binary ) )
+    {
+        DBG( code ); DBG( "\n" );
+
+        switch( code )
+        {
+        case 0:
+            {
+                nextentity = reader->getString();
+                DBG( nextentity ); DBG( "\n" );
+                txt.updateAngle();
+                iface->addMText( txt );
+                return true; // found new entity or ENDSEC, terminate
+            }
+
+        default:
+            txt.parseCode( code, reader );
+            break;
+        }
+    }
+
+    return true;
+}
+
+
+bool dxfRW::processHatch()
+{
+    DBG( "dxfRW::processHatch" );
+    int         code;
+    DRW_Hatch   hatch;
+
+    while( reader->readRec( &code, !binary ) )
+    {
+        DBG( code ); DBG( "\n" );
+
+        switch( code )
+        {
+        case 0:
+            {
+                nextentity = reader->getString();
+                DBG( nextentity ); DBG( "\n" );
+                iface->addHatch( &hatch );
+                return true; // found new entity or ENDSEC, terminate
+            }
+
+        default:
+            hatch.parseCode( code, reader );
+            break;
+        }
+    }
+
+    return true;
+}
+
+
+bool dxfRW::processSpline()
+{
+    DBG( "dxfRW::processSpline" );
+    int         code;
+    DRW_Spline  sp;
+
+    while( reader->readRec( &code, !binary ) )
+    {
+        DBG( code ); DBG( "\n" );
+
+        switch( code )
+        {
+        case 0:
+            {
+                nextentity = reader->getString();
+                DBG( nextentity ); DBG( "\n" );
+                iface->addSpline( &sp );
+                return true; // found new entity or ENDSEC, terminate
+            }
+
+        default:
+            sp.parseCode( code, reader );
+            break;
+        }
+    }
+
+    return true;
+}
+
+
+bool dxfRW::processImage()
+{
+    DBG( "dxfRW::processImage" );
+    int         code;
+    DRW_Image   img;
+
+    while( reader->readRec( &code, !binary ) )
+    {
+        DBG( code ); DBG( "\n" );
+
+        switch( code )
+        {
+        case 0:
+            {
+                nextentity = reader->getString();
+                DBG( nextentity ); DBG( "\n" );
+                iface->addImage( &img );
+                return true; // found new entity or ENDSEC, terminate
+            }
+
+        default:
+            img.parseCode( code, reader );
+            break;
+        }
+    }
+
+    return true;
+}
+
+
+bool dxfRW::processDimension()
+{
+    DBG( "dxfRW::processDimension" );
+    int             code;
+    DRW_Dimension   dim;
+
+    while( reader->readRec( &code, !binary ) )
+    {
+        DBG( code ); DBG( "\n" );
+
+        switch( code )
+        {
+        case 0:
+            {
+                nextentity = reader->getString();
+                DBG( nextentity ); DBG( "\n" );
+                int type = dim.type & 0x0F;
+
+                switch( type )
+                {
+                case 0:
+                    {
+                        DRW_DimLinear d( dim );
+                        iface->addDimLinear( &d );
+                        break;
+                    }
+
+                case 1:
+                    {
+                        DRW_DimAligned d( dim );
+                        iface->addDimAlign( &d );
+                        break;
+                    }
+
+                case 2:
+                    {
+                        DRW_DimAngular d( dim );
+                        iface->addDimAngular( &d );
+                        break;
+                    }
+
+                case 3:
+                    {
+                        DRW_DimDiametric d( dim );
+                        iface->addDimDiametric( &d );
+                        break;
+                    }
+
+                case 4:
+                    {
+                        DRW_DimRadial d( dim );
+                        iface->addDimRadial( &d );
+                        break;
+                    }
+
+                case 5:
+                    {
+                        DRW_DimAngular3p d( dim );
+                        iface->addDimAngular3P( &d );
+                        break;
+                    }
+
+                case 6:
+                    {
+                        DRW_DimOrdinate d( dim );
+                        iface->addDimOrdinate( &d );
+                        break;
+                    }
+                }
+
+                return true; // found new entity or ENDSEC, terminate
+            }
+
+        default:
+            dim.parseCode( code, reader );
+            break;
+        }
+    }
+
+    return true;
+}
+
+
+bool dxfRW::processLeader()
+{
+    DBG( "dxfRW::processLeader" );
+    int         code;
+    DRW_Leader  leader;
+
+    while( reader->readRec( &code, !binary ) )
+    {
+        DBG( code ); DBG( "\n" );
+
+        switch( code )
+        {
+        case 0:
+            {
+                nextentity = reader->getString();
+                DBG( nextentity ); DBG( "\n" );
+                iface->addLeader( &leader );
+                return true; // found new entity or ENDSEC, terminate
+            }
+
+        default:
+            leader.parseCode( code, reader );
+            break;
+        }
+    }
+
+    return true;
+}
+
+
+/********* Objects Section *********/
+
+bool dxfRW::processObjects()
+{
+    DBG( "dxfRW::processObjects\n" );
+    int code;
+
+    if( !reader->readRec( &code, !binary ) )
+    {
+        return false;
+    }
+
+    bool next = true;
+
+    if( code == 0 )
+    {
+        nextentity = reader->getString();
+    }
+    else
+    {
+        return false;      // first record in objects is 0
+    }
+
+    do {
+        if( nextentity == "ENDSEC" )
+        {
+            return true;    // found ENDSEC terminate
+        }
+        else if( nextentity == "IMAGEDEF" )
+        {
+            processImageDef();
+        }
+        else
+        {
+            if( reader->readRec( &code, !binary ) )
+            {
+                if( code == 0 )
+                    nextentity = reader->getString();
+            }
+            else
+                return false; // end of file without ENDSEC
+        }
+    } while( next );
+
+    return true;
+}
+
+
+bool dxfRW::processImageDef()
+{
+    DBG( "dxfRW::processImageDef" );
+    int             code;
+    DRW_ImageDef    img;
+
+    while( reader->readRec( &code, !binary ) )
+    {
+        DBG( code ); DBG( "\n" );
+
+        switch( code )
+        {
+        case 0:
+            {
+                nextentity = reader->getString();
+                DBG( nextentity ); DBG( "\n" );
+                iface->linkImage( &img );
+                return true; // found new entity or ENDSEC, terminate
+            }
+
+        default:
+            img.parseCode( code, reader );
+            break;
+        }
+    }
+
+    return true;
+}
+
+
+/** utility function
+ * convert a int to string in hex
+ **/
+std::string dxfRW::toHexStr( int n )
+{
+#if defined(__APPLE__)
+    std::string buffer( 9, '\0' );
+    snprintf( &buffer[0], 9, "%X", n );
+    return buffer;
+#else
+    std::ostringstream Convert;
+    Convert << std::uppercase << std::hex << n;
+    return Convert.str();
+#endif
+}

lib_dxf/libdxfrw.h

+/******************************************************************************
+**  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 LIBDXFRW_H
+#define LIBDXFRW_H
+
+#include <string>
+#include "drw_entities.h"
+#include "drw_objects.h"
+#include "drw_interface.h"
+
+
+class dxfReader;
+class dxfWriter;
+
+class dxfRW
+{
+public:
+    dxfRW( const char* name );
+    ~dxfRW();
+    // / reads the file specified in constructor
+    /*!
+     * An interface must be provided. It is used by the class to signal various
+     * components being added.
+     * @param interface_ the interface to use
+     * @param ext should the extrusion be applied to convert in 2D?
+     * @return true for success
+     */
+    bool            read( DRW_Interface* interface_, bool ext );
+
+    void setBinary( bool b ) { binary = b; }
+
+    bool            write( DRW_Interface* interface_, DRW::Version ver, bool bin );
+    bool            writeLineType( DRW_LType* ent );
+    bool            writeLayer( DRW_Layer* ent );
+    bool            writeDimstyle( DRW_Dimstyle* ent );
+    bool            writeTextstyle( DRW_Textstyle* ent );
+    bool            writeVport( DRW_Vport* ent );
+    bool            writePoint( DRW_Point* ent );
+    bool            writeLine( DRW_Line* ent );
+    bool            writeRay( DRW_Ray* ent );
+    bool            writeXline( DRW_Xline* ent );
+    bool            writeCircle( DRW_Circle* ent );
+    bool            writeArc( DRW_Arc* ent );
+    bool            writeEllipse( DRW_Ellipse* ent );
+    bool            writeTrace( DRW_Trace* ent );
+    bool            writeSolid( DRW_Solid* ent );
+    bool            write3dface( DRW_3Dface* ent );
+    bool            writeLWPolyline( DRW_LWPolyline* ent );
+    bool            writePolyline( DRW_Polyline* ent );
+    bool            writeSpline( DRW_Spline* ent );
+    bool            writeBlockRecord( std::string name );
+    bool            writeBlock( DRW_Block* ent );
+    bool            writeInsert( DRW_Insert* ent );
+    bool            writeMText( DRW_MText* ent );
+    bool            writeText( DRW_Text* ent );
+    bool            writeHatch( DRW_Hatch* ent );
+    bool            writeViewport( DRW_Viewport* ent );
+    DRW_ImageDef*   writeImage( DRW_Image* ent, std::string name );
+    bool            writeLeader( DRW_Leader* ent );
+    bool            writeDimension( DRW_Dimension* ent );
+
+    void setEllipseParts( int parts ) { elParts = parts; }    /*!< set parts munber when convert ellipse to polyline */
+private:
+    // / used by read() to parse the content of the file
+    bool            processDxf();
+    bool            processHeader();
+    bool            processTables();
+    bool            processBlocks();
+    bool            processBlock();
+    bool            processEntities( bool isblock );
+    bool            processObjects();
+
+    bool            processLType();
+    bool            processLayer();
+    bool            processDimStyle();
+    bool            processTextStyle();
+    bool            processVports();
+
+    bool            processPoint();
+    bool            processLine();
+    bool            processRay();
+    bool            processXline();
+    bool            processCircle();
+    bool            processArc();
+    bool            processEllipse();
+    bool            processTrace();
+    bool            processSolid();
+    bool            processInsert();
+    bool            processLWPolyline();
+    bool            processPolyline();
+    bool            processVertex( DRW_Polyline* pl );
+    bool            processText();
+    bool            processMText();
+    bool            processHatch();
+    bool            processSpline();
+    bool            process3dface();
+    bool            processViewport();
+    bool            processImage();
+    bool            processImageDef();
+    bool            processDimension();
+    bool            processLeader();
+
+// bool writeHeader();
+    bool            writeEntity( DRW_Entity* ent );
+    bool            writeTables();
+    bool            writeBlocks();
+    bool            writeObjects();
+    std::string     toHexStr( int n );
+
+private:
+    DRW::Version                version;
+    std::string                 fileName;
+    std::string                 codePage;
+    bool                        binary;
+    dxfReader*                  reader;
+    dxfWriter*                  writer;
+    DRW_Interface*              iface;
+    DRW_Header                  header;
+// int section;
+    string                      nextentity;
+    int                         entCount;
+    bool                        wlayer0;
+    bool                        dimstyleStd;
+    bool                        applyExt;
+    bool                        writingBlock;
+    int                         elParts;    /*!< parts munber when convert ellipse to polyline */
+    std::map<std::string, int>  blockMap;
+    std::vector<DRW_ImageDef*>  imageDef;   /*!< imageDef list */
+
+    int                         currHandle;
+};
+
+#endif    // LIBDXFRW_H

pcbnew/CMakeLists.txt

@@ -26,6 +26,8 @@ include_directories(
     ../common
     ../polygon
     ../common/dialogs
+    ../lib_dxf
+    ./import_dxf
     ${INC_AFTER}
     )
 
@@ -114,6 +116,11 @@ set( PCBNEW_DIALOGS
     dialogs/dialog_footprint_wizard_list.cpp
     )
 
+set( PCBNEW_IMPORT_DXF
+    import_dxf/dialog_dxf_import.cpp
+    import_dxf/dxf2brd_items.cpp
+    )
+
 set( PCBNEW_AUTOROUTER_SRCS
     autorouter/automove.cpp
     autorouter/autoplac.cpp
@@ -145,6 +152,7 @@ set( PCBNEW_CLASS_SRCS
     cross-probing.cpp
     deltrack.cpp
     ${PCBNEW_DIALOGS}
+    ${PCBNEW_IMPORT_DXF}
     dragsegm.cpp
     drc.cpp
     drc_clearance_test_functions.cpp
@@ -347,6 +355,7 @@ if( KICAD_SCRIPTING_MODULES )
         pcbcommon
         common
         pcad2kicadpcb
+        lib_dxf
         ${GITHUB_PLUGIN_LIBRARIES}
         polygon
         bitmaps
@@ -515,6 +524,7 @@ target_link_libraries( pcbnew
     pcad2kicadpcb
     polygon
     bitmaps
+    lib_dxf
     ${GITHUB_PLUGIN_LIBRARIES}
     ${wxWidgets_LIBRARIES}
     ${OPENGL_LIBRARIES}

pcbnew/edit.cpp

@@ -51,10 +51,9 @@
 #include <class_pcb_text.h>
 #include <modview_frame.h>
 #include <class_pcb_layer_box_selector.h>
-
 #include <dialog_drc.h>
-
 #include <dialog_global_edit_tracks_and_vias.h>
+#include <invoke_pcb_dialog.h>
 
 // Handles the selection of command events.
 void PCB_EDIT_FRAME::Process_Special_Functions( wxCommandEvent& event )
@@ -1185,6 +1184,11 @@ void PCB_EDIT_FRAME::Process_Special_Functions( wxCommandEvent& event )
         ArchiveModulesOnBoard( wxEmptyString, false );
         break;
 
+    case ID_GEN_IMPORT_DXF_FILE:
+        InvokeDXFDialogImport( this );
+        m_canvas->Refresh();
+        break;
+
     default:
         wxString msg;
         msg.Printf( wxT( "PCB_EDIT_FRAME::Process_Special_Functions() unknown event id %d" ),

pcbnew/import_dxf/dialog_dxf_import.cpp

+#include <dxf2brd_items.h>
+#include <wxPcbStruct.h>
+#include <convert_from_iu.h>
+
+bool InvokeDXFDialogImport( PCB_EDIT_FRAME* aCaller )
+{
+    wxFileDialog dlg( aCaller,
+                      wxT( "Open File" ),
+                      wxEmptyString, wxEmptyString,
+                      wxT( "dxf Files (*.dxf)|*.dxf|*.DXF" ),
+                      wxFD_OPEN|wxFD_FILE_MUST_EXIST );
+    dlg.ShowModal();
+
+    wxString fileName = dlg.GetPath();
+
+    if( !fileName.IsEmpty() )
+    {
+        BOARD * brd = aCaller->GetBoard();
+        DXF2BRD_CONVERTER dxf_importer;
+
+        // Set coordinates offset for import (offset is given in mm)
+        double offsetY = - aCaller->GetPageSizeIU().y * MM_PER_IU;
+        dxf_importer.SetOffset( 0.0, offsetY );
+        dxf_importer.SetBrdLayer( DRAW_N );
+        dxf_importer.ImportDxfFile( fileName, brd );
+    }
+
+    return true;
+}

pcbnew/import_dxf/dxf2brd_items.cpp

+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2013 Jean-Pierre Charras, jp.charras at wanadoo.fr
+ * Copyright (C) 1992-2013 KiCad Developers, see AUTHORS.txt for contributors.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it 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.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+// The DXF reader lib (libdxfrw) comes from LibreCAD project, a 2D CAD program
+// libdxfrw can be found on http://sourceforge.net/projects/libdxfrw/
+// or (latest sources) on
+// https://github.com/LibreCAD/LibreCAD/tree/master/libraries/libdxfrw/src
+//
+// There is no doc to use it, but have a look to
+// https://github.com/LibreCAD/LibreCAD/blob/master/librecad/src/lib/filters/rs_filterdxf.cpp
+// and https://github.com/LibreCAD/LibreCAD/blob/master/librecad/src/lib/filters/rs_filterdxf.h
+// Each time a dxf entity is read, a "call back" fuction is called
+// like void DXF2BRD_CONVERTER::addLine( const DRW_Line& data ) when a line is read.
+// this function just add the BOARD entity from dxf parameters (start and end point ...)
+
+
+#include "libdxfrw.h"
+#include "dxf2brd_items.h"
+#include <wx/arrstr.h>
+#include <wx/regex.h>
+
+#include <trigo.h>
+#include <class_board.h>
+#include <class_drawsegment.h>
+#include <class_pcb_text.h>
+
+DXF2BRD_CONVERTER::DXF2BRD_CONVERTER() : DRW_Interface()
+{
+    m_xOffset   = 0.0;      // X coord offset for conversion (in mm)
+    m_yOffset   = 0.0;      // Y coord offset for conversion (in mm)
+    m_Dfx2mm    = 1.0;      // The scale factor to convert DXF units to mm
+    m_dxf       = NULL;
+    m_brd       = NULL;
+    m_version   = 0;
+    m_defaultThickness = 0.1;
+    m_brdLayer = DRAW_N;
+}
+
+
+DXF2BRD_CONVERTER::~DXF2BRD_CONVERTER()
+{
+}
+
+
+// coordinate conversions from dxf to internal units
+int DXF2BRD_CONVERTER::mapX( double aDxfCoordX )
+{
+    return Millimeter2iu( m_xOffset + (aDxfCoordX * m_Dfx2mm) );
+}
+
+
+int DXF2BRD_CONVERTER::mapY( double aDxfCoordY )
+{
+    return Millimeter2iu( -m_yOffset - (aDxfCoordY * m_Dfx2mm) );
+}
+
+
+int DXF2BRD_CONVERTER::mapDim( double aDxfValue )
+{
+    return Millimeter2iu( aDxfValue * m_Dfx2mm );
+}
+
+
+/**
+ * Implementation of the method used for communicate
+ * with this filter.
+ *
+ * @param aFile = the full filename.
+ * @param aLayersList = where to store the list of layer names
+ */
+bool DXF2BRD_CONVERTER::ImportDxfFile( const wxString& aFile, BOARD* aBoard )
+{
+    m_brd = aBoard;
+
+    m_dxf = new dxfRW( aFile.ToUTF8() );
+    bool success = m_dxf->read( this, true );
+
+    if( success==false )
+    {
+        return false;
+    }
+
+    delete m_dxf;
+    m_dxf = NULL;
+    return true;
+}
+
+
+/**
+ * Implementation of the method which handles layers.
+ */
+void DXF2BRD_CONVERTER::addLayer( const DRW_Layer& data )
+{
+#if 0
+    wxString name = wxString::FromUTF8( data.name.c_str() );
+    wxLogMessage( name );
+#endif
+}
+
+
+/*
+ * Import line entities.
+ */
+void DXF2BRD_CONVERTER::addLine( const DRW_Line& data )
+{
+    DRAWSEGMENT*    segm = new DRAWSEGMENT( m_brd );
+
+    segm->SetLayer( m_brdLayer );
+    wxPoint         start( mapX( data.basePoint.x ), mapY( data.basePoint.y ) );
+    segm->SetStart( start );
+    wxPoint         end( mapX( data.secPoint.x ), mapY( data.secPoint.y ) );
+    segm->SetEnd( end );
+    segm->SetWidth( mapDim( data.thickness == 0 ? m_defaultThickness
+                            : data.thickness ) );
+    m_brd->Add( segm );
+}
+
+
+/*
+ * Import Circle entities.
+ */
+void DXF2BRD_CONVERTER::addCircle( const DRW_Circle& data )
+{
+    DRAWSEGMENT* segm = new DRAWSEGMENT( m_brd );
+
+    segm->SetLayer( m_brdLayer );
+    segm->SetShape( S_CIRCLE );
+    wxPoint center( mapX( data.basePoint.x ), mapY( data.basePoint.y ) );
+    segm->SetPosition( center );
+    wxPoint circle_start( mapX( data.basePoint.x + data.radious ),
+                          mapY( data.basePoint.y ) );
+    segm->SetEnd( circle_start );
+    segm->SetWidth( mapDim( data.thickness == 0 ? m_defaultThickness
+                            : data.thickness ) );
+    m_brd->Add( segm );
+}
+
+
+/*
+ * Import Arc entities.
+ */
+void DXF2BRD_CONVERTER::addArc( const DRW_Arc& data )
+{
+    DRAWSEGMENT* segm = new DRAWSEGMENT( m_brd );
+
+    segm->SetLayer( m_brdLayer );
+    segm->SetShape( S_ARC );
+
+    // Init arc centre:
+    wxPoint center( mapX( data.basePoint.x ), mapY( data.basePoint.y ) );
+    segm->SetPosition( center );
+
+    // Init arc start point
+    double  arcStartx   = data.radious;
+    double  arcStarty   = 0;
+    RotatePoint( &arcStartx, &arcStarty, -RAD2DECIDEG( data.staangle ) );
+    wxPoint arcStart( mapX( arcStartx + data.basePoint.x ),
+                      mapY( arcStarty + data.basePoint.y ) );
+    segm->SetEnd( arcStart );
+
+    // calculate arc angle (arcs are CCW, and should be < 0 in Pcbnew)
+    double angle = -RAD2DECIDEG( data.endangle - data.staangle );
+
+    if( angle > 0.0 )
+        angle -= 3600.0;
+
+    segm->SetAngle( angle );
+
+    segm->SetWidth( mapDim( data.thickness == 0 ? m_defaultThickness
+                            : data.thickness ) );
+    m_brd->Add( segm );
+}
+
+/**
+ * Import texts (TEXT).
+ */
+void DXF2BRD_CONVERTER::addText(const DRW_Text& data)
+{
+    TEXTE_PCB*  pcb_text = new TEXTE_PCB( m_brd );
+    pcb_text->SetLayer( m_brdLayer );
+
+    wxPoint refPoint( mapX(data.basePoint.x), mapY(data.basePoint.y) );
+    wxPoint secPoint( mapX(data.secPoint.x), mapY(data.secPoint.y) );
+
+    if (data.alignV !=0 || data.alignH !=0 ||data.alignH ==DRW_Text::HMiddle)
+    {
+        if (data.alignH !=DRW_Text::HAligned && data.alignH !=DRW_Text::HFit)
+        {
+            wxPoint tmp = secPoint;
+            secPoint = refPoint;
+            refPoint = tmp;
+        }
+    }
+
+    switch( data.alignV )
+    {
+        case DRW_Text::VBaseLine:       // Top
+            pcb_text->SetVertJustify( GR_TEXT_VJUSTIFY_TOP );
+            break;
+
+        case DRW_Text::VBottom:
+            pcb_text->SetVertJustify( GR_TEXT_VJUSTIFY_BOTTOM );
+            break;
+
+        case DRW_Text::VMiddle:
+            pcb_text->SetVertJustify( GR_TEXT_VJUSTIFY_CENTER );
+            break;
+
+        case DRW_Text::VTop:
+            pcb_text->SetVertJustify( GR_TEXT_VJUSTIFY_TOP );
+            break;
+    }
+
+    switch( data.alignH )
+    {
+        case DRW_Text::HLeft:
+            pcb_text->SetHorizJustify( GR_TEXT_HJUSTIFY_LEFT );
+            break;
+
+        case DRW_Text::HCenter:
+            pcb_text->SetHorizJustify( GR_TEXT_HJUSTIFY_CENTER );
+            break;
+
+        case DRW_Text::HRight:
+            pcb_text->SetHorizJustify( GR_TEXT_HJUSTIFY_RIGHT );
+            break;
+
+        case DRW_Text::HAligned:
+            // no equivalent options in text pcb.
+            pcb_text->SetHorizJustify( GR_TEXT_HJUSTIFY_RIGHT );
+            break;
+
+        case DRW_Text::HMiddle:
+            // no equivalent options in text pcb.
+            pcb_text->SetHorizJustify( GR_TEXT_HJUSTIFY_CENTER );
+            break;
+
+        case DRW_Text::HFit:
+            // no equivalent options in text pcb.
+            pcb_text->SetHorizJustify( GR_TEXT_HJUSTIFY_RIGHT );
+            break;
+    }
+
+#if 0
+    wxString sty = wxString::FromUTF8(data.style.c_str());
+    sty=sty.ToLower();
+
+    if (data.textgen==2)
+    {
+        // Text dir = left to right;
+    } else if (data.textgen==4)
+    {
+        / Text dir = top to bottom;
+    } else
+    {
+    }
+#endif
+
+    wxString    text = toNativeString( wxString::FromUTF8( data.text.c_str() ) );
+
+    pcb_text->SetTextPosition( refPoint );
+    pcb_text->SetOrientation( data.angle * 10 );
+    // The 0.8 factor gives a better height/width ratio with our font
+    pcb_text->SetWidth( mapDim( data.height * 0.8 ) );
+    pcb_text->SetHeight( mapDim( data.height ) );
+    pcb_text->SetThickness( mapDim( data.thickness == 0 ? m_defaultThickness
+                                    : data.thickness ) );
+    pcb_text->SetText( text );
+
+    m_brd->Add( pcb_text );
+}
+
+
+/**
+ * Import multi line texts (MTEXT).
+ */
+void DXF2BRD_CONVERTER::addMText( const DRW_MText& data )
+{
+    wxString    text = toNativeString( wxString::FromUTF8( data.text.c_str() ) );
+    wxString    attrib, tmp;
+
+    /* Some texts start by '\' and have formating chars (font name, font option...)
+     *  ending with ';'
+     *  Here are some mtext formatting codes:
+     *  Format code        Purpose
+     * \0...\o            Turns overline on and off
+     *  \L...\l            Turns underline on and off
+     * \~                 Inserts a nonbreaking space
+     \\                 Inserts a backslash
+     \\\{...\}            Inserts an opening and closing brace
+     \\ \File name;        Changes to the specified font file
+     \\ \Hvalue;           Changes to the text height specified in drawing units
+     \\ \Hvaluex;          Changes the text height to a multiple of the current text height
+     \\ \S...^...;         Stacks the subsequent text at the \, #, or ^ symbol
+     \\ \Tvalue;           Adjusts the space between characters, from.75 to 4 times
+     \\ \Qangle;           Changes obliquing angle
+     \\ \Wvalue;           Changes width factor to produce wide text
+     \\ \A                 Sets the alignment value; valid values: 0, 1, 2 (bottom, center, top)    while( text.StartsWith( wxT("\\") ) )
+     */
+    while( text.StartsWith( wxT( "\\" ) ) )
+    {
+        attrib << text.BeforeFirst( ';' );
+        tmp     = text.AfterFirst( ';' );
+        text    = tmp;
+    }
+
+    TEXTE_PCB*  pcb_text = new TEXTE_PCB( m_brd );
+    pcb_text->SetLayer( m_brdLayer );
+    wxPoint     textpos( mapX( data.basePoint.x ), mapY( data.basePoint.y ) );
+    pcb_text->SetTextPosition( textpos );
+    pcb_text->SetOrientation( data.angle * 10 );
+    // The 0.8 factor gives a better height/width ratio with our font
+    pcb_text->SetWidth( mapDim( data.height * 0.8 ) );
+    pcb_text->SetHeight( mapDim( data.height ) );
+    pcb_text->SetThickness( mapDim( data.thickness == 0 ? m_defaultThickness
+                                    : data.thickness ) );
+    pcb_text->SetText( text );
+
+    // Initialize text justifications:
+    if( data.textgen <= 3 )
+    {
+        pcb_text->SetVertJustify( GR_TEXT_VJUSTIFY_TOP );
+    }
+    else if( data.textgen <= 6 )
+    {
+        pcb_text->SetVertJustify( GR_TEXT_VJUSTIFY_CENTER );
+    }
+    else
+    {
+        pcb_text->SetVertJustify( GR_TEXT_VJUSTIFY_BOTTOM );
+    }
+
+    if( data.textgen % 3 == 1 )
+    {
+        pcb_text->SetHorizJustify( GR_TEXT_HJUSTIFY_LEFT );
+    }
+    else if( data.textgen % 3 == 2 )
+    {
+        pcb_text->SetHorizJustify( GR_TEXT_HJUSTIFY_CENTER );
+    }
+    else
+    {
+        pcb_text->SetHorizJustify( GR_TEXT_HJUSTIFY_RIGHT );
+    }
+
+#if 0   // These setting have no mening in Pcbnew
+    if( data.alignH==1 )
+    {
+        // Text is left to right;
+    }
+    else if( data.alignH == 3 )
+    {
+        // Text is top to bottom;
+    }
+    else
+    {
+        // use ByStyle;
+    }
+
+    if( data.alignV==1 )
+    {
+        // use AtLeast;
+    }
+    else
+    {
+        // useExact;
+    }
+#endif
+
+    m_brd->Add( pcb_text );
+}
+
+
+/**
+ * Sets the header variables from the DXF file.
+ */
+void DXF2BRD_CONVERTER::addHeader( const DRW_Header* data )
+{
+    std::map<std::string, DRW_Variant*>::const_iterator it;
+
+    for( it = data->vars.begin(); it != data->vars.end(); it++ )
+    {
+        std::string key = ( (*it).first ).c_str();
+
+        if( key == "$DWGCODEPAGE" )
+        {
+            DRW_Variant* var = (*it).second;
+            m_codePage = ( *var->content.s );
+        }
+    }
+}
+
+
+/**
+ * Converts a native unicode string into a DXF encoded string.
+ *
+ * DXF endoding includes the following special sequences:
+ * - %%%c for a diameter sign
+ * - %%%d for a degree sign
+ * - %%%p for a plus/minus sign
+ */
+wxString DXF2BRD_CONVERTER::toDxfString( const wxString& str )
+{
+    wxString    res;
+    int         j = 0;
+
+    for( unsigned i = 0; i<str.length(); ++i )
+    {
+        int c = str[i];
+
+        if( c>175 || c<11 )
+        {
+            res.append( str.Mid( j, i - j ) );
+            j = i;
+
+            switch( c )
+            {
+            case 0x0A:
+                res += wxT("\\P");
+                break;
+
+                // diameter:
+#ifdef __WINDOWS_
+            // windows, as always, is special.
+            case 0x00D8:
+#else
+            case 0x2205:
+#endif
+                res += wxT("%%C");
+                break;
+
+            // degree:
+            case 0x00B0:
+                res += wxT("%%D");
+                break;
+
+            // plus/minus
+            case 0x00B1:
+                res += wxT("%%P");
+                break;
+
+            default:
+                j--;
+                break;
+            }
+
+            j++;
+        }
+    }
+
+    res.append( str.Mid( j ) );
+    return res;
+}
+
+
+/**
+ * Converts a DXF encoded string into a native Unicode string.
+ */
+wxString DXF2BRD_CONVERTER::toNativeString( const wxString& data )
+{
+    wxString    res;
+
+    // Ignore font tags:
+    int         j = 0;
+
+    for( unsigned i = 0; i<data.length(); ++i )
+    {
+        if( data[ i ] == 0x7B )                                     // is '{' ?
+        {
+            if( data[ i + 1 ] == 0x5c && data[ i + 2 ] == 0x66 )    // is "\f" ?
+            {
+                // found font tag, append parsed part
+                res.append( data.Mid( j, i - j ) );
+
+                // skip to ';'
+                for( unsigned k = i + 3; k < data.length(); ++k )
+                {
+                    if( data[ k ] == 0x3B )
+                    {
+                        i = j = ++k;
+                        break;
+                    }
+                }
+
+                // add to '}'
+                for( unsigned k = i; k<data.length(); ++k )
+                {
+                    if( data[ k ] == 0x7D )
+                    {
+                        res.append( data.Mid( i, k - i ) );
+                        i = j = ++k;
+                        break;
+                    }
+                }
+            }
+        }
+    }
+
+    res.append( data.Mid( j ) );
+
+#if 1
+    wxRegEx regexp;
+    // Line feed:
+    regexp.Compile( wxT( "\\\\P" ) );
+    regexp.Replace( &res, wxT( "\n" ) );
+
+    // Space:
+    regexp.Compile( wxT( "\\\\~" ) );
+    regexp.Replace( &res, wxT( " " ) );
+
+    // diameter:
+    regexp.Compile( wxT( "%%[cC]" ) );
+#ifdef __WINDOWS__
+    // windows, as always, is special.
+    regexp.Replace( &res, wxChar( 0xD8 ) );
+#else
+    // Empty_set, diameter is 0x2300
+    regexp.Replace( &res, wxChar( 0x2205 ) );
+#endif
+
+    // degree:
+    regexp.Compile( wxT( "%%[dD]" ) );
+    regexp.Replace( &res, wxChar( 0x00B0 ) );
+    // plus/minus
+    regexp.Compile( wxT( "%%[pP]" ) );
+    regexp.Replace( &res, wxChar( 0x00B1 ) );
+#endif
+
+    return res;
+}
+
+
+void DXF2BRD_CONVERTER::addTextStyle( const DRW_Textstyle& data )
+{
+    // TODO
+}

pcbnew/import_dxf/dxf2brd_items.h

+/****************************************************************************
+**
+** This file comes from the LibreCAD project, a 2D CAD program
+**
+** Copyright (C) 2011 Rallaz, rallazz@gmail.com
+** Copyright (C) 2010 R. van Twisk (librecad@rvt.dds.nl)
+**
+**
+** This file may be distributed and/or modified 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.
+**
+** This program is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+** GNU General Public License for more details.
+**
+** You should have received a copy of the GNU General Public License
+** along with this program; if not, write to the Free Software
+** Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+**
+**********************************************************************/
+
+
+#ifndef FILTERDXFRW_H
+#define FILTERDXFRW_H
+
+#include "drw_interface.h"
+#include "wx/wx.h"
+
+class dxfRW;
+class BOARD;
+
+/**
+ * This format filter class can import and export DXF files.
+ * It depends on the dxflib library.
+ *
+ * @author Rallaz
+ */
+class DXF2BRD_CONVERTER : public DRW_Interface
+{
+private:
+    BOARD * m_brd;
+    double m_xOffset;       // X coord offset for conversion (in mm)
+    double m_yOffset;       // Y coord offset for conversion (in mm)
+    double m_defaultThickness;  // default line thickness for conversion (in dxf units)
+    double m_Dfx2mm;        // The scale factor to convert DXF units to mm
+    int    m_brdLayer;      // The board layer to place imported dfx items
+    int m_version;
+    std::string m_codePage;
+    dxfRW* m_dxf;
+
+public:
+    DXF2BRD_CONVERTER();
+    ~DXF2BRD_CONVERTER();
+
+    /**
+     * Set the coordinate offset between the importede dxf items
+     * and Pcbnew.
+     * because dxf files have the Y axis from bottom to top;
+     * aOffsetX = 0, and aOffsetY = - vertical page size to import a full page
+     * @param aOffsetX = the X offset in mm
+     * @param aOffsetY = the Y offset in mm
+     */
+    void SetOffset( double aOffsetX, double aOffsetY )
+    {
+        m_xOffset =aOffsetX;
+        m_yOffset =aOffsetY;
+    }
+
+    /**
+     * Set the layer number to import dxf items.
+     * the layer should be a techicanl layer, not a copper layer
+     */
+    void SetBrdLayer( int aBrdLayer ) { m_brdLayer = aBrdLayer; }
+
+    bool ImportDxfFile(  const wxString& aFile, BOARD * aBoard );
+
+private:
+    // coordinate conversions from dxf to internal units
+    int mapX( double aDxfCoordX );
+    int mapY( double aDxfCoordY );
+    int mapDim( double aDxfValue );
+
+    // Methods from DRW_CreationInterface:
+    // They are "call back" fonctions, called when the corresponding object
+    // is read in dxf file
+    // Depending of the application, they can do something or not
+    virtual void addHeader( const DRW_Header* data );
+    virtual void addLType( const DRW_LType& data ){}
+    virtual void addLayer( const DRW_Layer& data );
+    virtual void addDimStyle( const DRW_Dimstyle& data ){}
+    virtual void addBlock(const DRW_Block& data ){}
+    virtual void endBlock(){}
+    virtual void addPoint(const DRW_Point& data ){}
+    virtual void addLine(const DRW_Line& data);
+    virtual void addRay(const DRW_Ray& data ){}
+    virtual void addXline(const DRW_Xline& data ){}
+    virtual void addCircle(const DRW_Circle& data );
+    virtual void addArc(const DRW_Arc& data );
+    virtual void addEllipse(const DRW_Ellipse& data ){}
+    virtual void addLWPolyline(const DRW_LWPolyline& data ){}
+    virtual void addText(const DRW_Text& data );
+    virtual void addPolyline(const DRW_Polyline& data ){}
+    virtual void addSpline(const DRW_Spline* data ){}
+    virtual void addKnot(const DRW_Entity&) {}
+    virtual void addInsert(const DRW_Insert& data ){}
+    virtual void addTrace(const DRW_Trace& data ){}
+    virtual void addSolid(const DRW_Solid& data ){}
+    virtual void addMText(const DRW_MText& data);
+    virtual void addDimAlign(const DRW_DimAligned *data ){}
+    virtual void addDimLinear(const DRW_DimLinear *data ){}
+    virtual void addDimRadial(const DRW_DimRadial *data ){}
+    virtual void addDimDiametric(const DRW_DimDiametric *data ){}
+    virtual void addDimAngular(const DRW_DimAngular *data ){}
+    virtual void addDimAngular3P(const DRW_DimAngular3p *data ){}
+    virtual void addDimOrdinate(const DRW_DimOrdinate *data ){}
+    virtual void addLeader(const DRW_Leader *data ){}
+    virtual void addHatch(const DRW_Hatch* data ){}
+    virtual void addImage(const DRW_Image* data ){}
+    virtual void linkImage(const DRW_ImageDef* data ){}
+
+    virtual void add3dFace(const DRW_3Dface& data ){}
+    virtual void addComment(const char*){}
+
+     virtual void addVport(const DRW_Vport& data) {}
+
+    virtual void addTextStyle(const DRW_Textstyle& data);
+
+    virtual void addViewport(const DRW_Viewport& data) {}
+
+    virtual void setBlock(const int handle) {}
+
+    static wxString toDxfString(const wxString& str);
+    static wxString toNativeString(const wxString& data);
+
+    // These functions are not used in Kicad.
+    // But because they are virtual pure in DRW_Interface, they should be defined
+    virtual void writeTextstyles() {}
+    virtual void writeVports() {}
+    virtual void writeHeader(DRW_Header& data) {}
+    virtual void writeEntities() {}
+    virtual void writeLTypes() {}
+    virtual void writeLayers() {}
+    virtual void writeBlockRecords() {}
+    virtual void writeBlocks() {}
+    virtual void writeDimstyles() {}
+
+    void writeLine();
+    void writeMtext();
+
+};
+
+#endif  // FILTERDXFRW_H

pcbnew/invoke_pcb_dialog.h

+/**
+ * @file invoke_pcb_dialog.h
+ */
 
-/*
- * This program source code file is part of KiCad, a free EDA CAD application.
+/* This program source code file is part of KiCad, a free EDA CAD application.
  *
  * Copyright (C) 2013 SoftPLC Corporation, Dick Hollenbeck <dick@softplc.com>
  * Copyright (C) 2013 KiCad Developers, see change_log.txt for contributors.
@@ -75,5 +77,14 @@ int InvokePcbLibTableEditor( wxTopLevelWindow* aCaller, FP_LIB_TABLE* aGlobal, F
 void InvokePluginOptionsEditor( wxTopLevelWindow* aCaller,
         const wxString& aNickname, const wxString& aOptions, wxString* aResult );
 
+/**
+ * Function InvokePcbLibTableEditor
+ * shows the modal DIALOG_FP_LIB_TABLE for purposes of editing two lib tables.
+ *
+ * @param aCaller is the wxTopLevelWindow which is invoking the dialog.
+ * @return true if the ilport was made.
+ */
+bool InvokeDXFDialogImport( PCB_EDIT_FRAME* aCaller );
+
 
 #endif  // INVOKE_A_DIALOG_H_

pcbnew/menubar_pcbframe.cpp

@@ -174,6 +174,11 @@ void PCB_EDIT_FRAME::ReCreateMenuBar()
                  _( "Import a routed \"Specctra Session\" (*.ses) file" ),
                  KiBitmap( import_xpm ) );
 
+    AddMenuItem( submenuImport, ID_GEN_IMPORT_DXF_FILE,
+                 _( "&DXF File" ),
+                 _( "Import a 2D Drawing DXF file to Pcbnew on the Drawings layer" ),
+                 KiBitmap( import_xpm ) );
+
     AddMenuItem( filesMenu, submenuImport,
                  ID_GEN_IMPORT_FILE, _( "&Import" ),
                  _( "Import files" ), KiBitmap( import_xpm ) );

pcbnew/pcbframe.cpp

@@ -105,6 +105,7 @@ BEGIN_EVENT_TABLE( PCB_EDIT_FRAME, PCB_BASE_FRAME )
 
     EVT_MENU( ID_GEN_IMPORT_SPECCTRA_SESSION,PCB_EDIT_FRAME::ImportSpecctraSession )
     EVT_MENU( ID_GEN_IMPORT_SPECCTRA_DESIGN, PCB_EDIT_FRAME::ImportSpecctraDesign )
+    EVT_MENU( ID_GEN_IMPORT_DXF_FILE, PCB_EDIT_FRAME::Process_Special_Functions )
 
     EVT_MENU( ID_MENU_ARCHIVE_NEW_MODULES, PCB_EDIT_FRAME::Process_Special_Functions )
     EVT_MENU( ID_MENU_ARCHIVE_ALL_MODULES, PCB_EDIT_FRAME::Process_Special_Functions )

pcbnew/pcbnew_id.h

@@ -252,6 +252,7 @@ enum pcbnew_ids
     ID_GEN_EXPORT_FILE_MODULE_REPORT,
     ID_GEN_IMPORT_SPECCTRA_SESSION,
     ID_GEN_IMPORT_SPECCTRA_DESIGN,
+    ID_GEN_IMPORT_DXF_FILE,
 
     ID_TOOLBARH_PCB_MODE_MODULE,
     ID_TOOLBARH_PCB_MODE_TRACKS,