Forwarding to mailing list.
-----Forwarded Message-----
From: Angus Ainslie <[EMAIL PROTECTED]>
To: [EMAIL PROTECTED]
Subject: Dia DXF import
Date: 13 Aug 2002 15:41:31 -0600
Hi,
I made some changes to the dia dxf import to better understand what's
exported from
visio 2002. It gives nearly the same import a bringing the dxf file into
autocad but
is still far from finished. I thought I'd contribute it anyhow.
Cheers
Angus
----
/* -*- Mode: C; c-basic-offset: 4 -*- */
/* Dia -- an diagram creation/manipulation program
* Copyright (C) 1998 Alexander Larsson
*
* dxf-import.c: dxf import filter for dia
* Copyright (C) 2000 Steffen Macke
*
* This program is free software; you can redistribute it and/or modify
* it 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.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include <stdio.h>
#include <string.h>
#include <math.h>
#include <glib.h>
#include <stdlib.h>
#include <locale.h>
#include "intl.h"
#include "message.h"
#include "geometry.h"
#include "render.h"
#include "filter.h"
#include "object.h"
#include "properties.h"
#include "propinternals.h"
#include "autocad_pal.h"
#include "../app/group.h"
#include "../objects/standard/create.h"
static real coord_scale = 1.0, measure_scale = 1.0;
static real text_scale = 1.0;
#define WIDTH_SCALE measure_scale
#define DEFAULT_LINE_WIDTH 0.001
Point extent_min, extent_max;
Point limit_min, limit_max;
/* maximum line length */
#define DXF_LINE_LENGTH 256
typedef struct layer_data_tag
{
char layerName[256];
int acad_colour;
} layer_data_type;
typedef struct _DxfData
{
char code[DXF_LINE_LENGTH];
char value[DXF_LINE_LENGTH];
} DxfData;
gboolean import_dxf(const gchar *filename, DiagramData *dia, void* user_data);
gboolean read_dxf_codes(FILE *filedxf, DxfData *data);
Object *read_entity_line_dxf(FILE *filedxf, DxfData *data, DiagramData *dia);
Object *read_entity_circle_dxf(FILE *filedxf, DxfData *data, DiagramData *dia);
Object *read_entity_ellipse_dxf(FILE *filedxf, DxfData *data, DiagramData *dia);
Object *read_entity_arc_dxf(FILE *filedxf, DxfData *data, DiagramData *dia);
Object *read_entity_solid_dxf(FILE *filedxf, DxfData *data, DiagramData *dia);
Object *read_entity_polyline_dxf(FILE *filedxf, DxfData *data, DiagramData *dia);
void read_entity_scale_dxf(FILE *filedxf, DxfData *data, DiagramData *dia);
void read_entity_textsize_dxf(FILE *filedxf, DxfData *data, DiagramData *dia);
void read_entity_mesurement_dxf(FILE *filedxf, DxfData *data, DiagramData *dia);
void read_table_layer_dxf(FILE *filedxf, DxfData *data, DiagramData *dia);
void read_section_header_dxf(FILE *filedxf, DxfData *data, DiagramData *dia);
void read_section_classes_dxf(FILE *filedxf, DxfData *data, DiagramData *dia);
void read_section_tables_dxf(FILE *filedxf, DxfData *data, DiagramData *dia);
void read_section_entities_dxf(FILE *filedxf, DxfData *data, DiagramData *dia);
void read_section_blocks_dxf(FILE *filedxf, DxfData *data, DiagramData *dia);
Layer *layer_find_by_name(char *layername, DiagramData *dia);
LineStyle get_dia_linestyle_dxf(char *dxflinestyle);
/* returns the layer with the given name */
/* TODO: merge this with other layer code? */
Layer *layer_find_by_name(char *layername, DiagramData *dia)
{
Layer *matching_layer, *layer;
int i;
// matching_layer = dia->active_layer;
matching_layer = NULL;
for (i=0; i<dia->layers->len; i++) {
layer = (Layer *)g_ptr_array_index(dia->layers, i);
if(strcmp(layer->name, layername) == 0) {
matching_layer = layer;
break;
}
}
if( matching_layer == NULL )
{
matching_layer = new_layer(g_strdup( layername ));
data_add_layer(dia, matching_layer);
}
return matching_layer;
}
/* returns the matching dia linestyle for a given dxf linestyle */
/* if no matching style is found, LINESTYLE solid is returned as a default */
LineStyle get_dia_linestyle_dxf(char *dxflinestyle) {
if(strcmp(dxflinestyle, "DASH") == 0) {
return LINESTYLE_DASHED;
}
if(strcmp(dxflinestyle, "DASHDOT") == 0){
return LINESTYLE_DASH_DOT;
}
if(strcmp(dxflinestyle, "DOT") == 0){
return LINESTYLE_DOTTED;
}
return LINESTYLE_SOLID;
}
static PropDescription dxf_prop_descs[] = {
{ "start_point", PROP_TYPE_POINT },
{ "end_point", PROP_TYPE_POINT },
{ "line_colour", PROP_TYPE_COLOUR },
{ "line_width", PROP_TYPE_REAL },
{ "line_style", PROP_TYPE_LINESTYLE},
PROP_DESC_END};
/* reads a line entity from the dxf file and creates a line object in dia*/
Object *read_entity_line_dxf(FILE *filedxf, DxfData *data, DiagramData *dia){
int codedxf;
char *old_locale;
/* line data */
Point start, end;
ObjectType *otype = object_get_type("Standard - Line");
Handle *h1, *h2;
Object *line_obj;
Color line_colour = { 0.0, 0.0, 0.0 };
// Color line_colour = { 1.0, 1.0, 1.0 };
GPtrArray *props;
PointProperty *ptprop;
LinestyleProperty *lsprop;
ColorProperty *cprop;
RealProperty *rprop;
real line_width = DEFAULT_LINE_WIDTH;
LineStyle style = LINESTYLE_SOLID;
Layer *layer = NULL;
old_locale = setlocale(LC_NUMERIC, "C");
do {
if(read_dxf_codes(filedxf, data) == FALSE){
setlocale(LC_NUMERIC, old_locale);
return( NULL );
}
codedxf = atoi(data->code);
switch(codedxf){
case 6: style = get_dia_linestyle_dxf(data->value);
break;
case 8: layer = layer_find_by_name(data->value, dia);
break;
case 10:
start.x = atof(data->value) * coord_scale * measure_scale;
break;
case 11:
end.x = atof(data->value) * coord_scale * measure_scale;
break;
case 20:
start.y = (-1)*atof(data->value) * coord_scale * measure_scale;
break;
case 21:
end.y = (-1)*atof(data->value) * coord_scale * measure_scale;
break;
case 39:
line_width = atof(data->value) * WIDTH_SCALE;
printf( "line width %f\n", line_width );
break;
}
} while(codedxf != 0);
setlocale(LC_NUMERIC, old_locale);
line_obj = otype->ops->create(&start, otype->default_user_data,
&h1, &h2);
layer_add_object(layer, line_obj);
props = prop_list_from_descs(dxf_prop_descs,pdtpp_true);
g_assert(props->len == 5);
ptprop = g_ptr_array_index(props,0);
ptprop->point_data = start;
ptprop = g_ptr_array_index(props,1);
ptprop->point_data = end;
cprop = g_ptr_array_index(props,2);
cprop->color_data = line_colour;
rprop = g_ptr_array_index(props,3);
rprop->real_data = line_width;
lsprop = g_ptr_array_index(props,4);
lsprop->style = style;
lsprop->dash = 1.0;
line_obj->ops->set_props(line_obj, props);
prop_list_free(props);
return( line_obj );
}
static PropDescription dxf_solid_prop_descs[] = {
{ "line_colour", PROP_TYPE_COLOUR },
{ "line_width", PROP_TYPE_REAL },
{ "line_style", PROP_TYPE_LINESTYLE },
{ "fill_colour", PROP_TYPE_COLOUR },
{ "show_background", PROP_TYPE_BOOL },
PROP_DESC_END};
/* reads a solid entity from the dxf file and creates a polygon object in dia*/
Object *read_entity_solid_dxf(FILE *filedxf, DxfData *data, DiagramData *dia)
{
int codedxf;
char *old_locale;
/* polygon data */
Point p[4];
ObjectType *otype = object_get_type("Standard - Polygon");
Handle *h1, *h2;
Object *polygon_obj;
PolygonCreateData *pcd;
// Color line_colour = { 1.0, 1.0, 1.0 };
Color fill_colour = { 0.5, 0.5, 0.5 };
GPtrArray *props;
LinestyleProperty *lsprop;
ColorProperty *cprop, *fprop;
RealProperty *rprop;
BoolProperty *bprop;
real line_width = 0.001;
LineStyle style = LINESTYLE_SOLID;
Layer *layer = NULL;
unsigned char colour;
// printf( "Solid " );
old_locale = setlocale(LC_NUMERIC, "C");
do {
if(read_dxf_codes(filedxf, data) == FALSE){
setlocale(LC_NUMERIC, old_locale);
return( NULL );
}
codedxf = atoi(data->code);
switch(codedxf){
case 6:
style = get_dia_linestyle_dxf(data->value);
break;
case 8:
layer = layer_find_by_name(data->value, dia);
// printf( "layer: %s ", data->value );
break;
case 10:
p[0].x = atof(data->value) * coord_scale * measure_scale;
// printf( "P0.x: %f ", p[0].x );
break;
case 11:
p[1].x = atof(data->value) * coord_scale * measure_scale;
// printf( "P1.x: %f ", p[1].x );
break;
case 12:
p[2].x = atof(data->value) * coord_scale * measure_scale;
// printf( "P2.x: %f ", p[2].x );
break;
case 13:
p[3].x = atof(data->value) * coord_scale * measure_scale;
// printf( "P3.x: %f ", p[3].x );
break;
case 20:
p[0].y = (-1)*atof(data->value) * coord_scale * measure_scale;
// printf( "P0.y: %f ", p[0].y );
break;
case 21:
p[1].y = (-1)*atof(data->value) * coord_scale * measure_scale;
// printf( "P1.y: %f ", p[1].y );
break;
case 22:
p[2].y = (-1)*atof(data->value) * coord_scale * measure_scale;
// printf( "P2.y: %f ", p[2].y );
break;
case 23:
p[3].y = (-1)*atof(data->value) * coord_scale * measure_scale;
// printf( "P3.y: %f\n", p[3].y );
break;
case 39:
line_width = atof(data->value) * WIDTH_SCALE;
// printf( "width %f\n", line_width );
break;
case 62:
colour = atoi(data->value);
fill_colour.red = acad_pal[colour].r / 255.0;
fill_colour.green = acad_pal[colour].g / 255.0;
fill_colour.blue = acad_pal[colour].b / 255.0;
printf( "acad colour %d %d %d\n", acad_pal[colour].r, acad_pal[colour].g,
acad_pal[colour].b );
printf( "fill colour %f %f %f\n", fill_colour.red, fill_colour.green,
fill_colour.blue );
break;
}
} while(codedxf != 0);
setlocale(LC_NUMERIC, old_locale);
pcd = g_new( PolygonCreateData, 1);
if( p[2].x != p[3].x && p[2].y != p[3].y )
pcd->num_points = 4;
else
pcd->num_points = 3;
pcd->points = g_new( Point, pcd->num_points );
memcpy( pcd->points, p, sizeof( Point ) * pcd->num_points );
//pcd->points = points;
polygon_obj = otype->ops->create( NULL, pcd, &h1, &h2 );
layer_add_object( layer, polygon_obj );
props = prop_list_from_descs( dxf_solid_prop_descs, pdtpp_true );
g_assert(props->len == 5);
cprop = g_ptr_array_index( props,0 );
cprop->color_data = fill_colour;
rprop = g_ptr_array_index( props,1 );
rprop->real_data = line_width;
lsprop = g_ptr_array_index( props,2 );
lsprop->style = style;
lsprop->dash = 1.0;
fprop = g_ptr_array_index( props, 3 );
fprop->color_data = fill_colour;
bprop = g_ptr_array_index( props, 4 );
bprop->bool_data = TRUE;
polygon_obj->ops->set_props( polygon_obj, props );
prop_list_free(props);
return( polygon_obj );
}
static PropDescription dxf_polyline_prop_descs[] = {
{ "line_colour", PROP_TYPE_COLOUR },
{ "line_width", PROP_TYPE_REAL },
{ "line_style", PROP_TYPE_LINESTYLE },
PROP_DESC_END};
int IsEqual( double a, double b )
{
double epsilon = 0.001;
if( a == b )
return( 1 );
if(( a + epsilon ) > b && ( a - epsilon ) < b )
return( 1 );
return( 0 );
}
/* reads a polyline entity from the dxf file and creates a polyline object in dia*/
Object *read_entity_polyline_dxf(FILE *filedxf, DxfData *data, DiagramData *dia)
{
int codedxf, i;
char *old_locale;
/* polygon data */
Point *p = NULL, start, end, center;
ObjectType *otype = object_get_type("Standard - PolyLine");
Handle *h1, *h2;
Object *polyline_obj;
PolylineCreateData *pcd;
Color line_colour = { 0.0, 0.0, 0.0 };
GPtrArray *props;
LinestyleProperty *lsprop;
ColorProperty *cprop; //, *fprop;
RealProperty *rprop;
// BoolProperty *bprop;
real line_width = DEFAULT_LINE_WIDTH;
real radius, start_angle;
LineStyle style = LINESTYLE_SOLID;
Layer *layer = NULL;
unsigned char colour, closed = 0;
int points = 0; //, i;
// printf( "PolyLine " );
old_locale = setlocale(LC_NUMERIC, "C");
do {
if(read_dxf_codes(filedxf, data) == FALSE){
setlocale(LC_NUMERIC, old_locale);
return( NULL );
}
codedxf = atoi(data->code);
switch(codedxf){
case 0:
if( !strcmp( data->value, "VERTEX" ))
{
points++;
p = realloc( p, sizeof( Point ) * points );
printf( "Vertex %d\n", points );
}
case 6:
style = get_dia_linestyle_dxf(data->value);
break;
case 8:
layer = layer_find_by_name(data->value, dia);
// printf( "layer: %s ", data->value );
break;
case 10:
if( points != 0 )
{
p[points-1].x = atof(data->value) * coord_scale * measure_scale;
// printf( "P[%d].x: %f ", points-1, p[points-1].x );
}
break;
case 20:
if( points != 0 )
{
p[points-1].y = (-1)*atof(data->value) * coord_scale * measure_scale;
// printf( "P[%d].y: %f\n", points-1, p[points-1].y );
}
break;
case 39:
// line_width = atof(data->value) * WIDTH_SCALE;
line_width = atof(data->value) * WIDTH_SCALE;
printf( "width %f\n", line_width );
break;
case 42:
p = realloc( p, sizeof( Point ) * ( points + 10 ));
// memcpy( start, p[points-2], sizeof( Point ));
// memcpy( end, p[points-1], sizeof( Point ));
start = p[points-2];
end = p[points-1];
radius = sqrt( pow( end.x - start.x, 2 ) + pow( end.y - start.y, 2 ))/2;
center.x = start.x + ( end.x - start.x )/2;
center.y = start.y + ( end.y - start.y )/2;
if( IsEqual( start.x, end.x ))
{
if( IsEqual( start.y, end.y ))
{
fprintf( stderr, "Bad vertex bulge\n" );
}
else if( start.y > center.y )
{
// start_angle = 90.0;
start_angle = M_PI/2;
}
else
{
// start_angle = 270.0;
start_angle = M_PI * 1.5;
}
}
else if( IsEqual( start.y, end.y ))
{
if( IsEqual( start.x, end.x ))
{
fprintf( stderr, "Bad vertex bulge\n" );
}
else if( start.x > center.x )
{
start_angle = 0.0;
}
else
{
// start_angle = 180.0;
start_angle = M_PI;
}
}
else
{
start_angle = atan( center.y - start.y /center.x - start.x );
}
printf( "start x %f end x %f center x %f\n", start.x, end.x, center.x );
printf( "start y %f end y %f center y %f\n", start.y, end.y, center.y );
printf( "bulge %s %f startx_angle %f\n", data->value, radius, start_angle );
for( i=(points-1); i<(points+9); i++ );
{
p[i].x = center.x + cos( start_angle ) * radius;
p[i].y = center.y + sin( start_angle ) * radius;
start_angle += M_PI/10.0;
printf( "i %d x %f y %f\n", i, p[i].x, p[i].y );
}
points += 10;
p[points-1] = end;
break;
case 62:
colour = atoi(data->value);
line_colour.red = acad_pal[colour].r / 255.0;
line_colour.green = acad_pal[colour].g / 255.0;
line_colour.blue = acad_pal[colour].b / 255.0;
break;
case 70:
closed = 1 & atoi( data->value );
// printf( "closed %d %s", closed, data->value );
break;
}
} while( strcmp( data->value, "SEQEND" ));
// } while( codedxf != 0 && strcmp( data->value, "SEQEND" ));
setlocale(LC_NUMERIC, old_locale);
if( points == 0 )
{
printf( "No vertexes defined\n" );
return( NULL );
}
pcd = g_new( PolylineCreateData, 1);
if( closed )
{
++points;
p = realloc( p, sizeof( Point ) * points );
p[points-1].x = p[0].x;
p[points-1].y = p[0].y;
}
pcd->num_points = points;
// pcd->points = p;
pcd->points = g_new( Point, pcd->num_points );
memcpy( pcd->points, p, sizeof( Point ) * pcd->num_points );
free( p );
//pcd->points = points;
polyline_obj = otype->ops->create( NULL, pcd, &h1, &h2 );
layer_add_object( layer, polyline_obj );
props = prop_list_from_descs( dxf_polyline_prop_descs, pdtpp_true );
g_assert( props->len == 3 );
cprop = g_ptr_array_index( props,0 );
cprop->color_data = line_colour;
rprop = g_ptr_array_index( props,1 );
rprop->real_data = line_width;
lsprop = g_ptr_array_index( props,2 );
lsprop->style = style;
lsprop->dash = 1.0;
polyline_obj->ops->set_props( polyline_obj, props );
prop_list_free(props);
return( polyline_obj );
}
static PropDescription dxf_ellipse_prop_descs[] = {
{ "elem_corner", PROP_TYPE_POINT },
{ "elem_width", PROP_TYPE_REAL },
{ "elem_height", PROP_TYPE_REAL },
{ "line_colour", PROP_TYPE_COLOUR },
{ "line_width", PROP_TYPE_REAL },
{ "show_background", PROP_TYPE_BOOL},
PROP_DESC_END};
/* reads a circle entity from the dxf file and creates a circle object in dia*/
Object *read_entity_circle_dxf(FILE *filedxf, DxfData *data, DiagramData *dia)
{
int codedxf;
char *old_locale;
/* circle data */
Point center;
real radius = 1.0;
ObjectType *otype = object_get_type("Standard - Ellipse");
Handle *h1, *h2;
Object *ellipse_obj;
Color line_colour = { 0.0, 0.0, 0.0 };
PointProperty *ptprop;
RealProperty *rprop;
BoolProperty *bprop;
ColorProperty *cprop;
GPtrArray *props;
real line_width = DEFAULT_LINE_WIDTH;
Layer *layer = NULL;
old_locale = setlocale(LC_NUMERIC, "C");
do {
if(read_dxf_codes(filedxf, data) == FALSE){
setlocale(LC_NUMERIC, old_locale);
return( NULL );
}
codedxf = atoi(data->code);
switch(codedxf){
case 8:
layer = layer_find_by_name(data->value, dia);
break;
case 10:
center.x = atof(data->value) * coord_scale * measure_scale;
break;
case 20:
center.y = (-1)*atof(data->value) * coord_scale * measure_scale;
break;
case 39:
line_width = atof(data->value) * WIDTH_SCALE;
break;
case 40:
radius = atof(data->value) * coord_scale * measure_scale;
break;
}
} while(codedxf != 0);
setlocale(LC_NUMERIC, old_locale);
center.x -= radius;
center.y -= radius;
ellipse_obj = otype->ops->create(¢er, otype->default_user_data,
&h1, &h2);
layer_add_object(layer, ellipse_obj);
props = prop_list_from_descs(dxf_ellipse_prop_descs,pdtpp_true);
g_assert(props->len == 6);
ptprop = g_ptr_array_index(props,0);
ptprop->point_data = center;
rprop = g_ptr_array_index(props,1);
rprop->real_data = radius * 2.0;
rprop = g_ptr_array_index(props,2);
rprop->real_data = radius * 2.0;
cprop = g_ptr_array_index(props,3);
cprop->color_data = line_colour;
rprop = g_ptr_array_index(props,4);
rprop->real_data = line_width;
bprop = g_ptr_array_index(props,5);
bprop->bool_data = FALSE;
ellipse_obj->ops->set_props(ellipse_obj, props);
prop_list_free(props);
return( ellipse_obj );
}
static PropDescription dxf_arc_prop_descs[] = {
{ "start_point", PROP_TYPE_POINT },
{ "end_point", PROP_TYPE_POINT },
{ "curve_distance", PROP_TYPE_REAL },
{ "line_colour", PROP_TYPE_COLOUR },
{ "line_width", PROP_TYPE_REAL },
PROP_DESC_END};
/* reads a circle entity from the dxf file and creates a circle object in dia*/
Object *read_entity_arc_dxf(FILE *filedxf, DxfData *data, DiagramData *dia)
{
int codedxf;
char *old_locale;
/* arc data */
Point start,center,end;
real radius = 1.0, start_angle = 0.0, end_angle=360.0;
real curve_distance;
ObjectType *otype = object_get_type("Standard - Arc");
Handle *h1, *h2;
Object *arc_obj;
Color line_colour = { 0.0, 0.0, 0.0 };
ColorProperty *cprop;
PointProperty *ptprop;
RealProperty *rprop;
GPtrArray *props;
real line_width = DEFAULT_LINE_WIDTH;
Layer *layer = NULL;
old_locale = setlocale(LC_NUMERIC, "C");
do {
if(read_dxf_codes(filedxf, data) == FALSE){
setlocale(LC_NUMERIC,old_locale);
return( NULL );
}
codedxf = atoi(data->code);
switch(codedxf){
case 8:
layer = layer_find_by_name(data->value, dia);
break;
case 10:
center.x = atof(data->value) * coord_scale * measure_scale;
break;
case 20:
center.y = (-1)*atof(data->value) * coord_scale * measure_scale;
break;
case 39:
line_width = atof(data->value) * WIDTH_SCALE;
break;
case 40:
radius = atof(data->value) * coord_scale * measure_scale;
break;
case 50:
start_angle = atof(data->value)*M_PI/180.0;
break;
case 51:
end_angle = atof(data->value)*M_PI/180.0;
break;
}
} while(codedxf != 0);
setlocale(LC_NUMERIC, old_locale);
/* printf("c.x=%f c.y=%f s",center.x,center.y); */
start.x = center.x + cos(start_angle) * radius;
start.y = center.y - sin(start_angle) * radius;
end.x = center.x + cos(end_angle) * radius;
end.y = center.y - sin(end_angle) * radius;
/*printf("s.x=%f s.y=%f e.x=%f e.y=%f\n",start.x,start.y,end.x,end.y);*/
if (end_angle < start_angle) end_angle += 2.0*M_PI;
curve_distance = radius * (1 - cos ((end_angle - start_angle)/2));
/*printf("start_angle: %f end_angle: %f radius:%f curve_distance:%f\n",
start_angle,end_angle,radius,curve_distance);*/
arc_obj = otype->ops->create(¢er, otype->default_user_data,
&h1, &h2);
layer_add_object(layer, arc_obj);
props = prop_list_from_descs(dxf_arc_prop_descs,pdtpp_true);
g_assert(props->len == 5);
ptprop = g_ptr_array_index(props,0);
ptprop->point_data = start;
ptprop = g_ptr_array_index(props,1);
ptprop->point_data = end;
rprop = g_ptr_array_index(props,2);
rprop->real_data = curve_distance;
cprop = g_ptr_array_index(props,3);
cprop->color_data = line_colour;
rprop = g_ptr_array_index(props,4);
rprop->real_data = line_width;
arc_obj->ops->set_props(arc_obj, props);
prop_list_free(props);
return( arc_obj );
}
/* reads an ellipse entity from the dxf file and creates an ellipse object in dia*/
Object *read_entity_ellipse_dxf(FILE *filedxf, DxfData *data, DiagramData *dia){
int codedxf;
char *old_locale;
/* ellipse data */
Point center;
real width = 1.0;
real ratio_width_height = 1.0;
ObjectType *otype = object_get_type("Standard - Ellipse");
Handle *h1, *h2;
Object *ellipse_obj;
Color line_colour = { 0.0, 0.0, 0.0 };
PointProperty *ptprop;
RealProperty *rprop;
BoolProperty *bprop;
ColorProperty *cprop;
GPtrArray *props;
real line_width = DEFAULT_LINE_WIDTH;
Layer *layer = NULL;
old_locale = setlocale(LC_NUMERIC, "C");
do {
if(read_dxf_codes(filedxf, data) == FALSE){
setlocale(LC_NUMERIC, old_locale);
return( NULL );
}
codedxf = atoi(data->code);
switch(codedxf){
case 8:
layer = layer_find_by_name(data->value, dia);
break;
case 10:
center.x = atof(data->value) * coord_scale * measure_scale;
break;
case 11:
ratio_width_height = atof(data->value) * coord_scale * measure_scale;
break;
case 20:
center.y = (-1)*atof(data->value) * coord_scale * measure_scale;
break;
case 39:
line_width = atof(data->value) * WIDTH_SCALE;
break;
case 40:
width = atof(data->value) * 2; /* XXX what scale */
break;
}
} while(codedxf != 0);
setlocale(LC_NUMERIC, old_locale);
center.x -= width;
center.y -= (width*ratio_width_height);
ellipse_obj = otype->ops->create(¢er, otype->default_user_data,
&h1, &h2);
layer_add_object(layer, ellipse_obj);
props = prop_list_from_descs(dxf_ellipse_prop_descs,pdtpp_true);
g_assert(props->len == 6);
ptprop = g_ptr_array_index(props,0);
ptprop->point_data = center;
rprop = g_ptr_array_index(props,1);
rprop->real_data = width;
rprop = g_ptr_array_index(props,2);
rprop->real_data = width * ratio_width_height;
cprop = g_ptr_array_index(props,3);
cprop->color_data = line_colour;
rprop = g_ptr_array_index(props,4);
rprop->real_data = line_width;
bprop = g_ptr_array_index(props,5);
bprop->bool_data = FALSE;
ellipse_obj->ops->set_props(ellipse_obj, props);
prop_list_free(props);
return( ellipse_obj );
}
static PropDescription dxf_text_prop_descs[] = {
{ "text", PROP_TYPE_TEXT },
PROP_DESC_END};
Object *read_entity_text_dxf(FILE *filedxf, DxfData *data, DiagramData *dia)
{
int codedxf, colour;
char *old_locale;
/* text data */
Point location;
// real height = 10.0;
real height = text_scale * coord_scale * measure_scale;
// real height = text_scale;
real y_offset = 0;
Alignment textalignment = ALIGN_LEFT;
char *textvalue = NULL, *textp;
ObjectType *otype = object_get_type("Standard - Text");
Handle *h1, *h2;
Object *text_obj;
Color text_colour = { 0.0, 0.0, 0.0 };
TextProperty *tprop;
GPtrArray *props;
Layer *layer = NULL;
old_locale = setlocale(LC_NUMERIC, "C");
do {
if (read_dxf_codes(filedxf, data) == FALSE) {
setlocale(LC_NUMERIC,old_locale);
return( NULL );
}
codedxf = atoi(data->code);
switch (codedxf) {
case 1:
textvalue = g_strdup(data->value);
textp = textvalue;
// FIXME - poor tab to space converter
do
{
if( textp[0] == '^' && textp[1] == 'I' )
{
textp[0] = ' ';
textp[1] = ' ';
textp++;
}
}
while( *(++textp) != '\0' );
printf( "Found text: %s\n", textvalue );
break;
case 8: layer = layer_find_by_name(data->value, dia);
break;
case 10:
location.x = atof(data->value) * coord_scale * measure_scale;
// location.x = atof(data->value) / text_scale;
printf( "Found text location x: %f\n", location.x );
break;
case 11:
location.x = atof(data->value) * coord_scale * measure_scale;
// location.x = atof(data->value) / text_scale;
printf( "Found text location x: %f\n", location.x );
break;
case 20:
location.y = (-1)*atof(data->value) * coord_scale * measure_scale;
// location.y = (-1)*atof(data->value) / text_scale;
printf( "Found text location y: %f\n", location.y );
break;
case 21:
location.y = (-1)*atof(data->value) * coord_scale * measure_scale;
// location.y = (-1)*atof(data->value) / text_scale;
printf( "Found text location y: %f\n", location.y );
break;
case 40:
height = atof(data->value) * coord_scale * measure_scale;
// height = atof(data->value) / text_scale;
// if( height <= 1.0 )
// height = 1.0;
printf( "text height %f\n", height );
break;
case 62:
colour = atoi(data->value);
text_colour.red = acad_pal[colour].r / 255.0;
text_colour.green = acad_pal[colour].g / 255.0;
text_colour.blue = acad_pal[colour].b / 255.0;
break;
case 72:
switch(atoi(data->value))
{
case 0:
textalignment = ALIGN_LEFT;
break;
case 1:
textalignment = ALIGN_CENTER;
break;
case 2:
textalignment = ALIGN_RIGHT;
break;
case 3:
// FIXME - it's not clear what these are
break;
case 4:
// FIXME - it's not clear what these are
break;
case 5:
// FIXME - it's not clear what these are
break;
}
break;
case 73:
switch(atoi(data->value))
{
case 0:
case 1:
// FIXME - not really the same vertical alignment
// 0 = baseline
// 1 = bottom
y_offset = 0;
break;
case 2:
// 2 = middle
y_offset = 0.5;
break;
case 3:
// 3 = top
y_offset = 1;
break;
}
break;
}
} while(codedxf != 0);
setlocale(LC_NUMERIC,old_locale);
location.y += y_offset * height;
text_obj = otype->ops->create(&location, otype->default_user_data,
&h1, &h2);
layer_add_object(layer, text_obj);
props = prop_list_from_descs(dxf_text_prop_descs,pdtpp_true);
g_assert(props->len == 1);
tprop = g_ptr_array_index(props,0);
g_free(tprop->text_data);
tprop->text_data = textvalue;
tprop->attr.alignment = textalignment;
tprop->attr.position.x = location.x;
tprop->attr.position.y = location.y;
tprop->attr.font = font_getfont(_("Courier"));
// tprop->attr.font = font_getfont(_("Fixed"));
tprop->attr.height = height;
tprop->attr.color = text_colour;
text_obj->ops->set_props(text_obj, props);
prop_list_free(props);
return( text_obj );
}
/* reads the layer table from the dxf file and creates the layers */
void read_table_layer_dxf(FILE *filedxf, DxfData *data, DiagramData *dia){
int codedxf;
// Layer *layer;
do {
if(read_dxf_codes(filedxf, data) == FALSE){
return;
}
else {
codedxf = atoi(data->code);
if(codedxf == 2){
// layer = new_layer(g_strdup(data->value));
// data_add_layer(dia, layer);
layer_find_by_name( data->value, dia );
}
}
} while ((codedxf != 0) || (strcmp(data->value, "ENDTAB") != 0));
}
/* reads a scale entity from the dxf file */
void read_entity_scale_dxf(FILE *filedxf, DxfData *data, DiagramData *dia)
{
int codedxf;
if(read_dxf_codes(filedxf, data) == FALSE)
return;
codedxf = atoi(data->code);
switch(codedxf)
{
case 40:
coord_scale = atof(data->value);
printf( "Scale: %f\n", coord_scale );
break;
default:
break;
}
}
/* reads a scale entity from the dxf file */
void read_entity_measurement_dxf(FILE *filedxf, DxfData *data, DiagramData *dia)
{
int codedxf;
if(read_dxf_codes(filedxf, data) == FALSE)
return;
codedxf = atoi(data->code);
switch(codedxf)
{
case 70:
// value 0 = English, 1 = Metric
if( atoi( data->value ) == 0 )
measure_scale = 2.54;
else
measure_scale = 1.0;
printf( "Measure Scale: %f\n", measure_scale );
break;
default:
break;
}
}
/* reads a textsize entity from the dxf file */
void read_entity_textsize_dxf(FILE *filedxf, DxfData *data, DiagramData *dia){
int codedxf;
if(read_dxf_codes(filedxf, data) == FALSE)
return;
codedxf = atoi(data->code);
switch(codedxf)
{
case 40:
text_scale = atof(data->value);
printf( "Text Size: %f\n", text_scale );
break;
default:
break;
}
}
/* reads the headers section of the dxf file */
void read_section_header_dxf(FILE *filedxf, DxfData *data, DiagramData *dia) {
int codedxf;
if(read_dxf_codes(filedxf, data) == FALSE){
return;
}
do {
codedxf = atoi(data->code);
if((codedxf == 9) && (strcmp(data->value, "$DIMSCALE") == 0)) {
read_entity_scale_dxf(filedxf, data, dia);
} else if((codedxf == 9) && (strcmp(data->value, "$TEXTSIZE") == 0)) {
read_entity_textsize_dxf(filedxf, data, dia);
} else if((codedxf == 9) && (strcmp(data->value, "$MEASUREMENT") == 0)) {
read_entity_measurement_dxf(filedxf, data, dia);
} else {
if(read_dxf_codes(filedxf, data) == FALSE){
return;
}
}
} while ((codedxf != 0) || (strcmp(data->value, "ENDSEC") != 0));
}
/* reads the classes section of the dxf file */
void read_section_classes_dxf(FILE *filedxf, DxfData *data, DiagramData *dia) {
int codedxf;
if(read_dxf_codes(filedxf, data) == FALSE){
return;
}
do {
codedxf = atoi(data->code);
if((codedxf == 9) && (strcmp(data->value, "$LTSCALE") == 0)) {
read_entity_scale_dxf(filedxf, data, dia);
} else if((codedxf == 9) && (strcmp(data->value, "$TEXTSIZE") == 0)) {
read_entity_textsize_dxf(filedxf, data, dia);
} else {
if(read_dxf_codes(filedxf, data) == FALSE){
return;
}
}
} while ((codedxf != 0) || (strcmp(data->value, "ENDSEC") != 0));
}
/* reads the tables section of the dxf file */
void read_section_tables_dxf(FILE *filedxf, DxfData *data, DiagramData *dia) {
int codedxf;
if(read_dxf_codes(filedxf, data) == FALSE){
return;
}
do {
codedxf = atoi(data->code);
if((codedxf == 0) && (strcmp(data->value, "LAYER") == 0)) {
read_table_layer_dxf(filedxf, data, dia);
}
else {
if(read_dxf_codes(filedxf, data) == FALSE){
return;
}
}
} while ((codedxf != 0) || (strcmp(data->value, "ENDSEC") != 0));
}
/* reads the entities section of the dxf file */
void read_section_entities_dxf(FILE *filedxf, DxfData *data, DiagramData *dia) {
int codedxf;
if (read_dxf_codes(filedxf, data) == FALSE){
return;
}
codedxf = atoi(data->code);
do {
if((codedxf == 0) && (strcmp(data->value, "LINE") == 0)) {
read_entity_line_dxf(filedxf, data, dia);
} else if((codedxf == 0) && (strcmp(data->value, "VERTEX") == 0)) {
read_entity_line_dxf(filedxf, data, dia);
} else if((codedxf == 0) && (strcmp(data->value, "SOLID") == 0)) {
read_entity_solid_dxf(filedxf, data, dia);
} else if((codedxf == 0) && (strcmp(data->value, "POLYLINE") == 0)) {
read_entity_polyline_dxf(filedxf, data, dia);
} else if((codedxf == 0) && (strcmp(data->value, "CIRCLE") == 0)) {
read_entity_circle_dxf(filedxf, data, dia);
} else if((codedxf == 0) && (strcmp(data->value, "ELLIPSE") == 0)) {
read_entity_ellipse_dxf(filedxf, data, dia);
} else if((codedxf == 0) && (strcmp(data->value, "TEXT") == 0)) {
read_entity_text_dxf(filedxf, data, dia);
} else if((codedxf == 0) && (strcmp(data->value, "ARC") == 0)) {
read_entity_arc_dxf(filedxf,data,dia);
} else {
/* if (codedxf == 0) {
g_warning("unknown DXF entity: %s",data->value);
}*/
if(read_dxf_codes(filedxf, data) == FALSE) {
return;
}
}
codedxf = atoi(data->code);
} while((codedxf != 0) || (strcmp(data->value, "ENDSEC") != 0));
}
//static GSList *compound_stack = NULL;
//static GList *;
/* reads the blocks section of the dxf file */
void read_section_blocks_dxf(FILE *filedxf, DxfData *data, DiagramData *dia)
{
int codedxf, group_items = 0, group;
GList *group_list;
Object *obj = NULL;
Layer *group_layer = NULL;
if (read_dxf_codes(filedxf, data) == FALSE){
return;
}
codedxf = atoi(data->code);
do {
if((codedxf == 0) && (strcmp(data->value, "LINE") == 0)) {
read_entity_line_dxf(filedxf, data, dia);
} else if((codedxf == 0) && (strcmp(data->value, "SOLID") == 0)) {
obj = read_entity_solid_dxf(filedxf, data, dia);
} else if((codedxf == 0) && (strcmp(data->value, "VERTEX") == 0)) {
read_entity_line_dxf(filedxf, data, dia);
} else if((codedxf == 0) && (strcmp(data->value, "POLYLINE") == 0)) {
obj = read_entity_polyline_dxf(filedxf, data, dia);
} else if((codedxf == 0) && (strcmp(data->value, "CIRCLE") == 0)) {
read_entity_circle_dxf(filedxf, data, dia);
} else if((codedxf == 0) && (strcmp(data->value, "ELLIPSE") == 0)) {
read_entity_ellipse_dxf(filedxf, data, dia);
} else if((codedxf == 0) && (strcmp(data->value, "TEXT") == 0)) {
obj = read_entity_text_dxf(filedxf, data, dia);
} else if((codedxf == 0) && (strcmp(data->value, "ARC") == 0)) {
read_entity_arc_dxf(filedxf,data,dia);
} else if((codedxf == 0) && (strcmp(data->value, "BLOCK") == 0)) {
printf( "Begin group\n" );
group = TRUE;
group_items = 0;
group_list = NULL;
group_layer = NULL;
do {
if(read_dxf_codes(filedxf, data) == FALSE)
return;
codedxf = atoi(data->code);
if( codedxf == 8 )
group_layer = layer_find_by_name( data->value, dia );
} while( codedxf != 0 );
} else if((codedxf == 0) && (strcmp(data->value, "ENDBLK") == 0)) {
printf( "End group %d\n", group_items );
if( group && group_items > 0 && group_list != NULL )
{
obj = group_create( group_list );
if( NULL == group_layer )
layer_add_object( dia->active_layer, obj );
else
layer_add_object( group_layer, obj );
}
group = FALSE;
group_items = 0;
group_list = NULL;
obj = NULL;
if(read_dxf_codes(filedxf, data) == FALSE)
return;
} else {
/* if (codedxf == 0) {
g_warning("unknown DXF entity: %s",data->value);
}*/
if(read_dxf_codes(filedxf, data) == FALSE) {
return;
}
}
if( group && obj != NULL )
{
group_items++;
// group_list = g_list_append( group_list, obj );
group_list = g_list_prepend( group_list, obj );
obj = NULL;
}
codedxf = atoi(data->code);
} while((codedxf != 0) || (strcmp(data->value, "ENDSEC") != 0));
}
/* imports the given dxf-file, returns TRUE if successful */
gboolean import_dxf(const gchar *filename, DiagramData *dia, void* user_data){
FILE *filedxf;
DxfData *data;
int codedxf;
filedxf = fopen(filename,"r");
if(filedxf == NULL){
message_error(_("Couldn't open: '%s' for reading.\n"), filename);
return FALSE;
}
data = g_new(DxfData, 1);
do {
if(read_dxf_codes(filedxf, data) == FALSE) {
g_free(data);
printf( "read_dxf_codes failed\n" );
return FALSE;
}
else {
codedxf = atoi(data->code);
if(codedxf == 2) {
if(strcmp(data->value, "ENTITIES") == 0) {
printf( "reading section entities\n" );
read_section_entities_dxf(filedxf, data, dia);
}
else if(strcmp(data->value, "BLOCKS") == 0) {
printf( "reading section BLOCKS\n" );
read_section_blocks_dxf(filedxf, data, dia);
}
else if(strcmp(data->value, "CLASSES") == 0) {
printf( "reading section CLASSES\n" );
read_section_classes_dxf(filedxf, data, dia);
}
else if(strcmp(data->value, "HEADER") == 0) {
printf( "reading section HEADER\n" );
read_section_header_dxf(filedxf, data, dia);
}
else if(strcmp(data->value, "TABLES") == 0) {
printf( "reading section tables\n" );
read_section_tables_dxf(filedxf, data, dia);
}
else if(strcmp(data->value, "OBJECTS") == 0) {
printf( "reading section objects\n" );
read_section_entities_dxf(filedxf, data, dia);
}
}
else
printf( "Unknown dxf code %d\n", codedxf );
}
}while((codedxf != 0) || (strcmp(data->value, "EOF") != 0));
g_free(data);
return TRUE;
}
/* reads a code/value pair from the DXF file */
gboolean read_dxf_codes(FILE *filedxf, DxfData *data){
int i;
char *c;
if(fgets(data->code, DXF_LINE_LENGTH, filedxf) == NULL){
return FALSE;
}
if(fgets(data->value, DXF_LINE_LENGTH, filedxf) == NULL){
return FALSE;
}
c=data->value;
for(i=0; i < DXF_LINE_LENGTH; i++){
if((c[i] == '\n')||(c[i] == '\r')){
c[i] = 0;
break;
}
}
return TRUE;
}
/* interface from filter.h */
static const gchar *extensions[] = {"dxf", NULL };
DiaImportFilter dxf_import_filter = {
N_("Drawing Interchange File"),
extensions,
import_dxf
};
----
typedef struct
{
unsigned char r, g, b;
} RGB_t;
static RGB_t acad_pal[256] =
{
{ 0x00, 0x00, 0x00 }, //0
{ 0xFF, 0x00, 0x00 },
{ 0xFF, 0xFF, 0x00 },
{ 0x00, 0xFF, 0x00 },
{ 0x00, 0xFF, 0xFF },
{ 0x00, 0x00, 0xFF }, //5
{ 0xFF, 0x00, 0xFF },
{ 0xFF, 0xFF, 0xFF },
{ 0x41, 0x41, 0x41 },
{ 0x80, 0x80, 0x80 },
{ 0xFF, 0x00, 0x00 }, //10
{ 0xFF, 0xAA, 0xAA },
{ 0xBD, 0x00, 0x00 },
{ 0xBD, 0x7E, 0x7E },
{ 0x81, 0x00, 0x00 },
{ 0x81, 0x56, 0x56 }, //15
{ 0x68, 0x00, 0x00 },
{ 0x68, 0x45, 0x45 },
{ 0x4F, 0x00, 0x00 },
{ 0x4F, 0x35, 0x35 },
{ 0xFF, 0x3F, 0x00 }, //20
{ 0xFF, 0xBF, 0xAA },
{ 0xBD, 0x2E, 0x00 },
{ 0xBD, 0x8D, 0x7E },
{ 0x81, 0x1F, 0x00 },
{ 0x81, 0x60, 0x56 }, //25
{ 0x68, 0x19, 0x00 },
{ 0x68, 0x4E, 0x45 },
{ 0x4F, 0x13, 0x00 },
{ 0x4F, 0x3B, 0x35 },
{ 0xFF, 0x7F, 0x00 }, //30
{ 0xFF, 0xD4, 0xAA },
{ 0xBD, 0x5E, 0x00 },
{ 0xBD, 0x9D, 0x7E },
{ 0x81, 0x40, 0x00 },
{ 0x81, 0x6B, 0x56 }, //35
{ 0x68, 0x34, 0x00 },
{ 0x68, 0x56, 0x45 },
{ 0x4F, 0x27, 0x00 },
{ 0x4F, 0x42, 0x35 },
{ 0xFF, 0xBF, 0x00 }, //40
{ 0xFF, 0xEA, 0xAA },
{ 0xBD, 0x8D, 0x00 },
{ 0xBD, 0xAD, 0x7E },
{ 0x81, 0x60, 0x00 },
{ 0x81, 0x76, 0x56 }, //45
{ 0x68, 0x4E, 0x00 },
{ 0x68, 0x5F, 0x45 },
{ 0x4F, 0x3B, 0x00 },
{ 0x4F, 0x49, 0x35 },
{ 0xFF, 0xFF, 0x00 }, //50
{ 0xFF, 0xFF, 0xAA },
{ 0xBD, 0xBD, 0x00 },
{ 0xBD, 0xBD, 0x7E },
{ 0x81, 0x81, 0x00 },
{ 0x81, 0x81, 0x56 }, //55
{ 0x68, 0x68, 0x00 },
{ 0x68, 0x68, 0x45 },
{ 0x4F, 0x4F, 0x00 },
{ 0x4F, 0x4F, 0x35 },
{ 0xBF, 0xFF, 0x00 }, //60
{ 0xEA, 0xFF, 0xAA },
{ 0x8D, 0xBD, 0x00 },
{ 0xAD, 0xBD, 0x7E },
{ 0x60, 0x81, 0x00 },
{ 0x76, 0x81, 0x56 }, //65
{ 0x4E, 0x68, 0x00 },
{ 0x5F, 0x68, 0x45 },
{ 0x3B, 0x4F, 0x00 },
{ 0x49, 0x4F, 0x35 },
{ 0x7F, 0xFF, 0x00 }, //70
{ 0xD4, 0xFF, 0xAA },
{ 0x5E, 0xBD, 0x00 },
{ 0x9D, 0xBD, 0x7E },
{ 0x40, 0x81, 0x00 },
{ 0x6B, 0x81, 0x56 }, //75
{ 0x34, 0x68, 0x00 },
{ 0x56, 0x68, 0x45 },
{ 0x27, 0x4F, 0x00 },
{ 0x42, 0x4F, 0x35 },
{ 0x3F, 0xFF, 0x00 }, //80
{ 0xBF, 0xFF, 0xAA },
{ 0x2E, 0xBD, 0x00 },
{ 0x8D, 0xBD, 0x7E },
{ 0x1F, 0x81, 0x00 },
{ 0x60, 0x81, 0x56 }, //85
{ 0x19, 0x68, 0x00 },
{ 0x4E, 0x68, 0x45 },
{ 0x13, 0x4F, 0x00 },
{ 0x3B, 0x4F, 0x35 },
{ 0x00, 0xFF, 0x00 }, //90
{ 0xAA, 0xFF, 0xAA },
{ 0x00, 0xBD, 0x00 },
{ 0x7E, 0xBD, 0x7E },
{ 0x00, 0x81, 0x00 },
{ 0x56, 0x81, 0x56 }, //95
{ 0x00, 0x68, 0x00 },
{ 0x45, 0x68, 0x45 },
{ 0x00, 0x4F, 0x00 },
{ 0x35, 0x4F, 0x35 },
{ 0x00, 0xFF, 0x3F }, //100
{ 0xAA, 0xFF, 0xBF },
{ 0x00, 0xBD, 0x2E },
{ 0x7E, 0xBD, 0x8D },
{ 0x00, 0x81, 0x1F },
{ 0x56, 0x81, 0x60 }, //105
{ 0x00, 0x68, 0x19 },
{ 0x45, 0x68, 0x4E },
{ 0x00, 0x4F, 0x13 },
{ 0x35, 0x4F, 0x3B },
{ 0x00, 0xFF, 0x7F }, //110
{ 0xAA, 0xFF, 0xD4 },
{ 0x00, 0xBD, 0x5E },
{ 0x7E, 0xBD, 0x9D },
{ 0x00, 0x81, 0x40 },
{ 0x56, 0x81, 0x6B }, //115
{ 0x00, 0x68, 0x34 },
{ 0x45, 0x68, 0x56 },
{ 0x00, 0x4F, 0x27 },
{ 0x35, 0x4F, 0x42 },
{ 0x00, 0xFF, 0xBF }, //120
{ 0xAA, 0xFF, 0xEA },
{ 0x00, 0xBD, 0x8D },
{ 0x7E, 0xBD, 0xAD },
{ 0x00, 0x81, 0x60 },
{ 0x56, 0x81, 0x76 }, //125
{ 0x00, 0x68, 0x4E },
{ 0x45, 0x68, 0x5F },
{ 0x00, 0x4F, 0x3B },
{ 0x35, 0x4F, 0x49 },
{ 0x00, 0xFF, 0xFF }, //130
{ 0xAA, 0xFF, 0xFF },
{ 0x00, 0xBD, 0xBD },
{ 0x7E, 0xBD, 0xBD },
{ 0x00, 0x81, 0x81 },
{ 0x56, 0x81, 0x81 }, //135
{ 0x00, 0x68, 0x68 },
{ 0x45, 0x68, 0x68 },
{ 0x00, 0x4F, 0x4F },
{ 0x35, 0x4F, 0x4F },
{ 0x00, 0xBF, 0xFF }, //140
{ 0xAA, 0xEA, 0xFF },
{ 0x00, 0x8D, 0xBD },
{ 0x7E, 0xAD, 0xBD },
{ 0x00, 0x60, 0x81 },
{ 0x56, 0x76, 0x81 }, //145
{ 0x00, 0x4E, 0x68 },
{ 0x45, 0x5F, 0x68 },
{ 0x00, 0x3B, 0x4F },
{ 0x35, 0x49, 0x4F },
{ 0x00, 0x7F, 0xFF }, //150
{ 0xAA, 0xD4, 0xFF },
{ 0x00, 0x5E, 0xBD },
{ 0x7E, 0x9D, 0xBD },
{ 0x00, 0x40, 0x81 },
{ 0x56, 0x6B, 0x81 }, //155
{ 0x00, 0x34, 0x68 },
{ 0x45, 0x56, 0x68 },
{ 0x00, 0x27, 0x4F },
{ 0x35, 0x42, 0x4F },
{ 0x00, 0x3F, 0xFF }, //160
{ 0xAA, 0xBF, 0xFF },
{ 0x00, 0x2E, 0xBD },
{ 0x7E, 0x8D, 0xBD },
{ 0x00, 0x1F, 0x81 },
{ 0x56, 0x60, 0x81 }, //165
{ 0x00, 0x19, 0x68 },
{ 0x45, 0x4E, 0x68 },
{ 0x00, 0x13, 0x4F },
{ 0x35, 0x3B, 0x4F },
{ 0x00, 0x00, 0xFF }, //170
{ 0xAA, 0xAA, 0xFF },
{ 0x00, 0x00, 0xBD },
{ 0x7E, 0x7E, 0xBD },
{ 0x00, 0x00, 0x81 },
{ 0x56, 0x56, 0x81 }, //175
{ 0x00, 0x00, 0x68 },
{ 0x45, 0x45, 0x68 },
{ 0x00, 0x00, 0x4F },
{ 0x35, 0x35, 0x4F },
{ 0x3F, 0x00, 0xFF }, //180
{ 0xBF, 0xAA, 0xFF },
{ 0x2E, 0x00, 0xBD },
{ 0x8D, 0x7E, 0xBD },
{ 0x1F, 0x00, 0x81 },
{ 0x60, 0x56, 0x81 }, //185
{ 0x19, 0x00, 0x68 },
{ 0x4E, 0x45, 0x68 },
{ 0x13, 0x00, 0x4F },
{ 0x3B, 0x35, 0x4F },
{ 0x7F, 0x00, 0xFF }, //190
{ 0xD4, 0xAA, 0xFF },
{ 0x5E, 0x00, 0xBD },
{ 0x9D, 0x7E, 0xBD },
{ 0x40, 0x00, 0x81 },
{ 0x6B, 0x56, 0x81 }, //195
{ 0x34, 0x00, 0x68 },
{ 0x56, 0x45, 0x68 },
{ 0x27, 0x00, 0x4F },
{ 0x42, 0x35, 0x4F },
{ 0xBF, 0x00, 0xFF }, //200
{ 0xEA, 0xAA, 0xFF },
{ 0x8D, 0x00, 0xBD },
{ 0xAD, 0x7E, 0xBD },
{ 0x60, 0x00, 0x81 },
{ 0x76, 0x56, 0x81 }, //205
{ 0x4E, 0x00, 0x68 },
{ 0x5F, 0x45, 0x68 },
{ 0x3B, 0x00, 0x4F },
{ 0x49, 0x35, 0x4F },
{ 0xFF, 0x00, 0xFF }, //210
{ 0xFF, 0xAA, 0xFF },
{ 0xBD, 0x00, 0xBD },
{ 0xBD, 0x7E, 0xBD },
{ 0x81, 0x00, 0x81 },
{ 0x81, 0x56, 0x81 }, //215
{ 0x68, 0x00, 0x68 },
{ 0x68, 0x45, 0x68 },
{ 0x4F, 0x00, 0x4F },
{ 0x4F, 0x35, 0x4F },
{ 0xFF, 0x00, 0xBF }, //220
{ 0xFF, 0xAA, 0xEA },
{ 0xBD, 0x00, 0x8D },
{ 0xBD, 0x7E, 0xAD },
{ 0x81, 0x00, 0x60 },
{ 0x81, 0x56, 0x76 }, //225
{ 0x68, 0x00, 0x4E },
{ 0x68, 0x45, 0x5F },
{ 0x4F, 0x00, 0x3B },
{ 0x4F, 0x35, 0x49 },
{ 0xFF, 0x00, 0x7F }, //230
{ 0xFF, 0xAA, 0xD4 },
{ 0xBD, 0x00, 0x5E },
{ 0xBD, 0x7E, 0x9D },
{ 0x81, 0x00, 0x40 },
{ 0x81, 0x56, 0x6B }, //235
{ 0x68, 0x00, 0x34 },
{ 0x68, 0x45, 0x56 },
{ 0x4F, 0x00, 0x27 },
{ 0x4F, 0x35, 0x42 },
{ 0xFF, 0x00, 0x3F }, //240
{ 0xFF, 0xAA, 0xBF },
{ 0xBD, 0x00, 0x2E },
{ 0xBD, 0x7E, 0x8D },
{ 0x81, 0x00, 0x1F },
{ 0x81, 0x56, 0x60 }, //245
{ 0x68, 0x00, 0x19 },
{ 0x68, 0x45, 0x4E },
{ 0x4F, 0x00, 0x13 },
{ 0x4F, 0x35, 0x3B },
{ 0x33, 0x33, 0x33 }, //250
{ 0x50, 0x50, 0x50 },
{ 0x69, 0x69, 0x69 },
{ 0x82, 0x82, 0x82 },
{ 0xBE, 0xBE, 0xBE },
{ 0xFF, 0xFF, 0xFF } //255
};
_______________________________________________
Dia-list mailing list
[EMAIL PROTECTED]
http://mail.gnome.org/mailman/listinfo/dia-list
