DiaObject *
create_standard_bezierline(int num_points,
BezPoint *points,
Arrow *end_arrow,
Arrow *start_arrow) {
DiaObjectType *otype = object_get_type("Standard - BezierLine");
DiaObject *new_obj;
Handle *h1, *h2;
BezierCreateData bcd;
GPtrArray *props;
if (otype == NULL){
message_error(_("Can't find standard object"));
return NULL;
}
bcd.num_points = num_points;
bcd.points = points;
new_obj = otype->ops->create(NULL, &bcd, &h1, &h2);
props = prop_list_from_descs(create_line_prop_descs,pdtpp_true);
g_assert(props->len == 2);
if (start_arrow != NULL)
((ArrowProperty *)g_ptr_array_index(props, 0))->arrow_data = *start_arrow;
if (end_arrow != NULL)
((ArrowProperty *)g_ptr_array_index(props, 1))->arrow_data = *end_arrow;
new_obj->ops->set_props(new_obj, props);
prop_list_free(props);
return new_obj;
}
/*!
* \brief Modify the objects string property
* @param object the object to modify
* @param name the name of the string property (NULL for any)
* @param value the value to set, NULL to delete
* @return object change on sucess, NULL if not found
*
* Usually you should not pass NULL for the name, the facility
* was added for convenience of the unit test.
*
* \memberof _DiaObject
* \ingroup StdProps
*/
ObjectChange *
dia_object_set_string (DiaObject *object,
const char *name,
const char *value)
{
ObjectChange *change;
GPtrArray *props = NULL;
Property *prop = object_prop_by_name_type (object, name, PROP_TYPE_STRING);
if (!prop)
prop = object_prop_by_name_type (object, name, PROP_TYPE_FILE);
if (prop) {
StringProperty *pp = (StringProperty *)prop;
g_free (pp->string_data);
pp->string_data = g_strdup (value);
props = prop_list_from_single (prop);
} else if ((prop = object_prop_by_name_type (object, name, PROP_TYPE_TEXT)) != NULL) {
TextProperty *pp = (TextProperty *)prop;
g_free (pp->text_data);
pp->text_data = g_strdup (value);
props = prop_list_from_single (prop);
}
if (!props)
return NULL;
change = object_apply_props (object, props);
prop_list_free (props);
return change;
}
DiaObject *
create_standard_ellipse(real xpos, real ypos, real width, real height) {
DiaObjectType *otype = object_get_type("Standard - Ellipse");
DiaObject *new_obj;
Handle *h1, *h2;
GPtrArray *props;
Point point;
if (otype == NULL){
message_error(_("Can't find standard object"));
return NULL;
}
point.x = xpos;
point.y = ypos;
new_obj = otype->ops->create(&point, otype->default_user_data,
&h1, &h2);
props = make_element_props(xpos,ypos,width,height);
new_obj->ops->set_props(new_obj, props);
prop_list_free(props);
return new_obj;
}
/* Match and replace property values. */
static gboolean
_replace (DiaObject *obj, const SearchData *sd, const char *replacement)
{
ObjectChange *obj_change;
GPtrArray *plist = NULL;
plist = _match_props (obj, sd, replacement);
if (!plist)
return FALSE;
/* Refresh screen and free the list of modified properties. */
obj_change = object_apply_props (obj, plist);
prop_list_free (plist);
if (obj_change)
undo_object_change(sd->diagram, obj, obj_change);
object_add_updates(obj, sd->diagram);
diagram_update_connections_object(sd->diagram, obj, TRUE);
diagram_modified(sd->diagram);
diagram_object_modified(sd->diagram, obj);
diagram_update_extents(sd->diagram);
diagram_flush(sd->diagram);
return TRUE;
}
/*! Match and possibly modify all the given object's properties. */
static GPtrArray *
_match_all_props (DiaObject *obj, const SearchData *sd, const gchar *replacement)
{
GPtrArray *all_plist = NULL;
GPtrArray *matched_plist = NULL;
const PropDescription *desc;
guint pnum;
if (!obj)
return NULL;
desc = object_get_prop_descriptions (obj);
if (!desc)
return NULL;
all_plist = prop_list_from_descs (desc, pdtpp_true);
if (!all_plist)
return NULL;
/* Step though all object properties.
* Along the way, construct a list of matching properties (or
* replaced properties). */
for (pnum = 0; pnum < all_plist->len; ++pnum) {
Property *prop = g_ptr_array_index (all_plist, pnum);
gboolean is_match = FALSE;
const gchar *prop_name;
if (!prop || !prop->name)
continue;
/* This extra step seems to be necessary to populate the property data. */
prop_name = prop->name;
prop->ops->free (prop);
prop = object_prop_by_name (obj, prop_name);
is_match = _match_prop (obj, sd, replacement, prop);
if (!is_match) {
prop->ops->free (prop);
continue;
}
/* We have a match. */
if (!matched_plist) {
/* First time. */
matched_plist = prop_list_from_single (prop);
} else {
/* FIXME: do we realy want a replace all here? */
/* Subsequent finds. */
GPtrArray *append_plist;
append_plist = prop_list_from_single (prop);
prop_list_add_list (matched_plist, append_plist);
prop_list_free (append_plist);
}
} /* Continue stepping through all object properties. */
return matched_plist;
}
void
prop_dialog_destroy(PropDialog *dialog)
{
if (dialog->props) prop_list_free(dialog->props);
g_array_free(dialog->prop_widgets,TRUE);
g_ptr_array_free(dialog->containers,TRUE);
if (dialog->copies) destroy_object_list(dialog->copies);
g_free(dialog);
}
static void
fig_simple_properties(DiaObject *obj,
int line_style,
float dash_length,
int thickness,
int pen_color,
int fill_color,
int area_fill,
DiaContext *ctx)
{
GPtrArray *props = prop_list_from_descs(xfig_simple_prop_descs_line,
pdtpp_true);
RealProperty *rprop;
ColorProperty *cprop;
g_assert(props->len == 2);
rprop = g_ptr_array_index(props,0);
rprop->real_data = thickness/FIG_ALT_UNIT;
cprop = g_ptr_array_index(props,1);
cprop->color_data = fig_color(pen_color, ctx);
if (line_style != -1) {
LinestyleProperty *lsprop =
(LinestyleProperty *)make_new_prop("line_style",
PROP_TYPE_LINESTYLE,
PROP_FLAG_DONT_SAVE);
lsprop->dash = dash_length/FIG_ALT_UNIT;
lsprop->style = fig_line_style_to_dia(line_style, ctx);
g_ptr_array_add(props,lsprop);
}
if (area_fill == -1) {
BoolProperty *bprop =
(BoolProperty *)make_new_prop("show_background",
PROP_TYPE_BOOL,PROP_FLAG_DONT_SAVE);
bprop->bool_data = FALSE;
g_ptr_array_add(props,bprop);
} else {
ColorProperty *cprop =
(ColorProperty *)make_new_prop("fill_colour",
PROP_TYPE_COLOUR,
PROP_FLAG_DONT_SAVE);
cprop->color_data = fig_area_fill_color(area_fill, fill_color, ctx);
g_ptr_array_add(props,cprop);
}
obj->ops->set_props(obj, props);
prop_list_free(props);
}
DiaObject *
create_standard_image(real xpos, real ypos, real width, real height,
char *file) {
DiaObjectType *otype = object_get_type("Standard - Image");
DiaObject *new_obj;
Handle *h1, *h2;
Point point;
GPtrArray *props;
StringProperty *sprop;
if (otype == NULL){
message_error(_("Can't find standard object"));
return NULL;
}
point.x = xpos;
point.y = ypos;
new_obj = otype->ops->create(&point, otype->default_user_data,
&h1, &h2);
props = make_element_props(xpos,ypos,width,height);
new_obj->ops->set_props(new_obj, props);
prop_list_free(props);
props = prop_list_from_descs(create_file_prop_descs,pdtpp_true);
g_assert(props->len == 1);
sprop = g_ptr_array_index(props,0);
g_free(sprop->string_data);
sprop->string_data = g_strdup(file);
new_obj->ops->set_props(new_obj, props);
prop_list_free(props);
return new_obj;
}
void
object_save_props(DiaObject *obj, ObjectNode obj_node, DiaContext *ctx)
{
GPtrArray *props;
g_return_if_fail(obj != NULL);
g_return_if_fail(obj_node != NULL);
g_return_if_fail(object_complies_with_stdprop(obj));
props = prop_list_from_descs(object_get_prop_descriptions(obj),
pdtpp_do_save);
obj->ops->get_props(obj, props);
prop_list_save(props,obj_node,ctx);
prop_list_free(props);
}
/* Only match (find), do not replace any values. */
static gboolean
_matches (DiaObject *obj, const SearchData *sd)
{
GPtrArray *plist = NULL;
if (!obj)
return FALSE;
plist = _match_props (obj, sd, NULL);
if (!plist)
return FALSE;
prop_list_free (plist);
return TRUE;
}
static gboolean
import_data (const gchar *filename, DiagramData *data, DiaContext *ctx, void* user_data)
{
DiaObjectType *otype = object_get_type("Standard - Image");
gint width, height;
if (!otype) /* this would be really broken */
return FALSE;
if (!user_data) {
dia_context_add_message(ctx, _("Calling error, missing user_data."));
return FALSE;
}
if (gdk_pixbuf_get_file_info (filename, &width, &height))
{
DiaObject *obj;
Handle *h1, *h2;
Point point;
point.x = point.y = 0.0;
obj = otype->ops->create(&point, otype->default_user_data, &h1, &h2);
if (obj)
{
GPtrArray *plist = g_ptr_array_new ();
prop_list_add_filename (plist, "image_file", filename);
prop_list_add_real (plist, "elem_width", width / 20.0);
prop_list_add_real (plist, "elem_height", height / 20.0);
obj->ops->set_props(obj, plist);
prop_list_free (plist);
layer_add_object(data->active_layer, obj);
return TRUE;
}
}
else
{
dia_context_add_message(ctx, _("Pixbuf[%s] can't load:\n%s"),
(gchar*)user_data, dia_context_get_filename(ctx));
}
return FALSE;
}
static void
object_prop_change_apply_revert(ObjectPropChange *change, DiaObject *obj)
{
GPtrArray *old_props;
old_props = prop_list_copy_empty(change->saved_props);
if (change->obj->ops->get_props)
change->obj->ops->get_props(change->obj, old_props);
/* set saved property values */
if (change->obj->ops->set_props)
change->obj->ops->set_props(change->obj, change->saved_props);
/* move old props to saved properties */
prop_list_free(change->saved_props);
change->saved_props = old_props;
}
void
object_load_props(DiaObject *obj, ObjectNode obj_node, DiaContext *ctx)
{
GPtrArray *props;
g_return_if_fail(obj != NULL);
g_return_if_fail(obj_node != NULL);
g_return_if_fail(object_complies_with_stdprop(obj));
props = prop_list_from_descs(object_get_prop_descriptions(obj),
pdtpp_do_load);
if (!prop_list_load(props,obj_node, ctx)) {
/* context already has the message */
}
obj->ops->set_props(obj, props);
prop_list_free(props);
}
int web_props(void)
{
if (!session_id())
return BBS_ELGNREQ;
prop_list_t *p = prop_list_load();
if (!p)
return BBS_EINTNL;
xml_header(NULL);
printf("<bbsprop>");
print_session();
for (int i = 0; i < prop_list_num_rows(p); ++i) {
show_prop(p, i);
}
printf("</bbsprop>");
prop_list_free(p);
return 0;
}
/*!
* \brief Apply the current style properties to the given object
*/
void
DiaOutputDev::applyStyle (DiaObject *obj, bool fill)
{
GPtrArray *plist = g_ptr_array_new ();
if (!fill) {
prop_list_add_line_width (plist, this->line_width);
prop_list_add_line_style (plist, this->line_style, this->dash_length);
prop_list_add_line_colour (plist, &this->stroke_color);
} else {
prop_list_add_line_width (plist, 0);
prop_list_add_line_colour (plist, &this->fill_color);
prop_list_add_fill_colour (plist, &this->fill_color);
}
prop_list_add_show_background (plist, fill ? TRUE : FALSE);
// using the "Standard - Path" internal enum values here is a bit dirty
prop_list_add_enum (plist, "stroke_or_fill", fill ? 0x2 : 0x1);
obj->ops->set_props (obj, plist);
prop_list_free (plist);
}
/**
* dia_object_default_create:
* @param type The objects type
* @param startpoint The left upper corner
* @param user_data
* @param handle1
* @param handle2
* @return A newly created object.
*
* Create an object respecting defaults if available
*/
DiaObject *
dia_object_default_create (const DiaObjectType *type,
Point *startpoint,
void *user_data,
Handle **handle1,
Handle **handle2)
{
const DiaObject *def_obj;
DiaObject *obj;
g_return_val_if_fail (type != NULL, NULL);
/* don't use dia_object_default_get() as it would insert the object into the hashtable (store defaults without being asked for it) */
def_obj = g_hash_table_lookup (defaults_hash, type->name);
if (def_obj && def_obj->ops->describe_props)
{
/* copy properties to new object, but keep position */
// factory_debug_to_log(g_strdup_printf(factory_utf8("拖入对像def_obj,名字:%s.\n"),type->name));
obj = type->ops->create (startpoint, user_data, handle1, handle2);
if (obj)
{
GPtrArray *props = prop_list_from_descs (
object_get_prop_descriptions(def_obj), pdtpp_standard_or_defaults);
// factory_debug_to_log(factory_utf8("拖入对像def_obj->ops->get_props(def_obj, props)\n"));
def_obj->ops->get_props(def_obj, props);
// factory_debug_to_log(factory_utf8("拖入对像obj->ops->set_props(obj, props)\n"));
obj->ops->set_props(obj, props);
obj->ops->move (obj, startpoint);
prop_list_free(props);
}
}
else
{
// factory_debug_to_log(g_strdup_printf(factory_utf8("拖入对像def_obj==NULL,名字:%s.\n"),type->name));
obj = type->ops->create (startpoint, user_data, handle1, handle2);
}
return obj;
}
/*!
* \brief Modification of the objects 'pixbuf' property
*
* @param object object to modify
* @param pixbuf the pixbuf to set
* @return an object change or NULL
*
* If the object does not have a pixbuf property nothing
* happens. If there is a pixbuf property and the passed
* in pixbuf is identical an empty change is returned.
*
* \memberof _DiaObject
* \ingroup StdProps
*/
ObjectChange *
dia_object_set_pixbuf (DiaObject *object,
GdkPixbuf *pixbuf)
{
ObjectChange *change;
GPtrArray *props;
PixbufProperty *pp;
Property *prop = object_prop_by_name_type (object, "pixbuf", PROP_TYPE_PIXBUF);
if (!prop)
return NULL;
pp = (PixbufProperty *)prop;
if (pp->pixbuf == pixbuf)
return change_list_create ();
if (pp->pixbuf)
g_object_unref (pp->pixbuf);
pp->pixbuf = g_object_ref (pixbuf);
props = prop_list_from_single (prop);
change = object_apply_props (object, props);
prop_list_free (props);
return change;
}
DiaObject *
create_standard_arc(real x1, real y1, real x2, real y2,
real distance,
Arrow *end_arrow,
Arrow *start_arrow) {
DiaObjectType *otype = object_get_type("Standard - Arc");
DiaObject *new_obj;
Handle *h1, *h2;
Point p1, p2;
GPtrArray *props;
if (otype == NULL){
message_error(_("Can't find standard object"));
return NULL;
}
p1.x = x1;
p1.y = y1;
p2.x = x2;
p2.y = y2;
new_obj = otype->ops->create(&p1, otype->default_user_data,
&h1, &h2);
new_obj->ops->move_handle(new_obj, h2, &p2, NULL, HANDLE_MOVE_USER_FINAL,0);
props = prop_list_from_descs(create_arc_prop_descs,pdtpp_true);
g_assert(props->len == 3);
((RealProperty *)g_ptr_array_index(props,0))->real_data = distance;
if (start_arrow != NULL)
((ArrowProperty *)g_ptr_array_index(props, 1))->arrow_data = *start_arrow;
if (end_arrow != NULL)
((ArrowProperty *)g_ptr_array_index(props, 2))->arrow_data = *end_arrow;
new_obj->ops->set_props(new_obj, props);
prop_list_free(props);
return new_obj;
}
/*!
* \brief Modification of the objects 'pattern' property
*
* @param object object to modify
* @param pattern the pattern to set
* @return an object change or NULL
*
* If the object does not have a pattern property nothing
* happens. If there is a pattern property and the passed
* in pattern is identical an empty change is returned.
*
* \memberof _DiaObject
* \ingroup StdProps
*/
ObjectChange *
dia_object_set_pattern (DiaObject *object,
DiaPattern *pattern)
{
ObjectChange *change;
GPtrArray *props;
PatternProperty *pp;
Property *prop = object_prop_by_name_type (object, "pattern", PROP_TYPE_PATTERN);
if (!prop)
return NULL;
pp = (PatternProperty *)prop;
if (pp->pattern == pattern)
return change_list_create ();
if (pp->pattern)
g_object_unref (pp->pattern);
pp->pattern = g_object_ref (pattern);
props = prop_list_from_single (prop);
change = object_apply_props (object, props);
prop_list_free (props);
return change;
}
void
object_copy_props(DiaObject *dest, const DiaObject *src, gboolean is_default)
{
GPtrArray *props;
g_return_if_fail(src != NULL);
g_return_if_fail(dest != NULL);
g_return_if_fail(strcmp(src->type->name,dest->type->name)==0);
g_return_if_fail(src->ops == dest->ops);
g_return_if_fail(object_complies_with_stdprop(src));
g_return_if_fail(object_complies_with_stdprop(dest));
props = prop_list_from_descs(object_get_prop_descriptions(src),
(is_default?pdtpp_do_save_no_standard_default:
pdtpp_do_save));
src->ops->get_props((DiaObject *)src, props); /* FIXME: really should make
get_props' first argument
a (const DiaObject *) */
dest->ops->set_props(dest, props);
prop_list_free(props);
}
/* reads a polyline entity from the dxf file and creates a polyline object in dia*/
static DiaObject *
read_entity_polyline_dxf(FILE *filedxf, DxfData *data, DiagramData *dia)
{
int i;
/* polygon data */
Point *p = NULL, start, end, center;
DiaObjectType *otype = object_get_type("Standard - PolyLine");
Handle *h1, *h2;
DiaObject *polyline_obj;
MultipointCreateData *pcd;
Color line_colour;
GPtrArray *props;
real line_width = DEFAULT_LINE_WIDTH;
real radius, start_angle = 0;
LineStyle style = LINESTYLE_SOLID;
Layer *layer = dia->active_layer;
RGB_t color = { 0, };
unsigned char closed = 0;
int points = 0;
real bulge = 0.0;
int bulge_end = -1;
gboolean bulge_x_avail = FALSE, bulge_y_avail = FALSE;
do {
if(read_dxf_codes(filedxf, data) == FALSE){
return( NULL );
}
switch(data->code){
case 0:
if( !strcmp( data->value, "VERTEX" ))
{
points++;
p = g_realloc( p, sizeof( Point ) * points );
/*printf( "Vertex %d\n", points );*/
}
break;
case 6:
style = get_dia_linestyle_dxf(data->value);
break;
case 8:
layer = layer_find_by_name(data->value, dia);
color = pal_get_rgb (_dxf_color_get_by_layer (layer));
/*printf( "layer: %s ", data->value );*/
break;
case 10:
if( points != 0 )
{
p[points-1].x = g_ascii_strtod(data->value, NULL) * coord_scale * measure_scale;
/*printf( "P[%d].x: %f ", points-1, p[points-1].x );*/
bulge_x_avail = (bulge_end == points);
}
break;
case 20:
if( points != 0 )
{
p[points-1].y = (-1)*g_ascii_strtod(data->value, NULL) * coord_scale * measure_scale;
/*printf( "P[%d].y: %f\n", points-1, p[points-1].y );*/
bulge_y_avail = (bulge_end == points);
}
break;
case 39:
line_width = g_ascii_strtod(data->value, NULL) * WIDTH_SCALE;
/*printf( "width %f\n", line_width );*/
break;
case 40: /* default starting width */
case 41: /* default ending width */
line_width = g_ascii_strtod(data->value, NULL) * WIDTH_SCALE;
break;
case 42:
bulge = g_ascii_strtod(data->value, NULL);
/* The bulge is meant to be _between_ two VERTEX, here: p[points-1] and p[points,]
* but we have not yet read the end point; so just remember the point to 'bulge to' */
bulge_end = points+1;
bulge_x_avail = bulge_y_avail = FALSE;
break;
case 62:
color = pal_get_rgb (atoi(data->value));
break;
case 70:
closed = 1 & atoi( data->value );
/*printf( "closed %d %s", closed, data->value );*/
break;
}
if (points == bulge_end && bulge_x_avail && bulge_y_avail) {
/* turn the last segment into a bulge */
p = g_realloc( p, sizeof( Point ) * ( points + 10 ));
if (points < 2)
continue;
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( is_equal( start.x, end.x ))
{
if( is_equal( start.y, end.y ))
{
continue; /* better than complaining? */
g_warning("Bad vertex bulge");
}
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( is_equal( start.y, end.y ))
{
if( is_equal( start.x, end.x ))
{
continue;
g_warning("Bad vertex bulge");
}
else if( start.x > center.x )
{
start_angle = 0.0;
}
else
{
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 * bulge);
/*printf( "i %d x %f y %f\n", i, p[i].x, p[i].y );*/
}
points += 10;
p[points-1] = end;
}
} while( strcmp( data->value, "SEQEND" ));
if( points == 0 )
{
printf( "No vertexes defined\n" );
return( NULL );
}
pcd = g_new( MultipointCreateData, 1);
if( closed )
{
otype = object_get_type("Standard - Polygon");
}
pcd->num_points = points;
pcd->points = g_new( Point, pcd->num_points );
memcpy( pcd->points, p, sizeof( Point ) * pcd->num_points );
g_free( p );
polyline_obj = otype->ops->create( NULL, pcd, &h1, &h2 );
_color_init_from_rgb (&line_colour, color);
props = g_ptr_array_new ();
prop_list_add_line_colour (props, &line_colour);
prop_list_add_line_width (props, line_width);
prop_list_add_line_style (props, style, 1.0);
polyline_obj->ops->set_props( polyline_obj, props );
prop_list_free(props);
if (layer)
layer_add_object( layer, polyline_obj );
else
return polyline_obj;
return NULL; /* don't add it twice */
}
/* reads a circle entity from the dxf file and creates a circle object in dia*/
static DiaObject *
read_entity_arc_dxf(FILE *filedxf, DxfData *data, DiagramData *dia)
{
/* arc data */
Point start, end;
Point center = {0, 0};
real radius = 1.0, start_angle = 0.0, end_angle=360.0;
real curve_distance;
DiaObjectType *otype = object_get_type("Standard - Arc");
Handle *h1, *h2;
DiaObject *arc_obj;
RGB_t color = { 0, };
Color line_colour;
GPtrArray *props;
real line_width = DEFAULT_LINE_WIDTH;
Layer *layer = dia->active_layer;
do {
if(read_dxf_codes(filedxf, data) == FALSE){
return( NULL );
}
switch(data->code){
case 8:
layer = layer_find_by_name(data->value, dia);
color = pal_get_rgb (_dxf_color_get_by_layer (layer));
break;
case 10:
center.x = g_ascii_strtod(data->value, NULL) * coord_scale * measure_scale;
break;
case 20:
center.y = (-1)*g_ascii_strtod(data->value, NULL) * coord_scale * measure_scale;
break;
case 39:
line_width = g_ascii_strtod(data->value, NULL) * WIDTH_SCALE;
break;
case 40:
radius = g_ascii_strtod(data->value, NULL) * coord_scale * measure_scale;
break;
case 50:
start_angle = g_ascii_strtod(data->value, NULL)*M_PI/180.0;
break;
case 51:
end_angle = g_ascii_strtod(data->value, NULL)*M_PI/180.0;
break;
case 62 :
color = pal_get_rgb (atoi(data->value));
break;
}
} while(data->code != 0);
/* 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);
_color_init_from_rgb (&line_colour, color);
props = g_ptr_array_new ();
prop_list_add_point (props, "start_point", &start);
prop_list_add_point (props, "end_point", &end);
prop_list_add_real (props, "curve_distance", curve_distance);
prop_list_add_line_colour (props, &line_colour);
prop_list_add_line_width (props, line_width);
arc_obj->ops->set_props(arc_obj, props);
prop_list_free(props);
if (layer)
layer_add_object(layer, arc_obj);
else
return arc_obj ;
return NULL; /* don't add it twice */
}
/* reads an ellipse entity from the dxf file and creates an ellipse object in dia*/
static DiaObject *
read_entity_ellipse_dxf(FILE *filedxf, DxfData *data, DiagramData *dia)
{
/* ellipse data */
Point center = {0, 0};
real width = 1.0;
real ratio_width_height = 1.0;
DiaObjectType *otype = object_get_type("Standard - Ellipse");
Handle *h1, *h2;
DiaObject *ellipse_obj;
RGB_t color = { 0, };
Color line_colour;
GPtrArray *props;
real line_width = DEFAULT_LINE_WIDTH;
Layer *layer = dia->active_layer;
do {
if(read_dxf_codes(filedxf, data) == FALSE){
return( NULL );
}
switch(data->code){
case 8:
layer = layer_find_by_name(data->value, dia);
color = pal_get_rgb (_dxf_color_get_by_layer (layer));
break;
case 10:
center.x = g_ascii_strtod(data->value, NULL) * coord_scale * measure_scale;
break;
case 11:
ratio_width_height = g_ascii_strtod(data->value, NULL) * coord_scale * measure_scale;
break;
case 20:
center.y = (-1)*g_ascii_strtod(data->value, NULL) * coord_scale * measure_scale;
break;
case 39:
line_width = g_ascii_strtod(data->value, NULL) * WIDTH_SCALE;
break;
case 40:
width = g_ascii_strtod(data->value, NULL) * WIDTH_SCALE; /* XXX what scale */
break;
case 62 :
color = pal_get_rgb (atoi(data->value));
break;
}
} while(data->code != 0);
center.x -= width;
center.y -= (width*ratio_width_height);
ellipse_obj = otype->ops->create(¢er, otype->default_user_data,
&h1, &h2);
_color_init_from_rgb (&line_colour, color);
props = g_ptr_array_new ();
prop_list_add_point (props, "elem_corner", ¢er);
prop_list_add_real (props, "elem_width", width);
prop_list_add_real (props, "elem_height", width * ratio_width_height);
prop_list_add_line_colour (props, &line_colour);
prop_list_add_line_width (props, line_width);
prop_list_add_show_background (props, FALSE);
ellipse_obj->ops->set_props(ellipse_obj, props);
prop_list_free(props);
if (layer)
layer_add_object(layer, ellipse_obj);
else
return ellipse_obj;
return NULL; /* don't add it twice */
}
static DiaObject *
read_entity_text_dxf(FILE *filedxf, DxfData *data, DiagramData *dia)
{
RGB_t color = { 0, };
/* text data */
Point location = {0, 0};
real height = text_scale * coord_scale * measure_scale;
real y_offset = 0;
Alignment textalignment = ALIGN_LEFT;
char *textvalue = NULL, *textp;
DiaObjectType *otype = object_get_type("Standard - Text");
Handle *h1, *h2;
DiaObject *text_obj;
Color text_colour;
TextProperty *tprop;
GPtrArray *props;
Layer *layer = dia->active_layer;
do {
if (read_dxf_codes(filedxf, data) == FALSE) {
return( NULL );
}
switch (data->code) {
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);
color = pal_get_rgb (_dxf_color_get_by_layer (layer));
break;
case 10:
location.x = g_ascii_strtod(data->value, NULL) * coord_scale * measure_scale;
/*printf( "Found text location x: %f\n", location.x );*/
break;
case 11:
location.x = g_ascii_strtod(data->value, NULL) * coord_scale * measure_scale;
/*printf( "Found text location x: %f\n", location.x );*/
break;
case 20:
location.y = (-1)*g_ascii_strtod(data->value, NULL) * coord_scale * measure_scale;
/*printf( "Found text location y: %f\n", location.y );*/
break;
case 21:
location.y = (-1)*g_ascii_strtod(data->value, NULL) * coord_scale * measure_scale;
/*location.y = (-1)*g_ascii_strtod(data->value, NULL) / text_scale;*/
/*printf( "Found text location y: %f\n", location.y );*/
break;
case 40:
height = g_ascii_strtod(data->value, NULL) * text_scale * coord_scale * measure_scale;
/*printf( "text height %f\n", height );*/
break;
case 62:
color = pal_get_rgb (atoi(data->value));
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(data->code != 0);
location.y += y_offset * height;
_color_init_from_rgb (&text_colour, color);
text_obj = otype->ops->create(&location, otype->default_user_data,
&h1, &h2);
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;
attributes_get_default_font(&tprop->attr.font, &tprop->attr.height);
tprop->attr.color = text_colour;
tprop->attr.height = height;
text_obj->ops->set_props(text_obj, props);
prop_list_free(props);
if (layer)
layer_add_object(layer, text_obj);
else
return text_obj;
return NULL; /* don't add it twice */
}
static DiaObject *
fig_read_text(FILE *file, DiaContext *ctx)
{
GPtrArray *props = NULL;
TextProperty *tprop;
DiaObject *newobj = NULL;
int sub_type;
int color;
int depth;
int pen_style;
int font;
real font_size;
real angle;
int font_flags;
real height;
real length;
int x, y;
char *text_buf = NULL;
char* old_locale;
old_locale = setlocale(LC_NUMERIC, "C");
if (fscanf(file, " %d %d %d %d %d %lf %lf %d %lf %lf %d %d",
&sub_type,
&color,
&depth,
&pen_style,
&font,
&font_size,
&angle,
&font_flags,
&height,
&length,
&x,
&y) != 12) {
dia_context_add_message_with_errno(ctx, errno, _("Couldn't read text info."));
setlocale(LC_NUMERIC, old_locale);
return NULL;
}
/* Skip one space exactly */
text_buf = fig_read_text_line(file);
newobj = create_standard_text(x/FIG_UNIT, y/FIG_UNIT);
if (newobj == NULL) goto exit;
props = prop_list_from_descs(xfig_text_descs,pdtpp_true);
tprop = g_ptr_array_index(props,0);
tprop->text_data = g_strdup(text_buf);
/*g_free(text_buf); */
tprop->attr.alignment = sub_type;
tprop->attr.position.x = x/FIG_UNIT;
tprop->attr.position.y = y/FIG_UNIT;
if ((font_flags & 4) == 0) {
switch (font) {
case 0: tprop->attr.font = dia_font_new_from_legacy_name("Times-Roman"); break;
case 1: tprop->attr.font = dia_font_new_from_legacy_name("Times-Roman"); break;
case 2: tprop->attr.font = dia_font_new_from_legacy_name("Times-Bold"); break;
case 3: tprop->attr.font = dia_font_new_from_legacy_name("Times-Italic"); break;
case 4: tprop->attr.font = dia_font_new_from_legacy_name("Helvetica"); break;
case 5: tprop->attr.font = dia_font_new_from_legacy_name("Courier"); break;
default:
dia_context_add_message(ctx, _("Can't find LaTeX font nr. %d, using sans"), font);
tprop->attr.font = dia_font_new_from_legacy_name("Helvetica");
}
} else {
if (font == -1) {
/* "Default font" - wazzat? */
tprop->attr.font = dia_font_new_from_legacy_name("Times-Roman");
} else if (font < 0 || font >= num_fig_fonts()) {
dia_context_add_message(ctx, _("Can't find Postscript font nr. %d, using sans"), font);
tprop->attr.font = dia_font_new_from_legacy_name("Helvetica");
} else {
tprop->attr.font = dia_font_new_from_legacy_name(fig_fonts[font]);
}
}
tprop->attr.height = font_size*2.54/72.0;
tprop->attr.color = fig_color(color, ctx);
newobj->ops->set_props(newobj, props);
/* Depth field */
add_at_depth(newobj, depth, ctx);
exit:
setlocale(LC_NUMERIC, old_locale);
if (text_buf != NULL) g_free(text_buf);
if (props != NULL) prop_list_free(props);
return newobj;
}
static DiaObject *
fig_read_spline(FILE *file, DiaContext *ctx)
{
int sub_type;
int line_style;
int thickness;
int pen_color;
int fill_color;
int depth;
int pen_style;
int area_fill;
real style_val;
int cap_style;
int forward_arrow, backward_arrow;
Arrow *forward_arrow_info = NULL, *backward_arrow_info = NULL;
int npoints;
Point *points = NULL;
GPtrArray *props = g_ptr_array_new();
DiaObject *newobj = NULL;
BezPoint *bezpoints;
int i;
char* old_locale;
old_locale = setlocale(LC_NUMERIC, "C");
if (fscanf(file, "%d %d %d %d %d %d %d %d %lf %d %d %d %d\n",
&sub_type,
&line_style,
&thickness,
&pen_color,
&fill_color,
&depth,
&pen_style,
&area_fill,
&style_val,
&cap_style,
&forward_arrow,
&backward_arrow,
&npoints) != 13) {
dia_context_add_message_with_errno(ctx, errno, _("Couldn't read spline info."));
goto exit;
}
if (forward_arrow == 1) {
forward_arrow_info = fig_read_arrow(file, ctx);
}
if (backward_arrow == 1) {
backward_arrow_info = fig_read_arrow(file, ctx);
}
if (!fig_read_n_points(file, npoints, &points, ctx)) {
goto exit;
}
switch (sub_type) {
case 0: /* Open approximated spline */
case 1: /* Closed approximated spline */
dia_context_add_message(ctx, _("Cannot convert approximated spline yet."));
goto exit;
case 2: /* Open interpolated spline */
case 3: /* Closed interpolated spline */
/* Despite what the Fig description says, interpolated splines
now also have the line with spline info from the X-spline */
case 4: /* Open X-spline */
case 5: /* Closed X-spline */
{
double f;
gboolean interpolated = TRUE;
for (i = 0; i < npoints; i++) {
if (fscanf(file, " %lf ", &f) != 1) {
dia_context_add_message_with_errno(ctx, errno,_("Couldn't read spline info."));
goto exit;
}
if (f != -1.0 && f != 0.0) {
dia_context_add_message(ctx, _("Cannot convert approximated spline yet."));
interpolated = FALSE;
}
}
if (!interpolated)
goto exit;
/* Matrix-based conversion not ready yet. */
#if 0
if (sub_type%2 == 0) {
bezpoints = fig_transform_spline(npoints, points, FALSE, f);
newobj = create_standard_bezierline(npoints, bezpoints,
forward_arrow_info,
backward_arrow_info);
} else {
points = g_renew(Point, points, npoints+1);
points[npoints] = points[0];
npoints++;
bezpoints = fig_transform_spline(npoints, points, TRUE, f);
newobj = create_standard_beziergon(npoints, bezpoints);
}
#else
if (sub_type%2 == 0) {
bezpoints = transform_spline(npoints, points, FALSE);
newobj = create_standard_bezierline(npoints, bezpoints,
forward_arrow_info,
backward_arrow_info);
} else {
points = g_renew(Point, points, npoints+1);
points[npoints] = points[0];
npoints++;
bezpoints = transform_spline(npoints, points, TRUE);
newobj = create_standard_beziergon(npoints, bezpoints);
}
#endif
}
if (newobj == NULL) goto exit;
break;
default:
dia_context_add_message(ctx, _("Unknown spline subtype: %d\n"), sub_type);
goto exit;
}
fig_simple_properties(newobj, line_style, style_val, thickness,
pen_color, fill_color, area_fill, ctx);
/* Pen style field (not used) */
/* Style_val (size of dots and dashes) in 1/80 inch*/
/* Cap style */
/* Depth field */
add_at_depth(newobj, depth, ctx);
exit:
setlocale(LC_NUMERIC, old_locale);
prop_list_free(props);
g_free(forward_arrow_info);
g_free(backward_arrow_info);
g_free(points);
return newobj;
}
static DiaObject *
fig_read_polyline(FILE *file, DiaContext *ctx)
{
int sub_type;
int line_style;
int thickness;
int pen_color;
int fill_color;
int depth;
int pen_style;
int area_fill;
real style_val;
int join_style;
int cap_style;
int radius;
int forward_arrow, backward_arrow;
Arrow *forward_arrow_info = NULL, *backward_arrow_info = NULL;
int npoints;
Point *points;
GPtrArray *props = g_ptr_array_new();
DiaObject *newobj = NULL;
int flipped = 0;
char *image_file = NULL;
char* old_locale;
old_locale = setlocale(LC_NUMERIC, "C");
if (fscanf(file, "%d %d %d %d %d %d %d %d %lf %d %d %d %d %d %d\n",
&sub_type,
&line_style,
&thickness,
&pen_color,
&fill_color,
&depth,
&pen_style,
&area_fill,
&style_val,
&join_style,
&cap_style,
&radius,
&forward_arrow,
&backward_arrow,
&npoints) != 15) {
dia_context_add_message_with_errno(ctx, errno, _("Couldn't read polyline info.\n"));
goto exit;
}
if (forward_arrow == 1) {
forward_arrow_info = fig_read_arrow(file, ctx);
}
if (backward_arrow == 1) {
backward_arrow_info = fig_read_arrow(file, ctx);
}
if (sub_type == 5) { /* image has image name before npoints */
/* Despite what the specs say */
if (fscanf(file, " %d", &flipped) != 1) {
dia_context_add_message_with_errno(ctx, errno, _("Couldn't read flipped bit."));
goto exit;
}
image_file = fig_read_text_line(file);
}
if (!fig_read_n_points(file, npoints, &points, ctx)) {
goto exit;
}
switch (sub_type) {
case 4: {
RealProperty *rprop =
(RealProperty *)make_new_prop("corner_radius",
PROP_TYPE_REAL,PROP_FLAG_DONT_SAVE);
if (radius < 0) {
dia_context_add_message(ctx, _("Negative corner radius; negating"));
rprop->real_data = -radius/FIG_ALT_UNIT;
} else {
rprop->real_data = radius/FIG_ALT_UNIT;
}
g_ptr_array_add(props,rprop);
}
/* Notice fallthrough */
case 2: /* box */
if (points[0].x > points[2].x) {
real tmp = points[0].x;
points[0].x = points[2].x;
points[2].x = tmp;
}
if (points[0].y > points[2].y) {
real tmp = points[0].y;
points[0].y = points[2].y;
points[2].y = tmp;
}
newobj = create_standard_box(points[0].x, points[0].y,
points[2].x-points[0].x,
points[2].y-points[0].y);
if (newobj == NULL) goto exit;
newobj->ops->set_props(newobj, props);
break;
case 5: /* imported-picture bounding-box) */
newobj = create_standard_image(points[0].x, points[0].y,
points[2].x-points[0].x,
points[2].y-points[0].y,
image_file);
if (newobj == NULL) goto exit;
break;
case 1: /* polyline */
newobj = create_standard_polyline(npoints, points,
forward_arrow_info,
backward_arrow_info);
if (newobj == NULL) goto exit;
break;
case 3: /* polygon */
newobj = create_standard_polygon(npoints, points);
if (newobj == NULL) goto exit;
break;
default:
dia_context_add_message(ctx, _("Unknown polyline subtype: %d\n"), sub_type);
goto exit;
}
fig_simple_properties(newobj, line_style, style_val, thickness,
pen_color, fill_color, area_fill, ctx);
/* Pen style field (not used) */
/* Style_val (size of dots and dashes) in 1/80 inch*/
/* Join style */
/* Cap style */
/* Depth field */
add_at_depth(newobj, depth, ctx);
exit:
setlocale(LC_NUMERIC, old_locale);
prop_list_free(props);
g_free(forward_arrow_info);
g_free(backward_arrow_info);
g_free(image_file);
return newobj;
}
static void
text_change_free(struct TextObjectChange *change)
{
g_free(change->str);
prop_list_free(change->props);
}
static void
object_prop_change_free(ObjectPropChange *change)
{
prop_list_free(change->saved_props);
}
/*!
* \brief Draw a string to _Textobj
*
* To get objects more similar to what we had during export we
* should probably use TextOutputDev. It reassembles strings
* based on their position on the page. Or maybe Dia/cairo should
* stop realigning single glyphs in it's output?
*
* \todo Check alignment options - it's just guessed yet.
*/
void
DiaOutputDev::drawString(GfxState *state, GooString *s)
{
Color text_color = this->fill_color;
int len = s->getLength();
DiaObject *obj;
gchar *utf8 = NULL;
DiaFont *font;
// ignore empty strings
if (len == 0)
return;
// get the font
if (!state->getFont())
return;
if (!(state->getFontSize() > 0.0))
return;
font = (DiaFont *)g_hash_table_lookup (this->font_map, state->getFont());
// we have to decode the string data first
{
GfxFont *f = state->getFont();
char *p = s->getCString();
CharCode code;
int j = 0, m, n;
utf8 = g_new (gchar, len * 6 + 1);
Unicode *u;
int uLen;
double dx, dy, ox, oy;
while (len > 0) {
n = f->getNextChar(p, len, &code,
&u, &uLen,
&dx, &dy, &ox, &oy);
p += n;
len -= n;
m = g_unichar_to_utf8 (u[0], &utf8[j]);
j += m;
}
utf8[j] = '\0';
}
// check for invisible text -- this is used by Acrobat Capture
if (state->getRender() == 3)
text_color.alpha = 0.0;
// not sure how state->getLineX() is related, it's 0 in my test cases
double tx = state->getCurX();
double ty = state->getCurY();
int rot = state->getRotate();
if (rot == 0)
obj = create_standard_text (tx * scale, page_height - ty * scale);
else /* XXX: at least for rot==90 */
obj = create_standard_text (ty * scale, tx * scale);
//not applyStyle (obj, TEXT);
GPtrArray *plist = g_ptr_array_new ();
// the "text" property is special, it must be initialized with text
// attributes, too. So here it comes first to avoid overwriting
// the other values with defaults.
prop_list_add_text (plist, "text", utf8);
prop_list_add_font (plist, "text_font", font);
prop_list_add_text_colour (plist, &text_color);
prop_list_add_enum (plist, "text_alignment", this->alignment);
prop_list_add_fontsize (plist, "text_height", state->getTransformedFontSize() * scale / 0.8);
obj->ops->set_props (obj, plist);
prop_list_free (plist);
g_free (utf8);
addObject (obj);
}