drawing.c

AutoCAD DWG-file viewer

/****************************************************************/
/*			COPYRIGHT NOTICE			*/
/*			----------------			*/
/*  All software in this listing remain the strict copyright	*/
/*  of Ilija Kovacevic and cannot be copied or used in any way	*/
/*  except by written permission of Ilija Kovacevic.		*/
/*								*/
/*	Copyright (c) 1992 Ilija Kovacevic			*/
/*	www.kov.com   email [e-mail]			*/
/****************************************************************/

#define DWGINLOC /* define globals to this module */
#include "dwgin.h"

PRIVATE boolean read_entity( void );

static AcadEntity *entities;
static AcadEntity *last_entity;

PUBLIC AcadDrawing *AcadDrawing__create( char *name )

{
char full_name[ 256 ];
AcadDrawing *drawing;

__drawing = drawing = ( AcadDrawing * )get_memory( sizeof( AcadDrawing ) );
strcpy( full_name,name );
/*set_extension( full_name,"dwg" );*/
drawing->name = get_memory( strlen( full_name )+1 );
strcpy( drawing->name,full_name );
drawing->header = NULL;
drawing->viewport = NULL;
drawing->line_type = NULL;
drawing->layer = NULL;
drawing->block = NULL;
drawing->font_style = NULL;
drawing->view = NULL;
drawing->ucs = NULL;
drawing->appid = NULL;
drawing->dim_style = NULL;
drawing->entities = NULL;
return( drawing );
}


PRIVATE void free_viewports( void )

{
int viewport;
for( viewport = 0; viewport < __drawing->header->viewports; ++viewport )
	{
	AcadViewPort__delete( __drawing->viewport[ viewport ] );
	}
if ( __drawing->viewport ) free( ( char * )__drawing->viewport );
}


PRIVATE void free_line_types( void )

{
int line_type;
for( line_type = 0; line_type < __drawing->header->line_types; ++line_type )
	{
	AcadLineType__delete( __drawing->line_type[ line_type ] );
	}
if ( __drawing->line_type ) free( ( char * )__drawing->line_type );
}


PRIVATE void free_layers( void )

{
int layer;
for( layer = 0; layer < __drawing->header->layers; ++layer )
	{
	AcadLayer__delete( __drawing->layer[ layer ] );
	}
if ( __drawing->layer ) free( ( char * )__drawing->layer );
}


PRIVATE void free_entities( AcadEntity *entities )

{
AcadEntity *scrap;

for ( ; entities; )
	{
	scrap = entities;
	entities = entities->next;
	switch( scrap->type )
		{
		case ACAD_LINE		:AcadLine__delete( ( AcadLine * )scrap );
					 break;
		case ACAD_ARC		:AcadArc__delete( ( AcadArc * )scrap );
					 break;
		case ACAD_CIRCLE	:AcadCircle__delete( ( AcadCircle * )scrap );
					 break;
		case ACAD_POINT		:AcadPoint__delete( ( AcadPoint * )scrap );
					 break;
		case ACAD_TRACE		:AcadTrace__delete( ( AcadTrace * )scrap );
					 break;
		case ACAD_LINE3D	:AcadLine3d__delete( ( AcadLine3d * )scrap );
					 break;
		case ACAD_FACE3D	:AcadFace3d__delete( ( AcadFace3d * )scrap );
					 break;
		case ACAD_ATTDEF	:AcadAttdef__delete( ( AcadAttdef * )scrap );
					 break;
		case ACAD_ATTRIB	:AcadAttrib__delete( ( AcadAttrib * )scrap );
					 break;
		case ACAD_TEXT		:AcadText__delete( ( AcadText * )scrap );
					 break;
		case ACAD_SOLID		:AcadSolid__delete( ( AcadSolid * )scrap );
					 break;
		case ACAD_DIMENSION	:AcadDimension__delete( ( AcadDimension * )scrap );
					 break;
		case ACAD_INSERT	:AcadInsert__delete( ( AcadInsert * )scrap );
					 break;
		case ACAD_INSERT_BASE	:AcadInsertBase__delete( ( AcadInsertBase * )scrap );
					 break;
		case ACAD_SHAPE		:AcadShape__delete( ( AcadShape * )scrap );
					 break;
		case ACAD_ENDBLK	:AcadEndBlk__delete( ( AcadEndBlk * )scrap );
					 break;
		case ACAD_VERTEX	:AcadVertex__delete( ( AcadVertex * )scrap );
					 break;
		case ACAD_PLINE		:AcadPline__delete( ( AcadPline * )scrap );
					 break;
		case ACAD_SEQEND	:AcadSeqend__delete( ( AcadSeqend * )scrap );
					 break;
		case ACAD_VPORT		:AcadVport__delete( ( AcadVport * )scrap );
					 break;
		default			:;
					 break;
		}
	}
}


PRIVATE void free_blocks( void )

{
for( current_block = 0; current_block < __drawing->header->blocks; ++current_block )
	{
	free_entities( __drawing->block[ current_block ]->entities );
	AcadBlock__delete( __drawing->block[ current_block ] );
	}
if ( __drawing->block ) free( ( char * )__drawing->block );
}


PRIVATE void free_font_styles( void )

{
int font_style;
for( font_style = 0; font_style < __drawing->header->styles; ++font_style )
	{
	AcadFontStyle__delete( __drawing->font_style[ font_style ] );
	}
if ( __drawing->font_style ) free( ( char * )__drawing->font_style );
}


PRIVATE void free_views( void )

{
int view;
for( view = 0; view < __drawing->header->views; ++view )
	{
	AcadView__delete( __drawing->view[ view ] );
	}
if ( __drawing->view ) free( ( char * )__drawing->view );
}


PRIVATE void free_ucss( void )

{
int ucs;
for( ucs = 0; ucs < __drawing->header->ucss; ++ucs )
	{
	AcadUcs__delete( __drawing->ucs[ ucs ] );
	}
if ( __drawing->ucs ) free( ( char * )__drawing->ucs );
}


PRIVATE void free_appids( void )

{
int appid;
for( appid = 0; appid < __drawing->header->applications; ++appid )
	{
	AcadAppID__delete( __drawing->appid[ appid ] );
	}
if ( __drawing->appid ) free( ( char * )__drawing->appid );
}


PRIVATE void free_dim_styles( void )

{
int dim_style;
for( dim_style = 0; dim_style < __drawing->header->dimstyles; ++dim_style )
	{
	AcadDimStyle__delete( __drawing->dim_style[ dim_style ] );
	}
if ( __drawing->dim_style ) free( ( char * )__drawing->dim_style );
}


PUBLIC void AcadDrawing__delete( AcadDrawing *drawing )

{
if ( drawing->name ) free( drawing->name );
if ( drawing->header ) free( ( char * )drawing->header );
if ( drawing->viewport ) free_viewports();
if ( drawing->line_type ) free_line_types();
if ( drawing->layer ) free_layers();
if ( drawing->block ) free_blocks();
if ( drawing->font_style ) free_font_styles();
if ( drawing->view ) free_views();
if ( drawing->ucs ) free_ucss();
if ( drawing->appid ) free_appids();
if ( drawing->dim_style ) free_dim_styles();
if ( drawing->entities ) free_entities( drawing->entities );
if ( drawing ) free( ( char * )drawing );
}


PRIVATE void read_header( void )

{
__drawing->header = AcadHeader__create();
AcadHeader__read( __drawing->header );
if ( debugger ) AcadHeader__dump_to_debug_file( __drawing->header );
}


PRIVATE void read_viewports( void )

{
int viewport;
INT32 new_file_position;

if ( !__drawing->header->viewports ) return;
file_seek( __drawing->header->viewports_start );	
__drawing->viewport = ( AcadViewPort ** )get_memory( __drawing->header->viewports*sizeof( AcadViewPort ) );
for( viewport = 0; viewport < __drawing->header->viewports; ++viewport )
	{
	new_file_position = __drawing->file_position + __drawing->header->viewports_size;
	__drawing->viewport[ viewport ] = AcadViewPort__create();
	AcadViewPort__read( __drawing->viewport[ viewport ] );
	if ( debugger ) AcadViewPort__dump_to_debug_file( __drawing->viewport[ viewport ] );
	file_seek( new_file_position );
	}
}


PRIVATE void read_line_types( void )

{
int line_type;
INT32 new_file_position;

if ( !__drawing->header->line_types ) return;
file_seek( __drawing->header->line_types_start );	
__drawing->line_type = ( AcadLineType ** )get_memory( __drawing->header->line_types*sizeof( AcadLineType ) );
for( line_type = 0; line_type < __drawing->header->line_types; ++line_type )
	{
	new_file_position = __drawing->file_position + __drawing->header->line_type_size;
	__drawing->line_type[ line_type ] = AcadLineType__create();
	AcadLineType__read( __drawing->line_type[ line_type ] );
	if ( debugger ) AcadLineType__dump_to_debug_file( __drawing->line_type[ line_type ] );
	file_seek( new_file_position );
	}
}


PRIVATE void read_blocks( void )

{
INT32 new_file_position;
char block_name_start[ 0x20 ];
int block;

if ( !__drawing->header->blocks ) return;
file_seek( __drawing->header->block_names_start );	
if ( __drawing->acad11 ) get_array( &block_name_start,sizeof( block_name_start ) );
__drawing->block = ( AcadBlock ** )get_memory( __drawing->header->blocks*sizeof( AcadBlock ) );
for( block = 0; block < __drawing->header->blocks; ++block )
	{
	new_file_position = __drawing->file_position + __drawing->header->block_name_size;
	__drawing->block[ block ] = AcadBlock__create();
	AcadBlock__read( __drawing->block[ block ],block );
	if ( debugger ) AcadBlock__dump_to_debug_file( __drawing->block[ block ] );
	file_seek( new_file_position );
	}
}


PRIVATE void read_layers( void )

{
int layer;
INT32 new_file_position;

if ( !__drawing->header->layers ) return;
file_seek( __drawing->header->layers_start );	
__drawing->layer = ( AcadLayer ** )get_memory( __drawing->header->layers*sizeof( AcadLayer ) );
for( layer = 0; layer < __drawing->header->layers; ++layer )
	{
	new_file_position = __drawing->file_position + __drawing->header->layer_size;
	__drawing->layer[ layer ] = AcadLayer__create();
	AcadLayer__read( __drawing->layer[ layer ] );
	if ( debugger ) AcadLayer__dump_to_debug_file( __drawing->layer[ layer ] );
	file_seek( new_file_position );
	}
}


PRIVATE void read_font_styles( void )

{
int font_style;
INT32 new_file_position;

if ( !__drawing->header->styles ) return;
file_seek( __drawing->header->font_styles_start );	
__drawing->font_style = ( AcadFontStyle ** )get_memory( __drawing->header->styles*sizeof( AcadFontStyle ) );
for( font_style = 0; font_style < __drawing->header->styles; ++font_style )
	{
	new_file_position = __drawing->file_position + __drawing->header->font_styles_size;
	__drawing->font_style[ font_style ] = AcadFontStyle__create();
	AcadFontStyle__read( __drawing->font_style[ font_style ] );
	if ( debugger ) AcadFontStyle__dump_to_debug_file( __drawing->font_style[ font_style ] );
	file_seek( new_file_position );
	}
}


PRIVATE void read_views( void )

{
int view;
INT32 new_file_position;

if ( !__drawing->header->views ) return;
file_seek( __drawing->header->views_start );	
__drawing->view = ( AcadView ** )get_memory( __drawing->header->views*sizeof( AcadView ) );
for( view = 0; view < __drawing->header->views; ++view )
	{
	new_file_position = __drawing->file_position + __drawing->header->view_size;
	__drawing->view[ view ] = AcadView__create();
	AcadView__read( __drawing->view[ view ] );
	if ( debugger ) AcadView__dump_to_debug_file( __drawing->view[ view ] );
	file_seek( new_file_position );
	}
}


PRIVATE void read_ucss( void )

{
int ucs;
INT32 new_file_position;

if ( !__drawing->header->ucss ) return;
file_seek( __drawing->header->ucss_start );	
__drawing->ucs = ( AcadUcs ** )get_memory( __drawing->header->ucss*sizeof( AcadUcs ) );
for( ucs = 0; ucs < __drawing->header->ucss; ++ucs )
	{
	new_file_position = __drawing->file_position + __drawing->header->ucss_size;
	__drawing->ucs[ ucs ] = AcadUcs__create();
	AcadUcs__read( __drawing->ucs[ ucs ] );
	if ( debugger ) AcadUcs__dump_to_debug_file( __drawing->ucs[ ucs ] );
	file_seek( new_file_position );
	}
}


PRIVATE void read_appids( void )

{
int appid;
INT32 new_file_position;

if ( !__drawing->header->applications ) return;
file_seek( __drawing->header->applications_start );	
__drawing->appid = ( AcadAppID ** )get_memory( __drawing->header->applications*sizeof( AcadAppID ) );
for( appid = 0; appid < __drawing->header->applications; ++appid )
	{
	new_file_position = __drawing->file_position + __drawing->header->applications_size;
	__drawing->appid[ appid ] = AcadAppID__create();
	AcadAppID__read( __drawing->appid[ appid ] );
	if ( debugger ) AcadAppID__dump_to_debug_file( __drawing->appid[ appid ] );
	file_seek( new_file_position );
	}
}


PRIVATE void read_dim_styles( void )

{
int dim_style;
INT32 new_file_position;

if ( !__drawing->header->dimstyles ) return;
file_seek( __drawing->header->dimstyles_start );	
__drawing->dim_style = ( AcadDimStyle ** )get_memory( __drawing->header->dimstyles*sizeof( AcadDimStyle ) );
for( dim_style = 0; dim_style < __drawing->header->dimstyles; ++dim_style )
	{
	new_file_position = __drawing->file_position + __drawing->header->dimstyles_size;
	__drawing->dim_style[ dim_style ] = AcadDimStyle__create();
	AcadDimStyle__read( __drawing->dim_style[ dim_style ] );
	if ( debugger ) AcadDimStyle__dump_to_debug_file( __drawing->dim_style[ dim_style ] );
	file_seek( new_file_position );
	}
}


PRIVATE void add_entity( AcadEntity *entity, UINT8 type )

{
if ( entities )
	{
	last_entity->next = entity;
	last_entity = last_entity->next;
	}
else