3986 lines
97 KiB
C++
3986 lines
97 KiB
C++
/******************************************************************************
|
|
** 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 h;
|
|
iface->writeHeader( h );
|
|
writer->writeString( 0, "SECTION" );
|
|
entCount = FIRSTHANDLE;
|
|
h.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->getDir() != 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, const 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( const 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 );
|
|
}
|
|
}
|
|
// Fall through
|
|
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
|
|
}
|
|
}
|
|
// Fall through
|
|
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
|
|
}
|