drawing.c

AutoCAD DWG-file viewer

	{
	last_entity = entities = entity;
	}
last_entity->next = NULL;
last_entity->type = type;
}


PRIVATE void read_point( void )

{
AcadPoint *acad_point;

acad_point = AcadPoint__create();
add_entity( ( AcadEntity * )acad_point, ACAD_POINT );
AcadPoint__read( acad_point );
if ( debugger ) AcadPoint__dump_to_debug_file( acad_point );
}


PRIVATE void read_circle( void )

{
AcadCircle *acad_circle;

acad_circle = AcadCircle__create();
add_entity( ( AcadEntity * )acad_circle, ACAD_CIRCLE );
AcadCircle__read( acad_circle );
if ( debugger ) AcadCircle__dump_to_debug_file( acad_circle );
}


PRIVATE void read_line( void )

{
AcadLine *acad_line;

acad_line = AcadLine__create();
add_entity( ( AcadEntity * )acad_line, ACAD_LINE);
AcadLine__read( acad_line );
if ( debugger ) AcadLine__dump_to_debug_file( acad_line );
}


PRIVATE void read_trace( void )

{
AcadTrace *acad_trace;

acad_trace = AcadTrace__create();
add_entity( ( AcadEntity * )acad_trace, ACAD_TRACE );
AcadTrace__read( acad_trace );
if ( debugger ) AcadTrace__dump_to_debug_file( acad_trace );
}


PRIVATE void read_arc( void )

{
AcadArc *acad_arc;

acad_arc = AcadArc__create();
add_entity( ( AcadEntity * )acad_arc, ACAD_ARC );
AcadArc__read( acad_arc );
if ( debugger ) AcadArc__dump_to_debug_file( acad_arc );
}


PRIVATE void read_text( void )

{
AcadText *acad_text;

acad_text = AcadText__create();
add_entity( ( AcadEntity * )acad_text, ACAD_TEXT );
AcadText__read( acad_text );
if ( debugger ) AcadText__dump_to_debug_file( acad_text );
}


PRIVATE void read_shape( void )

{
AcadShape *acad_shape;

acad_shape = AcadShape__create();
add_entity( ( AcadEntity * )acad_shape, ACAD_SHAPE );
AcadShape__read( acad_shape );
if ( debugger ) AcadShape__dump_to_debug_file( acad_shape );
}


PRIVATE void read_solid( void )

{
AcadSolid *acad_solid;

acad_solid = AcadSolid__create();
add_entity( ( AcadEntity * )acad_solid, ACAD_SOLID );
AcadSolid__read( acad_solid );
if ( debugger ) AcadSolid__dump_to_debug_file( acad_solid );
}


PRIVATE void read_insert_base( void )

{
AcadInsertBase *acad_insert_base;

acad_insert_base = AcadInsertBase__create();
add_entity( ( AcadEntity * )acad_insert_base, ACAD_INSERT_BASE );
AcadInsertBase__read( acad_insert_base );
if ( debugger ) AcadInsertBase__dump_to_debug_file( acad_insert_base );
}


PRIVATE void read_endblk( void )

{
AcadEndBlk *acad_endblk;

acad_endblk = AcadEndBlk__create();
add_entity( ( AcadEntity * )acad_endblk, ACAD_ENDBLK );
AcadEndBlk__read( acad_endblk );
if ( debugger ) AcadEndBlk__dump_to_debug_file( acad_endblk );
}


PRIVATE void read_insert( void )

{
AcadInsert *acad_insert;

acad_insert = AcadInsert__create();
add_entity( ( AcadEntity * )acad_insert, ACAD_INSERT );
AcadInsert__read( acad_insert );
if ( debugger ) AcadInsert__dump_to_debug_file( acad_insert );
}


PRIVATE void read_attdef( void )

{
AcadAttdef *acad_attdef;

acad_attdef = AcadAttdef__create();
add_entity( ( AcadEntity * )acad_attdef, ACAD_ATTDEF );
AcadAttdef__read( acad_attdef );
if ( debugger ) AcadAttdef__dump_to_debug_file( acad_attdef );
}


PRIVATE void read_attrib( void )

{
AcadAttrib *acad_attrib;

acad_attrib = AcadAttrib__create();
add_entity( ( AcadEntity * )acad_attrib, ACAD_ATTRIB );
AcadAttrib__read( acad_attrib );
if ( debugger ) AcadAttrib__dump_to_debug_file( acad_attrib );
}


PRIVATE void read_seqend( void )

{
AcadSeqend *acad_seqend;

acad_seqend = AcadSeqend__create();
add_entity( ( AcadEntity * )acad_seqend, ACAD_SEQEND );
AcadSeqend__read( acad_seqend );
if ( debugger ) AcadSeqend__dump_to_debug_file( acad_seqend );
}


PRIVATE void read_pline( void )

{
AcadPline *acad_pline;

acad_pline = AcadPline__create();
add_entity( ( AcadEntity * )acad_pline, ACAD_PLINE );
AcadPline__read( acad_pline );
if ( debugger ) AcadPline__dump_to_debug_file( acad_pline );
}


PRIVATE void read_indirect( void )

{
INT32 next_file_position;
AcadIndirect *acad_indirect;

next_file_position = __drawing->file_position-1;
acad_indirect = AcadIndirect__create();
AcadIndirect__read( acad_indirect );
if ( debugger ) AcadIndirect__dump_to_debug_file( acad_indirect );

next_file_position += acad_indirect->common.size;
file_seek( __drawing->header->indirects_start + AcadIndirect__offset( acad_indirect ) );
read_entity();
file_seek( next_file_position );
}


PRIVATE void read_vertex( AcadPline *pline )

{
AcadVertex *acad_vertex;

acad_vertex = AcadVertex__create( pline );
add_entity( ( AcadEntity * )acad_vertex, ACAD_VERTEX );
AcadVertex__read( acad_vertex );
if ( debugger ) AcadVertex__dump_to_debug_file( acad_vertex );
}


PRIVATE void read_line3d( void )

{
AcadLine3d *acad_line3d;

acad_line3d = AcadLine3d__create();
add_entity( ( AcadEntity * )acad_line3d, ACAD_LINE3D );
AcadLine3d__read( acad_line3d );
if ( debugger ) AcadLine3d__dump_to_debug_file( acad_line3d );
}


PRIVATE void read_face3d( void )

{
AcadFace3d *acad_face3d;

acad_face3d = AcadFace3d__create();
add_entity( ( AcadEntity * )acad_face3d, ACAD_FACE3D );
AcadFace3d__read( acad_face3d );
if ( debugger ) AcadFace3d__dump_to_debug_file( acad_face3d );
}


PRIVATE void read_dimension( void )

{
AcadDimension *acad_dimension;

acad_dimension = AcadDimension__create();
add_entity( ( AcadEntity * )acad_dimension, ACAD_DIMENSION );
AcadDimension__read( acad_dimension );
if ( debugger ) AcadDimension__dump_to_debug_file( acad_dimension );
}


PRIVATE void read_vport( void )

{
AcadVport *acad_vport;

acad_vport = AcadVport__create();
add_entity( ( AcadEntity * )acad_vport, ACAD_VPORT );
AcadVport__read( acad_vport );
if ( debugger ) AcadVport__dump_to_debug_file( acad_vport );
}


PRIVATE int read_dummy( void ) /* and return size */

{
AcadEntity common;

AcadEntity__read_elevation_etc( &common,!__drawing->acad10 AND !__drawing->acad11,true );
return( common.size );
}


PRIVATE boolean read_entity( void )

{
boolean deleted;
UINT8 type;
INT32 next_file_position;
static AcadPline *pline;

next_file_position = __drawing->file_position;
get_UINT8( &type );

if ( debugger ) dprintf( "\n****** ENTITY type %xH at %lx ******\n",type&0x7f,__drawing->file_position-1 );
deleted = type & 0x80;

if ( deleted ) 
	{
	file_seek( next_file_position+read_dummy() );
	return( true );
	}

switch( type & 0x7f )
	{
	case 0x1  	:read_line();
		   	 break;
	case 0x2  	:read_point();
		   	 break;
	case 0x3  	:read_circle();
		   	 break;
	case 0x4  	:read_shape();
		  	 break;
	case 0x7  	:read_text();
		  	 break;
	case 0x8  	:read_arc();
		  	 break;
	case 0x9  	:read_trace();
		  	 break;
	case 0xb  	:read_solid();
		  	 break;
	case 0xc  	:read_insert_base();
		  	 break;
	case 0xd  	:read_endblk();
			 return( false );
	case 0xe  	:read_insert();
		  	 break;
	case 0xf  	:read_attdef();
		  	 break;
	case 0x10  	:read_attrib();
		  	 break;
	case 0x11  	:read_seqend();
			 break;
	case 0x12  	:read_indirect();
			 return( true );
	case 0x13  	:read_pline();
			 pline = ( AcadPline * )last_entity;
			 break;
	case 0x14  	:read_vertex( pline );
		  	 break;
	case 0x15  	:read_line3d();
		  	 break;
	case 0x16  	:read_face3d();
		  	 break;
	case 0x17  	:read_dimension();
		  	 break;
	case 0x18  	:read_vport();
		  	 break;
	default	  	:read_error( "Unknown entity type %xH",type & 0x7f );
		  	 break;
	}

file_seek( next_file_position + last_entity->size );
return( true );
}


PRIVATE void read_entities( void )

{
file_seek( __drawing->header->entities_start );
while ( __drawing->file_position < __drawing->header->block_names_start )
	{
	read_entity();
	}
__drawing->entities = entities;
entities = NULL;
}


PRIVATE void read_block_entities( void )

{
int block;

for( block = 0; block < __drawing->header->blocks; ++block )
	{
	if ( __drawing->block[ block ]->deleted ) continue;
	if ( !__drawing->block[ block ]->xref )
		{
		file_seek( __drawing->header->blocks_start+__drawing->block[ block ]->offset );
		while ( read_entity() );
		__drawing->block[ block ]->entities = entities;
		entities = NULL;
		}
	}
}


PUBLIC char *full_block_name( int index )

{
if ( index < 0 ) return ( "" );
if ( index >= __drawing->header->blocks ) return( "" );
return( __drawing->block[ index ]->full_name );
}



PUBLIC char *ucs_name( int index )

{
if ( index < 0 ) return( "" );
if ( index >= __drawing->header->ucss ) return( "" );
return( __drawing->ucs[ index ]->name );
}



PUBLIC char *application_name( int index )

{
if ( index < 0 ) return( "" );
if ( index >= __drawing->header->applications ) return( "" );
return( __drawing->appid[ index ]->name );
}



PUBLIC char *layer_name( int index )

{
if ( index < 0 ) return ( "0" );
if ( index >= __drawing->header->layers ) return( "0" );
return( __drawing->layer[ index ]->name );
}



PUBLIC char *line_type_name( int index )

{
if ( __drawing->header->line_types EQ 0 ) return( "CONTINUOUS" );
if ( index < 0 ) return( "CONTINUOUS" );
if ( index >= __drawing->header->line_types ) return( "CONTINUOUS" );
return( __drawing->line_type[ index ]->name );
}