drawing.c

AutoCAD DWG-file viewer

PUBLIC char *dimstyle_name( int index )

{
if ( index <= 0 ) return( "*UNNAMED" );
if ( index > __drawing->header->dimstyles ) return( "*UNNAMED" );
return( __drawing->dim_style[ index-1 ]->name );
}



PUBLIC char *this_block_full_name( int *flag )

{
*flag = __drawing->block[ current_block ]->flag;
return( __drawing->block[ current_block ]->full_name );
}



PUBLIC char *this_block_name( void )

{
return( __drawing->block[ current_block ]->name );
}


PUBLIC char *style_name( int index )

{
if ( index < 0 ) return( "STANDARD" );
if ( index >= __drawing->header->styles ) return( "STANDARD" );
return( __drawing->font_style[ index ]->name );
}


PRIVATE void dump_entities_to_debug_file( AcadEntity *entity )

{
for ( ; entity; entity = entity->next )
	{
	switch( entity->type )
		{
		case ACAD_LINE		:AcadLine__dump_to_debug_file( ( AcadLine * )entity );
					 break;
		case ACAD_ARC		:AcadArc__dump_to_debug_file( ( AcadArc * )entity );
					 break;
		case ACAD_CIRCLE	:AcadCircle__dump_to_debug_file( ( AcadCircle * )entity );
					 break;
		case ACAD_POINT		:AcadPoint__dump_to_debug_file( ( AcadPoint * )entity );
					 break;
		case ACAD_TRACE		:AcadTrace__dump_to_debug_file( ( AcadTrace * )entity );
					 break;
		case ACAD_LINE3D	:AcadLine3d__dump_to_debug_file( ( AcadLine3d * )entity );
					 break;
		case ACAD_FACE3D	:AcadFace3d__dump_to_debug_file( ( AcadFace3d * )entity );
					 break;
		case ACAD_ATTDEF	:AcadAttdef__dump_to_debug_file( ( AcadAttdef * )entity );
					 break;
		case ACAD_ATTRIB	:AcadAttrib__dump_to_debug_file( ( AcadAttrib * )entity );
					 break;
		case ACAD_TEXT		:AcadText__dump_to_debug_file( ( AcadText * )entity );
					 break;
		case ACAD_SOLID		:AcadSolid__dump_to_debug_file( ( AcadSolid * )entity );
					 break;
		case ACAD_DIMENSION	:AcadDimension__dump_to_debug_file( ( AcadDimension * )entity );
					 break;
		case ACAD_INSERT	:AcadInsert__dump_to_debug_file( ( AcadInsert * )entity );
					 break;
		case ACAD_INSERT_BASE	:AcadInsertBase__dump_to_debug_file( ( AcadInsertBase * )entity );
					 break;
		case ACAD_SHAPE		:AcadShape__dump_to_debug_file( ( AcadShape * )entity );
					 break;
		case ACAD_ENDBLK	:AcadEndBlk__dump_to_debug_file( ( AcadEndBlk * )entity );
					 break;
		case ACAD_VERTEX	:AcadVertex__dump_to_debug_file( ( AcadVertex * )entity );
					 break;
		case ACAD_PLINE		:AcadPline__dump_to_debug_file( ( AcadPline * )entity );
					 break;
		case ACAD_SEQEND	:AcadSeqend__dump_to_debug_file( ( AcadSeqend * )entity );
					 break;
		case ACAD_VPORT		:AcadVport__dump_to_debug_file( ( AcadVport * )entity );
					 break;
		default			:;
					 break;
		}
	}
}


PUBLIC void AcadDrawing__dump_to_debug_file( AcadDrawing *drawing )

{
int viewport;
int line_type;
int layer;
int view;
int ucs;
int appid;
int font_style;
int dim_style;

AcadHeader__dump_to_debug_file( drawing->header );

for( viewport = 0; viewport < drawing->header->viewports; ++viewport )
	{
	AcadViewPort__dump_to_debug_file( drawing->viewport[ viewport ] );
	}

for( line_type = 0; line_type < drawing->header->line_types; ++line_type )
	{
	AcadLineType__dump_to_debug_file( drawing->line_type[ line_type ] );
	}

for( current_block = 0; current_block < drawing->header->blocks; ++current_block )
	{
	AcadBlock__dump_to_debug_file( drawing->block[ current_block ] );
	dump_entities_to_debug_file( drawing->block[ current_block ]->entities );
	}

for( layer = 0; layer < drawing->header->layers; ++layer )
	{
	AcadLayer__dump_to_debug_file( drawing->layer[ layer ] );
	}

for( font_style = 0; font_style < drawing->header->styles; ++font_style )
	{
	AcadFontStyle__dump_to_debug_file( drawing->font_style[ font_style ] );
	}

for( view = 0; view < drawing->header->views; ++view )
	{
	AcadView__dump_to_debug_file( drawing->view[ view ] );
	}

for( ucs = 0; ucs < drawing->header->ucss; ++ucs )
	{
	AcadUcs__dump_to_debug_file( drawing->ucs[ ucs ] );
	}

for( appid = 0; appid < drawing->header->applications; ++appid )
	{
	AcadAppID__dump_to_debug_file( drawing->appid[ appid ] );
	}

for( dim_style = 0; dim_style < drawing->header->dimstyles; ++dim_style )
	{
	AcadDimStyle__dump_to_debug_file( drawing->dim_style[ dim_style ] );
	}

dump_entities_to_debug_file( drawing->entities );
}


PUBLIC void AcadDrawing__dxfout( AcadDrawing *drawing, char *name )

{
dxfout( drawing,name );
}


PUBLIC void AcadDrawing__read( AcadDrawing *drawing )

{
if ( ( drawing->source_file = open( drawing->name,O_RDONLY | O_BINARY ) ) < 0 ) read_error( "Unable to open %s",drawing->name );
drawing->drawing_size = filelength( drawing->source_file );
if ( verbose ) printf( "Header" );
read_header();
lseek( drawing->source_file,0L,SEEK_SET ); 
read_in_file();
if ( verbose ) printf( "\r      \rViewports" );
read_viewports();
if ( verbose ) printf( "\r         \rLine types" );
read_line_types();
if ( verbose ) printf( "\r          \rLayers" );
read_layers();
if ( verbose ) printf( "\r      \rFont styles" );
read_font_styles();
if ( verbose ) printf( "\r           \rViews" );
read_views();
if ( verbose ) printf( "\r     \rUcss" );
read_ucss();
if ( drawing->acad11 )
	{
	read_appids();
	read_dim_styles();
	}
if ( verbose ) printf( "\r    \rBlocks" );
read_blocks();
if ( verbose ) printf( "\r      \rEntities" );
read_entities();
if ( verbose ) printf( "\r        \rBlock entities" );
read_block_entities();
if ( verbose ) printf( "\r              \n" );
close( drawing->source_file );
}


PRIVATE void write_entities( AcadEntity *entity )

{
static INT32 seqend_parent;

for ( ; entity; entity = entity->next )
	{
	switch( entity->type )
		{
		case ACAD_LINE		:AcadLine__write( ( AcadLine * )entity );
					 break;
		case ACAD_ARC		:AcadArc__write( ( AcadArc * )entity );
					 break;
		case ACAD_CIRCLE	:AcadCircle__write( ( AcadCircle * )entity );
					 break;
		case ACAD_POINT		:AcadPoint__write( ( AcadPoint * )entity );
					 break;
		case ACAD_SOLID		:AcadSolid__write( ( AcadSolid * )entity );
					 break;
		case ACAD_VERTEX	:AcadVertex__write( ( AcadVertex * )entity );
					 break;
		case ACAD_PLINE		:seqend_parent = __drawing->file_position;
		                         AcadPline__write( ( AcadPline * )entity );
					 break;
		case ACAD_SEQEND	:AcadSeqend__write( ( AcadSeqend * )entity, seqend_parent );
					 break;
		case ACAD_TRACE		:AcadTrace__write( ( AcadTrace * )entity );
					 break;
		case ACAD_LINE3D	:AcadLine3d__write( ( AcadLine3d * )entity );
					 break;
		case ACAD_FACE3D	:AcadFace3d__write( ( AcadFace3d * )entity );
					 break;
		case ACAD_INSERT_BASE	:AcadInsertBase__write( ( AcadInsertBase * )entity );
					 break;
		case ACAD_ENDBLK	:AcadEndBlk__write( ( AcadEndBlk * )entity );
					 break;
		case ACAD_INSERT	:AcadInsert__write( ( AcadInsert * )entity );
					 break;
		case ACAD_ATTDEF	:AcadAttdef__write( ( AcadAttdef * )entity );
					 break;
		case ACAD_ATTRIB	:seqend_parent = __drawing->file_position;
					 AcadAttrib__write( ( AcadAttrib * )entity );
					 break;
		case ACAD_TEXT		:AcadText__write( ( AcadText * )entity );
					 break;
		case ACAD_DIMENSION	:AcadDimension__write( ( AcadDimension * )entity );
					 break;
		case ACAD_SHAPE		:AcadShape__write( ( AcadShape * )entity );
					 break;
		case ACAD_VPORT		:AcadVport__write( ( AcadVport * )entity );
					 break;
		default			:;
					 break;
		}
	}
}


PRIVATE void write_layers( AcadDrawing *drawing )

{
int layer;

if ( debugger ) dprintf( "Layers %lxH\n",drawing->file_position );
for( layer = 0; layer < drawing->header->layers; ++layer )
	{
	AcadLayer__write( drawing->layer[ layer ] );
	}
}


PRIVATE void write_viewports( AcadDrawing *drawing )

{
int viewport;

if ( debugger ) dprintf( "Viewports %lxH\n",drawing->file_position );
for( viewport = 0; viewport < drawing->header->viewports; ++viewport )
	{
	AcadViewPort__write( drawing->viewport[ viewport ] );
	}
}


PRIVATE void write_views( AcadDrawing *drawing )

{
int view;

if ( debugger ) dprintf( "Views %lxH\n",drawing->file_position );
for( view = 1; view < drawing->header->views; ++view )
	{
	AcadView__write( drawing->view[ view ] );
	}
}


PRIVATE void write_line_types( AcadDrawing *drawing )

{
int line_type;

if ( debugger ) dprintf( "line types %lxH\n",drawing->file_position );
for( line_type = 0; line_type < drawing->header->line_types; ++line_type )
	{
	AcadLineType__write( drawing->line_type[ line_type ] );
	}
}


PRIVATE void write_ucss( AcadDrawing *drawing )

{
int ucs;

if ( debugger ) dprintf( "UCSs %lxH\n",drawing->file_position );
for( ucs = 0; ucs < drawing->header->ucss; ++ucs )
	{
	AcadUcs__write( drawing->ucs[ ucs ] );
	}
}


PRIVATE void write_block_entities( AcadDrawing *drawing, INT32 blocks_start, INT32 block_names_start )

{
for( current_block = 0; current_block < drawing->header->blocks; ++current_block )
	{
	set_block_names_offset( blocks_start,block_names_start,current_block );
	write_entities( drawing->block[ current_block ]->entities );
	}
}


PRIVATE void write_block_names( AcadDrawing *drawing )

{
int block;

for ( block = 0; block < drawing->header->blocks; ++block )
	{
	AcadBlock__write( drawing->block[ block ] );
	}

}


PRIVATE void write_font_styles( AcadDrawing *drawing )

{
int font_style;

if ( debugger ) dprintf( "font styles %lxH\n",drawing->file_position );
for( font_style = 0; font_style < drawing->header->styles; ++font_style )
	{
	AcadFontStyle__write( drawing->font_style[ font_style ] );
	}
}


PUBLIC void AcadDrawing__write( AcadDrawing *drawing, char *name )

{
char full_name[ 256 ];
INT32 layers_start;
INT32 font_styles_start;
INT32 line_types_start;
INT32 views_start;
INT32 ucss_start;
INT32 viewports_start;
INT32 block_names_start;
INT32 blocks_start;
INT32 indirect_start;
INT32 dwgmgr_start;

strcpy( full_name,name );
if ( drawing->name ) free( drawing->name );
drawing->name = get_memory( strlen( full_name )+1 );
strcpy( drawing->name,full_name );

__drawing = drawing;
drawing->file_position = 0;

if ( ( drawing->output_file = open( drawing->name,O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, 0666 ) ) < 0 ) 
	{
	warn_perror( "cannot open [%s]",drawing->name );
	read_error( "Failed" );
	}
AcadHeader__set_default( drawing->header );
AcadHeader__write( drawing->header );

write_entities( drawing->entities );

block_names_start = drawing->file_position;
write_block_names( drawing );

layers_start = drawing->file_position;
write_layers( drawing );

font_styles_start = drawing->file_position;
write_font_styles( drawing );

line_types_start = drawing->file_position;
write_line_types( drawing );

views_start = drawing->file_position;
write_views( drawing );

ucss_start = drawing->file_position;
write_ucss( drawing );

viewports_start = drawing->file_position;
write_viewports( drawing );

dwgmgr_start = drawing->file_position;
blocks_start = drawing->file_position;
write_block_entities( drawing,blocks_start,block_names_start );

indirect_start = drawing->file_position;

if ( debugger ) dprintf( "File end %lxH\n",drawing->file_position );

set_header_pointers( layers_start,font_styles_start,line_types_start,
		     views_start,ucss_start,viewports_start,blocks_start,
		     indirect_start,block_names_start,dwgmgr_start );

close( drawing->output_file );
}