kicad/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

    version = DRW::UNKNOWNV;

    binary = false;
    iface = NULL;
    entCount = 0;
    wlayer0 = false;
    dimstyleStd = false;
    writingBlock = false;
    currHandle = 0;
}


dxfRW::~dxfRW()
{
    if( reader != NULL )
        delete reader;

    if( writer != NULL )
        delete writer;

    for( std::vector<DRW_ImageDef*>::iterator it = imageDef.begin(); it!=imageDef.end(); ++it )
        delete *it;

    imageDef.clear();
}


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 )
{
    std::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 );

    if( !ent->extData.empty() )
    {
        writeExtData( ent->extData );
    }

// 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::writeAppId( DRW_AppId* ent )
{
    writer->writeString( 0, "APPID" );

    if( version > DRW::AC1009 )
    {
        writer->writeString( 5, toHexStr( ++entCount ) );

        if( version > DRW::AC1014 )
        {
            writer->writeString( 330, "9" );
        }

        writer->writeString( 100, "AcDbSymbolTableRecord" );
        writer->writeString( 100, "AcDbRegAppTableRecord" );
        writer->writeUtf8String( 2, ent->name );
    }
    else
    {
        writer->writeUtf8Caps( 2, ent->name );
    }

    writer->writeInt16( 70, ent->flags );
    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" );

        if( !ent->getName().empty() )
        {
            writer->writeString( 2, ent->getName() );
        }

        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] = toHexStr( 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 );
    iface->writeAppId();
    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 );
        }
    }

    /* allways call writeBlockRecords to iface for prepare unnamed blocks */
    iface->writeBlockRecords();

    if( version > DRW::AC1009 )
    {
        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<std::string, std::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<std::string, std::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;
}


bool dxfRW::writeExtData( const std::vector<DRW_Variant*>& ed )
{
    for( std::vector<DRW_Variant*>::const_iterator it = ed.begin(); it!=ed.end(); ++it )
    {
        switch( (*it)->code )
        {
        case 1000:
        case 1001:
        case 1002:
        case 1003:
        case 1004:
        case 1005:
        {
            int cc = (*it)->code;

            if( (*it)->type == DRW_Variant::STRING )
                writer->writeUtf8String( cc, *(*it)->content.s );

// writer->writeUtf8String((*it)->code, (*it)->content.s);
            break;
        }

        case 1010:
        case 1011:
        case 1012:
        case 1013:

            if( (*it)->type == DRW_Variant::COORD )
            {
                writer->writeDouble( (*it)->code, (*it)->content.v->x );
                writer->writeDouble( (*it)->code + 10, (*it)->content.v->y );
                writer->writeDouble( (*it)->code + 20, (*it)->content.v->z );
            }

            break;

        case 1040:
        case 1041:
        case 1042:

            if( (*it)->type == DRW_Variant::DOUBLE )
                writer->writeDouble( (*it)->code, (*it)->content.d );

            break;

        case 1070:

            if( (*it)->type == DRW_Variant::INTEGER )
                writer->writeInt16( (*it)->code, (*it)->content.i );

            break;

        case 1071:

            if( (*it)->type == DRW_Variant::INTEGER )
                writer->writeInt32( (*it)->code, (*it)->content.i );

            break;

        default:
            break;
        }
    }

    return true;
}


/********* Reader Process *********/

bool dxfRW::processDxf()
{
    DBG( "dxfRW::processDxf() start processing dxf\n" );
    int code;
    bool more = true;
    std::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;
    std::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;
    std::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;
    std::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;
    std::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;
    std::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;
    std::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;
    std::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;
}


bool dxfRW::processAppId()
{
    DBG( "dxfRW::processAppId" );
    int code;
    std::string sectionstr;
    bool reading = false;
    DRW_AppId vp;

    while( reader->readRec( &code, !binary ) )
    {
        DBG( code ); DBG( "\n" );

        if( code == 0 )
        {
            if( reading )
                iface->addAppId( vp );

            sectionstr = reader->getString();
            DBG( sectionstr ); DBG( "\n" );

            if( sectionstr == "APPID" )
            {
                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;
    std::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__)
    char buffer[9] = { '\0' };
    snprintf( buffer, sizeof(buffer), "%X", n );
    return std::string( buffer );
#else
    std::ostringstream Convert;
    Convert << std::uppercase << std::hex << n;
    return Convert.str();
#endif
}