static DiaObject *
compfeat_create(Point *startpoint,
void *user_data,
Handle **handle1,
Handle **handle2)
{
Compfeat *compfeat;
OrthConn *orth;
DiaObject *obj;
Point p;
DiaFont *font;
font = dia_font_new_from_style(DIA_FONT_MONOSPACE, 0.8);
compfeat = g_new0(Compfeat, 1);
compfeat->role = compfeat->roletmp = GPOINTER_TO_INT(user_data);
compfeat->line_width = 0.1;
orth = &compfeat->orth;
obj = &orth->object;
obj->type = &compfeat_type;
obj->ops = &compfeat_ops;
orthconn_init(orth, startpoint);
p = *startpoint;
p.y -= COMPPROP_TEXTOFFSET;
compfeat->line_color = attributes_get_foreground();
compfeat->text = new_text("", font,
COMPPROP_FONTHEIGHT, &p, &compfeat->line_color,
ALIGN_CENTER);
dia_font_unref(font);
compfeat->text_handle.id = HANDLE_MOVE_TEXT;
compfeat->text_handle.type = HANDLE_MINOR_CONTROL;
compfeat->text_handle.connect_type = HANDLE_NONCONNECTABLE;
compfeat->text_handle.connected_to = NULL;
compfeat->text_handle.pos = compfeat->text_pos = p;
object_add_handle(obj, &compfeat->text_handle);
if (compfeat->role == COMPPROP_FACET
|| compfeat->role == COMPPROP_EVENTSOURCE) {
int pos = obj->num_connections;
object_add_connectionpoint(&orth->object, &compfeat->cp);
obj->connections[pos] = &compfeat->cp;
compfeat->cp.object = obj;
compfeat->cp.connected = NULL;
}
compfeat_update_data(compfeat);
*handle1 = orth->handles[0];
*handle2 = orth->handles[orth->numpoints-2];
return &compfeat->orth.object;
}
void
boolequation_destroy(Boolequation *booleq)
{
g_return_if_fail(booleq);
dia_font_unref(booleq->font);
if (booleq->value) g_free((gchar *)booleq->value);
if (booleq->rootblock) booleq->rootblock->ops->destroy(booleq->rootblock);
g_free(booleq);
}
static DiaObject *
function_create(Point *startpoint,
void *user_data,
Handle **handle1,
Handle **handle2)
{
Function *pkg;
Element *elem;
DiaObject *obj;
Point p;
DiaFont *font;
int i;
pkg = g_malloc0(sizeof(Function));
elem = &pkg->element;
obj = &elem->object;
obj->type = &function_type;
obj->ops = &function_ops;
elem->corner = *startpoint;
font = dia_font_new_from_style (DIA_FONT_SANS,FUNCTION_FONTHEIGHT);
pkg->is_wish = FALSE;
pkg->is_user = FALSE;
/* The text position is recalculated later */
p.x = 0.0;
p.y = 0.0;
pkg->text = new_text("", font, FUNCTION_FONTHEIGHT, &p, &color_black,
ALIGN_CENTER);
dia_font_unref(font);
element_init(elem, 8, NUM_CONNECTIONS);
for (i=0;i<NUM_CONNECTIONS;i++) {
obj->connections[i] = &pkg->connections[i];
pkg->connections[i].object = obj;
pkg->connections[i].connected = NULL;
}
pkg->connections[8].flags = CP_FLAGS_MAIN;
pkg->element.extra_spacing.border_trans = FUNCTION_FONTHEIGHT / FUNCTION_BORDERWIDTH_SCALE/2.0;
function_update_data(pkg);
for (i=0;i<8;i++) {
obj->handles[i]->type = HANDLE_NON_MOVABLE;
}
*handle1 = NULL;
*handle2 = NULL;
return &pkg->element.object;
}
static void
realizes_destroy(Realizes *realize)
{
g_free(realize->name);
g_free(realize->stereotype);
g_free(realize->st_stereotype);
dia_font_unref(realize->font);
orthconn_destroy(&realize->orth);
}
static DiaObject *
basestation_create(Point *startpoint,
void *user_data,
Handle **handle1,
Handle **handle2)
{
Basestation *basestation;
Element *elem;
DiaObject *obj;
Point p;
DiaFont *font;
int i;
basestation = g_new0(Basestation, 1);
elem = &basestation->element;
obj = &elem->object;
obj->type = &basestation_type;
obj->ops = &basestation_ops;
elem->corner = *startpoint;
elem->width = BASESTATION_WIDTH;
elem->height = BASESTATION_HEIGHT;
font = dia_font_new_from_style (DIA_FONT_MONOSPACE, 0.8);
p = *startpoint;
p.y += BASESTATION_HEIGHT -
dia_font_descent(_("Base Station"), font, 0.8);
basestation->text = new_text(_("Base Station"),
font, 0.8, &p, &color_black, ALIGN_CENTER);
dia_font_unref(font);
basestation->line_colour = color_black;
basestation->fill_colour = color_white;
basestation->sectors = 3;
element_init(elem, 8, NUM_CONNECTIONS);
for (i=0; i<NUM_CONNECTIONS; i++) {
obj->connections[i] = &basestation->connections[i];
basestation->connections[i].object = obj;
basestation->connections[i].connected = NULL;
basestation->connections[i].flags = 0;
}
basestation->connections[8].flags = CP_FLAGS_MAIN;
elem->extra_spacing.border_trans = BASESTATION_LINEWIDTH/2.0;
basestation_update_data(basestation);
for (i=0; i<8; i++) {
obj->handles[i]->type = HANDLE_NON_MOVABLE;
}
*handle1 = NULL;
*handle2 = NULL;
return &basestation->element.object;
}
static DiaObject *
usecase_create(Point *startpoint,
void *user_data,
Handle **handle1,
Handle **handle2)
{
Usecase *usecase;
Element *elem;
DiaObject *obj;
Point p;
DiaFont *font;
int i;
usecase = g_malloc0(sizeof(Usecase));
elem = &usecase->element;
obj = &elem->object;
obj->type = &usecase_type;
obj->ops = &usecase_ops;
elem->corner = *startpoint;
elem->width = USECASE_WIDTH;
elem->height = USECASE_HEIGHT;
usecase->line_width = attributes_get_default_linewidth();
usecase->line_color = attributes_get_foreground();
usecase->fill_color = attributes_get_background();
font = dia_font_new_from_style(DIA_FONT_SANS, 0.8);
p = *startpoint;
p.x += USECASE_WIDTH/2.0;
p.y += USECASE_HEIGHT/2.0;
usecase->text = new_text("", font, 0.8, &p, &color_black, ALIGN_CENTER);
dia_font_unref(font);
usecase->text_outside = 0;
usecase->collaboration = 0;
element_init(elem, 8, NUM_CONNECTIONS);
for (i=0;i<NUM_CONNECTIONS;i++) {
obj->connections[i] = &usecase->connections[i];
usecase->connections[i].object = obj;
usecase->connections[i].connected = NULL;
}
usecase->connections[8].flags = CP_FLAGS_MAIN;
elem->extra_spacing.border_trans = 0.0;
usecase_update_data(usecase);
for (i=0;i<8;i++) {
obj->handles[i]->type = HANDLE_NON_MOVABLE;
}
*handle1 = NULL;
*handle2 = NULL;
return &usecase->element.object;
}
static DiaObject *
textobj_load(ObjectNode obj_node, int version, DiaContext *ctx)
{
Textobj *textobj;
DiaObject *obj;
AttributeNode attr;
Point startpoint = {0.0, 0.0};
textobj = g_malloc0(sizeof(Textobj));
obj = &textobj->object;
obj->type = &textobj_type;
obj->ops = &textobj_ops;
object_load(obj, obj_node, ctx);
attr = object_find_attribute(obj_node, "text");
if (attr != NULL) {
textobj->text = data_text(attribute_first_data(attr), ctx);
} else {
DiaFont* font = dia_font_new_from_style(DIA_FONT_MONOSPACE,1.0);
textobj->text = new_text("", font, 1.0,
&startpoint, &color_black, ALIGN_CENTER);
dia_font_unref(font);
}
attr = object_find_attribute(obj_node, "valign");
if (attr != NULL)
textobj->vert_align = data_enum(attribute_first_data(attr), ctx);
else if (version == 0) {
textobj->vert_align = VALIGN_FIRST_LINE;
}
/* default visibility must be off to keep compatibility */
textobj->fill_color = attributes_get_background();
attr = object_find_attribute(obj_node, "fill_color");
if (attr)
data_color(attribute_first_data(attr), &textobj->fill_color, ctx);
attr = object_find_attribute(obj_node, "show_background");
if (attr)
textobj->show_background = data_boolean(attribute_first_data(attr), ctx);
else
textobj->show_background = FALSE;
object_init(obj, 1, 0);
obj->handles[0] = &textobj->text_handle;
textobj->text_handle.id = HANDLE_TEXT;
textobj->text_handle.type = HANDLE_MAJOR_CONTROL;
textobj->text_handle.connect_type = HANDLE_CONNECTABLE;
textobj->text_handle.connected_to = NULL;
textobj_update_data(textobj);
return &textobj->object;
}
static void
largepackage_destroy(LargePackage *pkg)
{
dia_font_unref(pkg->font);
g_free(pkg->stereotype);
g_free(pkg->st_stereotype);
g_free(pkg->name);
element_destroy(&pkg->element);
}
static void
dia_ps_ft2_renderer_finalize (GObject *object)
{
DiaPsFt2Renderer *renderer = DIA_PS_FT2_RENDERER(object);
if (renderer->current_font != NULL) {
dia_font_unref(renderer->current_font);
renderer->current_font = NULL;
}
G_OBJECT_CLASS (parent_class)->finalize (object);
}
static DiaObject *
note_create(Point *startpoint,
void *user_data,
Handle **handle1,
Handle **handle2)
{
Note *note;
Element *elem;
DiaObject *obj;
Point p;
DiaFont *font;
int i;
note = g_malloc0(sizeof(Note));
elem = ¬e->element;
obj = &elem->object;
obj->type = ¬e_type;
obj->ops = ¬e_ops;
elem->corner = *startpoint;
note->line_width = attributes_get_default_linewidth();
note->line_color = attributes_get_foreground();
note->fill_color = attributes_get_background();
font = dia_font_new_from_style (DIA_FONT_MONOSPACE, 0.8);
p = *startpoint;
p.x += note->line_width/2.0 + NOTE_MARGIN_X;
p.y += note->line_width/2.0 + NOTE_CORNER + dia_font_ascent("A",font, 0.8);
note->text = new_text("", font, 0.8, &p, &color_black, ALIGN_LEFT);
dia_font_unref(font);
element_init(elem, 8, NUM_CONNECTIONS);
for (i=0;i<NUM_CONNECTIONS;i++) {
obj->connections[i] = ¬e->connections[i];
note->connections[i].object = obj;
note->connections[i].connected = NULL;
}
note->connections[NUM_CONNECTIONS-1].flags = CP_FLAGS_MAIN;
elem->extra_spacing.border_trans = note->line_width/2.0;
note_update_data(note);
for (i=0;i<8;i++) {
obj->handles[i]->type = HANDLE_NON_MOVABLE;
}
*handle1 = NULL;
*handle2 = NULL;
return ¬e->element.object;
}
static DiaObject *
flow_load(ObjectNode obj_node, int version, DiaContext *ctx)
{
Flow *flow;
AttributeNode attr;
Connection *conn;
DiaObject *obj;
LineBBExtras *extra;
flow = g_malloc0(sizeof(Flow));
conn = &flow->connection;
obj = &conn->object;
extra = &conn->extra_spacing;
obj->type = &flow_type;
obj->ops = &flow_ops;
connection_load(conn, obj_node, ctx);
connection_init(conn, 3, 0);
flow->text = NULL;
attr = object_find_attribute(obj_node, "text");
if (attr != NULL)
flow->text = data_text(attribute_first_data(attr), ctx);
else { /* pathologic */
DiaFont *font = dia_font_new_from_style(DIA_FONT_SANS, FLOW_FONTHEIGHT);
flow->text = new_text("", font, FLOW_FONTHEIGHT, &obj->position, &color_black, ALIGN_CENTER);
dia_font_unref(font);
}
attr = object_find_attribute(obj_node, "type");
if (attr != NULL)
flow->type = (FlowType)data_int(attribute_first_data(attr), ctx);
flow->text_handle.id = HANDLE_MOVE_TEXT;
flow->text_handle.type = HANDLE_MINOR_CONTROL;
flow->text_handle.connect_type = HANDLE_NONCONNECTABLE;
flow->text_handle.connected_to = NULL;
flow->text_handle.pos = flow->text->position;
obj->handles[2] = &flow->text_handle;
extra->start_long =
extra->end_long =
extra->start_trans = FLOW_WIDTH/2.0;
extra->end_trans = MAX(FLOW_WIDTH, FLOW_ARROWLEN) / 2.0;
flow->textpos = flow->text->position;
flow_update_data(flow);
return &flow->connection.object;
}
/*!
* Fallback function returning a default initialized text object.
*/
Text *
new_text_default(Point *pos, Color *color, Alignment align)
{
Text *text;
DiaFont *font;
real font_height;
attributes_get_default_font(&font, &font_height);
text = new_text("", font, font_height, pos, color, align);
dia_font_unref(font);
return text;
}
void
text_get_attributes(Text *text, TextAttributes *attr)
{
DiaFont *old_font;
old_font = attr->font;
attr->font = dia_font_ref(text->font);
if (old_font != NULL) dia_font_unref(old_font);
attr->height = text->height;
attr->position = text->position;
attr->color = text->color;
attr->alignment = text->alignment;
}
static DiaObject *
radiocell_create(Point *startpoint,
void *user_data,
Handle **handle1,
Handle **handle2)
{
RadioCell *radiocell;
PolyShape *poly;
DiaObject *obj;
DiaFont *font;
int i = 0;
radiocell = g_new0(RadioCell, 1);
poly = &radiocell->poly;
obj = &poly->object;
obj->type = &radiocell_type;
obj->ops = &radiocell_ops;
radiocell->radius = 4.;
/* do not use default_properties.show_background here */
radiocell->show_background = FALSE;
radiocell->fill_colour = color_white;
radiocell->line_colour = color_black;
radiocell->line_width = RADIOCELL_LINEWIDTH;
attributes_get_default_line_style(&radiocell->line_style,
&radiocell->dashlength);
font = dia_font_new_from_style(DIA_FONT_MONOSPACE, RADIOCELL_FONTHEIGHT);
radiocell->text = new_text("", font, RADIOCELL_FONTHEIGHT, startpoint,
&color_black, ALIGN_CENTER);
dia_font_unref(font);
polyshape_init(poly, 6);
radiocell->center = *startpoint;
/* rather broken but otherwise we will always calculate from unitialized data
* see polyshape_update_data() */
poly->points[0].y = startpoint->y;
poly->points[0].x = startpoint->x - radiocell->radius;
poly->points[3].x = startpoint->x + radiocell->radius;
radiocell_update_data(radiocell);
*handle1 = poly->object.handles[0];
*handle2 = poly->object.handles[2];
for (i=0;i<6;i++) {
poly->object.handles[i]->id = HANDLE_CUSTOM1 + i;
}
return &radiocell->poly.object;
}
static void
end_render(DiaRenderer *self)
{
DiaPsRenderer *renderer = DIA_PS_RENDERER(self);
if (renderer_is_eps(renderer))
fprintf(renderer->file, "showpage\n");
if (self->font != NULL) {
dia_font_unref(self->font);
self->font = NULL;
}
}
static DiaObject *
state_create_activity(Point *startpoint,
void *user_data,
Handle **handle1,
Handle **handle2)
{
State *state;
Element *elem;
DiaObject *obj;
Point p;
DiaFont *font;
int i;
state = g_malloc0(sizeof(State));
elem = &state->element;
obj = &elem->object;
obj->type = &activity_type;
obj->ops = &state_ops;
elem->corner = *startpoint;
elem->width = STATE_WIDTH;
elem->height = STATE_HEIGHT;
state->line_color = attributes_get_foreground();
state->fill_color = attributes_get_background();
font = dia_font_new_from_style (DIA_FONT_SANS, 0.8);
p = *startpoint;
p.x += STATE_WIDTH/2.0;
p.y += STATE_HEIGHT/2.0;
state->text = new_text("", font, 0.8, &p, &color_black, ALIGN_CENTER);
dia_font_unref(font);
element_init(elem, 8, 8);
for (i=0;i<8;i++) {
obj->connections[i] = &state->connections[i];
state->connections[i].object = obj;
state->connections[i].connected = NULL;
}
elem->extra_spacing.border_trans = 0.0;
state_update_data(state);
for (i=0;i<8;i++) {
obj->handles[i]->type = HANDLE_NON_MOVABLE;
}
*handle1 = NULL;
*handle2 = NULL;
return &state->element.object;;
}
static DiaObject *
textobj_create(Point *startpoint,
void *user_data,
Handle **handle1,
Handle **handle2)
{
Textobj *textobj;
DiaObject *obj;
Color col;
DiaFont *font = NULL;
real font_height;
textobj = g_malloc0(sizeof(Textobj));
obj = &textobj->object;
obj->enclosing_box = g_new0 (Rectangle, 1);
obj->type = &textobj_type;
obj->ops = &textobj_ops;
col = attributes_get_foreground();
attributes_get_default_font(&font, &font_height);
textobj->text = new_text("", font, font_height,
startpoint, &col, default_properties.alignment );
/* need to initialize to object.position as well, it is used update data */
obj->position = *startpoint;
dia_font_unref(font);
textobj->vert_align = default_properties.vert_align;
/* default visibility must be off to keep compatibility */
textobj->fill_color = attributes_get_background();
textobj->show_background = FALSE;
object_init(obj, 1, 0);
obj->handles[0] = &textobj->text_handle;
textobj->text_handle.id = HANDLE_TEXT;
textobj->text_handle.type = HANDLE_MAJOR_CONTROL;
textobj->text_handle.connect_type = HANDLE_CONNECTABLE;
textobj->text_handle.connected_to = NULL;
/* no margin till Dia 0.98 */
textobj->margin = 0.0;
textobj_update_data(textobj);
*handle1 = NULL;
*handle2 = obj->handles[0];
return &textobj->object;
}
static void
transition_set_props(Transition *transition, GPtrArray *props)
{
object_set_props_from_offsets(&transition->element.object,
transition_offsets,props);
boolequation_set_value(transition->receptivity,transition->rcep_value);
dia_font_unref(transition->receptivity->font);
transition->receptivity->font = dia_font_ref(transition->rcep_font);
transition->receptivity->fontheight = transition->rcep_fontheight;
transition->receptivity->color = transition->rcep_color;
transition_update_data(transition);
}
static DiaObject *node_create(Point *startpoint, void *user_data, Handle **handle1, Handle **handle2)
{
Node *node;
Element *elem;
DiaObject *obj;
Point p;
DiaFont *font;
int i;
node = g_malloc0(sizeof(Node));
/* old defaults */
node->line_width = 0.1;
elem = &node->element;
obj = &elem->object;
obj->type = &node_type;
obj->ops = &node_ops;
elem->corner = *startpoint;
node->line_color = attributes_get_foreground();
node->fill_color = attributes_get_background();
font = dia_font_new_from_style (DIA_FONT_SANS, 0.8);
/* The text position is recalculated later */
p.x = 0.0;
p.y = 0.0;
node->name = new_text("", font, 0.8, &p, &color_black, ALIGN_LEFT);
dia_font_unref(font);
element_init(elem, 8, NUM_CONNECTIONS);
for (i=0;i<NUM_CONNECTIONS;i++) {
obj->connections[i] = &node->connections[i];
node->connections[i].object = obj;
node->connections[i].connected = NULL;
}
node->connections[8].flags = CP_FLAGS_MAIN;
elem->extra_spacing.border_trans = node->line_width/2.0;
node_update_data(node);
*handle1 = NULL;
*handle2 = obj->handles[7];
return &node->element.object;
}
void
text_set_font(Text *text, DiaFont *font)
{
DiaFont *old_font = text->font;
int i;
text->font = dia_font_ref(font);
dia_font_unref(old_font);
for (i = 0; i < text->numlines; i++) {
text_line_set_font(text->lines[i], font);
}
calc_width(text);
calc_ascent_descent(text);
}
static void
dia_font_check_for_font(int font)
{
DiaFont *check;
PangoFont *loaded;
static real height = 1.0;
check = dia_font_new_from_style(font, height);
loaded = pango_context_load_font(dia_font_get_context(), check->pfd);
if (!loaded) {
message_error(_("Can't load font %s.\n"), dia_font_get_family(check));
} else {
g_object_unref(loaded);
}
dia_font_unref(check);
}
Text *
data_text(AttributeNode text_attr, DiaContext *ctx)
{
char *string = NULL;
DiaFont *font;
real height;
Point pos = {0.0, 0.0};
Color col;
Alignment align;
AttributeNode attr;
Text *text;
attr = composite_find_attribute(text_attr, "string");
if (attr != NULL)
string = data_string(attribute_first_data(attr), ctx);
height = 1.0;
attr = composite_find_attribute(text_attr, "height");
if (attr != NULL)
height = data_real(attribute_first_data(attr), ctx);
attr = composite_find_attribute(text_attr, "font");
if (attr != NULL) {
font = data_font(attribute_first_data(attr), ctx);
} else {
font = dia_font_new_from_style(DIA_FONT_SANS,1.0);
}
attr = composite_find_attribute(text_attr, "pos");
if (attr != NULL)
data_point(attribute_first_data(attr), &pos, ctx);
col = color_black;
attr = composite_find_attribute(text_attr, "color");
if (attr != NULL)
data_color(attribute_first_data(attr), &col, ctx);
align = ALIGN_LEFT;
attr = composite_find_attribute(text_attr, "alignment");
if (attr != NULL)
align = data_enum(attribute_first_data(attr), ctx);
text = new_text(string ? string : "", font, height, &pos, &col, align);
if (font) dia_font_unref(font);
if (string) g_free(string);
return text;
}
static void
set_font(DiaRenderer *self, DiaFont *font, real height)
{
DiaPsFt2Renderer *renderer = DIA_PS_FT2_RENDERER(self);
if (renderer->current_font != font) {
if (renderer->current_font != NULL) {
dia_font_unref(renderer->current_font);
}
renderer->current_font = font;
/* Dammit! We have a random factor once again!
* And not only here but also in dia_font_scaled_build_layout() below ...
*/
renderer->current_height = height/**4.3*/;
dia_font_ref(font);
}
pango_context_set_font_description(dia_font_get_context(),
dia_font_get_description(font));
}
/** *NOT A CALLBACK*
Caller must set: - obj->type
--------------- - obj->ops
*/
DiaObject *aadlbox_create(Point *startpoint, void *user_data,
Handle **handle1, Handle **handle2)
{
Aadlbox *aadlbox;
Element *elem;
DiaObject *obj;
Point p;
DiaFont *font;
aadlbox = g_malloc0(sizeof(Aadlbox));
elem = &aadlbox->element;
obj = &elem->object;
obj->flags |= DIA_OBJECT_CAN_PARENT;
elem->corner = *startpoint;
aadlbox->specific = (Aadlbox_specific *) user_data;
aadlbox->num_ports = 0;
aadlbox->ports = NULL;
aadlbox->line_color = attributes_get_foreground();
aadlbox->fill_color = attributes_get_background();
font = dia_font_new_from_style (DIA_FONT_SANS, 0.8);
/* The text position is recalculated later */
p.x = 0.0;
p.y = 0.0;
aadlbox->name = new_text("", font, 0.8, &p, &color_black, ALIGN_LEFT);
text_get_attributes(aadlbox->name,&aadlbox->attrs);
dia_font_unref(font);
element_init(elem, 8, 0); /* 8 handles and 0 connection */
elem->extra_spacing.border_trans = AADLBOX_BORDERWIDTH/2.0;
aadlbox_update_data(aadlbox);
*handle1 = NULL;
*handle2 = obj->handles[7];
return &aadlbox->element.object;
}
static void
set_font(DiaRenderer *self, DiaFont *font, real height)
{
DiaCairoRenderer *renderer = DIA_CAIRO_RENDERER (self);
#ifndef HAVE_PANGOCAIRO_H
DiaFontStyle style = dia_font_get_style (font);
const char *family_name;
#endif
/* pango/cairo wants the font size, not the (line-) height */
real size = dia_font_get_size (font) * (height / dia_font_get_height (font));
PangoFontDescription *pfd = pango_font_description_copy (dia_font_get_description (font));
DIAG_NOTE(g_message("set_font %f %s", height, dia_font_get_family(font)));
#ifdef HAVE_PANGOCAIRO_H
/* select font and size */
pango_font_description_set_absolute_size (pfd, (int)(size * PANGO_SCALE));
pango_layout_set_font_description (renderer->layout, pfd);
pango_font_description_free (pfd);
#else
family_name = dia_font_get_family(font);
cairo_select_font_face (
renderer->cr,
family_name,
DIA_FONT_STYLE_GET_SLANT(style) == DIA_FONT_NORMAL ? CAIRO_FONT_SLANT_NORMAL : CAIRO_FONT_SLANT_ITALIC,
DIA_FONT_STYLE_GET_WEIGHT(style) < DIA_FONT_MEDIUM ? CAIRO_FONT_WEIGHT_NORMAL : CAIRO_FONT_WEIGHT_BOLD);
cairo_set_font_size (renderer->cr, size);
#endif
DIAG_STATE(renderer->cr)
/* for the interactive case we must maintain the font field in the base class */
if (self->is_interactive) {
dia_font_ref(font);
if (self->font)
dia_font_unref(self->font);
self->font = font;
self->font_height = height;
}
}
static void
set_font(DiaRenderer *self, DiaFont *font, real height)
{
DiaPsRenderer *renderer = DIA_PS_RENDERER(self);
gchar h_buf[DTOSTR_BUF_SIZE];
if (font != self->font || height != self->font_height) {
DiaFont *old_font;
fprintf(renderer->file, "/%s-latin1 ff %s scf sf\n",
dia_font_get_psfontname(font),
psrenderer_dtostr(h_buf, (gdouble) height*0.7) );
old_font = self->font;
self->font = font;
dia_font_ref(self->font);
if (old_font != NULL) {
dia_font_unref(old_font);
}
self->font_height = height;
}
}
static DiaObject *
ellipse_create(Point *startpoint,
void *user_data,
Handle **handle1,
Handle **handle2)
{
Ellipse *ellipse;
Element *elem;
DiaObject *obj;
Point p;
int i;
DiaFont *font = NULL;
real font_height;
init_default_values();
ellipse = g_malloc0(sizeof(Ellipse));
elem = &ellipse->element;
obj = &elem->object;
obj->type = &fc_ellipse_type;
obj->ops = &ellipse_ops;
elem->corner = *startpoint;
elem->width = DEFAULT_WIDTH;
elem->height = DEFAULT_HEIGHT;
ellipse->border_width = attributes_get_default_linewidth();
ellipse->border_color = attributes_get_foreground();
ellipse->inner_color = attributes_get_background();
ellipse->show_background = default_properties.show_background;
attributes_get_default_line_style(&ellipse->line_style,&ellipse->dashlength);
ellipse->padding = default_properties.padding;
attributes_get_default_font(&font, &font_height);
p = *startpoint;
p.x += elem->width / 2.0;
p.y += elem->height / 2.0 + font_height / 2;
ellipse->text = new_text("", font, font_height, &p, &ellipse->border_color,
ALIGN_CENTER);
dia_font_unref(font);
/* new default: let the user decide the size? */
ellipse->text_fitting = TEXTFIT_ALWAYS;
element_init(elem, 8, NUM_CONNECTIONS);
for (i=0;i<NUM_CONNECTIONS;i++) {
obj->connections[i] = &ellipse->connections[i];
ellipse->connections[i].object = obj;
ellipse->connections[i].connected = NULL;
ellipse->connections[i].flags = 0;
}
ellipse->connections[16].flags = CP_FLAGS_MAIN;
ellipse_update_data(ellipse, ANCHOR_MIDDLE, ANCHOR_MIDDLE);
*handle1 = NULL;
*handle2 = obj->handles[7];
return &ellipse->element.object;
}
static DiaObject *
flow_create(Point *startpoint,
void *user_data,
Handle **handle1,
Handle **handle2)
{
Flow *flow;
Connection *conn;
DiaObject *obj;
LineBBExtras *extra;
Point p ;
Point n ;
DiaFont *font;
flow = g_malloc0(sizeof(Flow));
conn = &flow->connection;
conn->endpoints[0] = *startpoint;
conn->endpoints[1] = *startpoint;
conn->endpoints[1].x += 1.5;
obj = &conn->object;
extra = &conn->extra_spacing;
obj->type = &flow_type;
obj->ops = &flow_ops;
connection_init(conn, 3, 0);
p = conn->endpoints[1] ;
point_sub( &p, &conn->endpoints[0] ) ;
point_scale( &p, 0.5 ) ;
n.x = p.y ;
n.y = -p.x ;
if ( fabs(n.x) < 1.e-5 && fabs(n.y) < 1.e-5 ) {
n.x = 0. ;
n.y = -1. ;
} else {
point_normalize( &n ) ;
}
point_scale( &n, 0.5*FLOW_FONTHEIGHT ) ;
point_add( &p, &n ) ;
point_add( &p, &conn->endpoints[0] ) ;
flow->textpos = p;
font = dia_font_new_from_style(DIA_FONT_SANS, FLOW_FONTHEIGHT);
flow->text = new_text("", font, FLOW_FONTHEIGHT, &p, &color_black, ALIGN_CENTER);
dia_font_unref(font);
flow->text_handle.id = HANDLE_MOVE_TEXT;
flow->text_handle.type = HANDLE_MINOR_CONTROL;
flow->text_handle.connect_type = HANDLE_NONCONNECTABLE;
flow->text_handle.connected_to = NULL;
flow->text_handle.pos = p;
obj->handles[2] = &flow->text_handle;
extra->start_long =
extra->end_long =
extra->start_trans = FLOW_WIDTH/2.0;
extra->end_trans = MAX(FLOW_WIDTH, FLOW_ARROWLEN) / 2.0;
flow_update_data(flow);
*handle1 = obj->handles[0];
*handle2 = obj->handles[1];
return &flow->connection.object;
}
static DiaObject *
attribute_load(ObjectNode obj_node, int version,DiaContext *ctx)
{
Attribute *attribute;
Element *elem;
DiaObject *obj;
int i;
AttributeNode attr;
attribute = g_malloc0(sizeof(Attribute));
elem = &attribute->element;
obj = &elem->object;
obj->type = &attribute_type;
obj->ops = &attribute_ops;
element_load(elem, obj_node, ctx);
attribute->border_width = 0.1;
attr = object_find_attribute(obj_node, "border_width");
if (attr != NULL)
attribute->border_width = data_real(attribute_first_data(attr), ctx);
attribute->border_color = color_black;
attr = object_find_attribute(obj_node, "border_color");
if (attr != NULL)
data_color(attribute_first_data(attr), &attribute->border_color, ctx);
attribute->inner_color = color_white;
attr = object_find_attribute(obj_node, "inner_color");
if (attr != NULL)
data_color(attribute_first_data(attr), &attribute->inner_color, ctx);
attribute->name = NULL;
attr = object_find_attribute(obj_node, "name");
if (attr != NULL)
attribute->name = data_string(attribute_first_data(attr), ctx);
attr = object_find_attribute(obj_node, "key");
if (attr != NULL)
attribute->key = data_boolean(attribute_first_data(attr), ctx);
attr = object_find_attribute(obj_node, "weak_key");
if (attr != NULL)
attribute->weakkey = data_boolean(attribute_first_data(attr), ctx);
attr = object_find_attribute(obj_node, "derived");
if (attr != NULL)
attribute->derived = data_boolean(attribute_first_data(attr), ctx);
attr = object_find_attribute(obj_node, "multivalued");
if (attr != NULL)
attribute->multivalue = data_boolean(attribute_first_data(attr), ctx);
if (attribute->font != NULL) {
/* This shouldn't happen, but doesn't hurt */
dia_font_unref(attribute->font);
attribute->font = NULL;
}
attr = object_find_attribute (obj_node, "font");
if (attr != NULL)
attribute->font = data_font (attribute_first_data (attr), ctx);
attribute->font_height = FONT_HEIGHT;
attr = object_find_attribute (obj_node, "font_height");
if (attr != NULL)
attribute->font_height = data_real(attribute_first_data(attr), ctx);
element_init(elem, 8, NUM_CONNECTIONS);
for (i=0;i<NUM_CONNECTIONS;i++) {
obj->connections[i] = &attribute->connections[i];
attribute->connections[i].object = obj;
attribute->connections[i].connected = NULL;
}
attribute->connections[8].flags = CP_FLAGS_MAIN;
if (attribute->font == NULL)
attribute->font = dia_font_new_from_style(DIA_FONT_MONOSPACE,
attribute->font_height);
attribute->name_width = dia_font_string_width(attribute->name,
attribute->font,
attribute->font_height);
attribute_update_data(attribute);
for (i=0;i<8;i++)
obj->handles[i]->type = HANDLE_NON_MOVABLE;
return &attribute->element.object;
}
/*!
* \brief Parse the SVG node from a shape file
*
* Fill the ShapeInfo display list with GraphicElement each got from
* a single node within the shape's SVG part.
*
* \extends _ShapeInfo
*/
static void
parse_svg_node(ShapeInfo *info, xmlNodePtr node, xmlNsPtr svg_ns,
DiaSvgStyle *style, const gchar *filename)
{
xmlChar *str;
/* walk SVG node ... */
for (node = node->xmlChildrenNode; node != NULL; node = node->next) {
GraphicElement *el = NULL;
DiaSvgStyle s;
if (xmlIsBlankNode(node)) continue;
if (node->type != XML_ELEMENT_NODE || node->ns != svg_ns)
continue;
dia_svg_style_init (&s, style);
dia_svg_parse_style(node, &s, -1);
if (!xmlStrcmp(node->name, (const xmlChar *)"line")) {
GraphicElementLine *line = g_new0(GraphicElementLine, 1);
el = (GraphicElement *)line;
line->type = GE_LINE;
str = xmlGetProp(node, (const xmlChar *)"x1");
if (str) {
line->p1.x = g_ascii_strtod((gchar *) str, NULL);
xmlFree(str);
}
str = xmlGetProp(node, (const xmlChar *)"y1");
if (str) {
line->p1.y = g_ascii_strtod((gchar *) str, NULL);
xmlFree(str);
}
str = xmlGetProp(node, (const xmlChar *)"x2");
if (str) {
line->p2.x = g_ascii_strtod((gchar *) str, NULL);
xmlFree(str);
}
str = xmlGetProp(node, (const xmlChar *)"y2");
if (str) {
line->p2.y = g_ascii_strtod((gchar *) str, NULL);
xmlFree(str);
}
} else if (!xmlStrcmp(node->name, (const xmlChar *)"polyline")) {
GraphicElementPoly *poly;
GArray *arr = g_array_new(FALSE, FALSE, sizeof(real));
real val, *rarr;
gchar *tmp;
int i;
str = xmlGetProp(node, (const xmlChar *)"points");
tmp = (gchar *) str;
while (tmp[0] != '\0') {
/* skip junk */
while (tmp[0] != '\0' && !g_ascii_isdigit(tmp[0]) && tmp[0]!='.'&&tmp[0]!='-')
tmp++;
if (tmp[0] == '\0') break;
val = g_ascii_strtod(tmp, &tmp);
g_array_append_val(arr, val);
}
xmlFree(str);
val = 0;
if (arr->len % 2 == 1)
g_array_append_val(arr, val);
poly = g_malloc0(sizeof(GraphicElementPoly) + arr->len/2*sizeof(Point));
el = (GraphicElement *)poly;
poly->type = GE_POLYLINE;
poly->npoints = arr->len / 2;
rarr = (real *)arr->data;
for (i = 0; i < poly->npoints; i++) {
poly->points[i].x = rarr[2*i];
poly->points[i].y = rarr[2*i+1];
}
g_array_free(arr, TRUE);
} else if (!xmlStrcmp(node->name, (const xmlChar *)"polygon")) {
GraphicElementPoly *poly;
GArray *arr = g_array_new(FALSE, FALSE, sizeof(real));
real val, *rarr;
char *tmp;
int i;
str = xmlGetProp(node, (const xmlChar *)"points");
tmp = (char *) str;
while (tmp[0] != '\0') {
/* skip junk */
while (tmp[0] != '\0' && !g_ascii_isdigit(tmp[0]) && tmp[0]!='.'&&tmp[0]!='-')
tmp++;
if (tmp[0] == '\0') break;
val = g_ascii_strtod(tmp, &tmp);
g_array_append_val(arr, val);
}
xmlFree(str);
val = 0;
if (arr->len % 2 == 1)
g_array_append_val(arr, val);
poly = g_malloc0(sizeof(GraphicElementPoly) + arr->len/2*sizeof(Point));
el = (GraphicElement *)poly;
poly->type = GE_POLYGON;
poly->npoints = arr->len / 2;
rarr = (real *)arr->data;
for (i = 0; i < poly->npoints; i++) {
poly->points[i].x = rarr[2*i];
poly->points[i].y = rarr[2*i+1];
}
g_array_free(arr, TRUE);
} else if (!xmlStrcmp(node->name, (const xmlChar *)"rect")) {
GraphicElementRect *rect = g_new0(GraphicElementRect, 1);
real corner_radius = 0.0;
el = (GraphicElement *)rect;
rect->type = GE_RECT;
str = xmlGetProp(node, (const xmlChar *)"x");
if (str) {
rect->corner1.x = g_ascii_strtod((gchar *) str, NULL);
xmlFree(str);
} else rect->corner1.x = 0;
str = xmlGetProp(node, (const xmlChar *)"y");
if (str) {
rect->corner1.y = g_ascii_strtod((gchar *) str, NULL);
xmlFree(str);
} else rect->corner1.y = 0;
str = xmlGetProp(node, (const xmlChar *)"width");
if (str) {
rect->corner2.x = rect->corner1.x + g_ascii_strtod((gchar *) str, NULL);
xmlFree(str);
}
str = xmlGetProp(node, (const xmlChar *)"height");
if (str) {
rect->corner2.y = rect->corner1.y + g_ascii_strtod((gchar *) str, NULL);
xmlFree(str);
}
str = xmlGetProp(node, (const xmlChar *)"rx");
if (str) {
corner_radius = g_ascii_strtod((gchar *) str, NULL);
xmlFree(str);
}
str = xmlGetProp(node, (const xmlChar *)"ry");
if (str) {
if(corner_radius != 0.0) {
/* calculate the mean value of rx and ry */
corner_radius = (corner_radius+g_ascii_strtod((gchar *) str, NULL))/2;
} else {
corner_radius = g_ascii_strtod((gchar *) str, NULL);
}
xmlFree(str);
}
rect->corner_radius = corner_radius;
} else if (!xmlStrcmp(node->name, (const xmlChar *)"text")) {
GraphicElementText *text = g_new(GraphicElementText, 1);
el = (GraphicElement *)text;
text->type = GE_TEXT;
text->object = NULL;
str = xmlGetProp(node, (const xmlChar *)"x");
if (str) {
text->anchor.x = g_ascii_strtod((gchar *) str, NULL);
xmlFree(str);
} else text->anchor.x = 0;
str = xmlGetProp(node, (const xmlChar *)"y");
if (str) {
text->anchor.y = g_ascii_strtod((gchar *) str, NULL);
xmlFree(str);
} else text->anchor.y = 0;
str = xmlGetProp(node, (const xmlChar *)"font-size");
if (str) {
text->s.font_height = g_ascii_strtod((gchar *) str, NULL);
xmlFree(str);
} else text->s.font_height = 0.8;
str = xmlNodeGetContent(node);
if (str) {
text->string = g_strdup((gchar *) str);
xmlFree(str);
} else text->string = g_strdup("");
} else if (!xmlStrcmp(node->name, (const xmlChar *)"circle")) {
GraphicElementEllipse *ellipse = g_new0(GraphicElementEllipse, 1);
el = (GraphicElement *)ellipse;
ellipse->type = GE_ELLIPSE;
str = xmlGetProp(node, (const xmlChar *)"cx");
if (str) {
ellipse->center.x = g_ascii_strtod((gchar *) str, NULL);
xmlFree(str);
}
str = xmlGetProp(node, (const xmlChar *)"cy");
if (str) {
ellipse->center.y = g_ascii_strtod((gchar *) str, NULL);
xmlFree(str);
}
str = xmlGetProp(node, (const xmlChar *)"r");
if (str) {
ellipse->width = ellipse->height = 2 * g_ascii_strtod((gchar *) str, NULL);
xmlFree(str);
}
} else if (!xmlStrcmp(node->name, (const xmlChar *)"ellipse")) {
GraphicElementEllipse *ellipse = g_new0(GraphicElementEllipse, 1);
el = (GraphicElement *)ellipse;
ellipse->type = GE_ELLIPSE;
str = xmlGetProp(node, (const xmlChar *)"cx");
if (str) {
ellipse->center.x = g_ascii_strtod((gchar *) str, NULL);
xmlFree(str);
}
str = xmlGetProp(node, (const xmlChar *)"cy");
if (str) {
ellipse->center.y = g_ascii_strtod((gchar *) str, NULL);
xmlFree(str);
}
str = xmlGetProp(node, (const xmlChar *)"rx");
if (str) {
ellipse->width = 2 * g_ascii_strtod((gchar *) str, NULL);
xmlFree(str);
}
str = xmlGetProp(node, (const xmlChar *)"ry");
if (str) {
ellipse->height = 2 * g_ascii_strtod((gchar *) str, NULL);
xmlFree(str);
}
} else if (!xmlStrcmp(node->name, (const xmlChar *)"path")) {
str = xmlGetProp(node, (const xmlChar *)"d");
if (str) {
parse_path(info, (char *) str, &s, filename);
xmlFree(str);
}
} else if (!xmlStrcmp(node->name, (const xmlChar *)"image")) {
GraphicElementImage *image = g_new0(GraphicElementImage, 1);
el = (GraphicElement *)image;
image->type = GE_IMAGE;
str = xmlGetProp(node, (const xmlChar *)"x");
if (str) {
image->topleft.x = g_ascii_strtod((gchar *) str, NULL);
xmlFree(str);
}
str = xmlGetProp(node, (const xmlChar *)"y");
if (str) {
image->topleft.y = g_ascii_strtod((gchar *) str, NULL);
xmlFree(str);
}
str = xmlGetProp(node, (const xmlChar *)"width");
if (str) {
image->width = g_ascii_strtod((gchar *) str, NULL);
xmlFree(str);
}
str = xmlGetProp(node, (const xmlChar *)"height");
if (str) {
image->height = g_ascii_strtod((gchar *) str, NULL);
xmlFree(str);
}
str = xmlGetProp(node, (const xmlChar *)"xlink:href");
if (!str) /* this doesn't look right but it appears to work w/o namespace --hb */
str = xmlGetProp(node, (const xmlChar *)"href");
if (str) {
gchar *imgfn = NULL;
const char* data = strchr((char *)str, ',');
/* first check for inlined data */
if (data) {
GdkPixbuf *pixbuf = pixbuf_decode_base64 (data+1);
if (pixbuf) {
image->image = dia_image_new_from_pixbuf (pixbuf);
g_object_unref (pixbuf);
}
} else {
imgfn = g_filename_from_uri((gchar *) str, NULL, NULL);
if (!imgfn)
/* despite it's name it ensures an absolute filename */
imgfn = custom_get_relative_filename(filename, (gchar *) str);
image->image = dia_image_load(imgfn);
}
if (!image->image)
g_debug("failed to load image file %s", imgfn ? imgfn : "(data:)");
g_free(imgfn);
xmlFree(str);
}
/* w/o the image we would crash later */
if (!image->image)
image->image = dia_image_get_broken();
} else if (!xmlStrcmp(node->name, (const xmlChar *)"g")) {
if (!is_subshape(node)) {
/* add elements from the group element */
parse_svg_node(info, node, svg_ns, &s, filename);
} else {
/* add elements from the group element, but make it a subshape */
GraphicElementSubShape *subshape = g_new0(GraphicElementSubShape, 1);
ShapeInfo* tmpinfo = g_new0(ShapeInfo, 1);
xmlChar *v_anchor_attr = xmlGetProp(node, (const xmlChar*)"v_anchor");
xmlChar *h_anchor_attr = xmlGetProp(node, (const xmlChar*)"h_anchor");
parse_svg_node(tmpinfo, node, svg_ns, &s, filename);
tmpinfo->shape_bounds.top = DBL_MAX;
tmpinfo->shape_bounds.left = DBL_MAX;
tmpinfo->shape_bounds.bottom = -DBL_MAX;
tmpinfo->shape_bounds.right = -DBL_MAX;
update_bounds( tmpinfo );
update_bounds( info );
subshape->half_width = (tmpinfo->shape_bounds.right-tmpinfo->shape_bounds.left) / 2.0;
subshape->half_height = (tmpinfo->shape_bounds.bottom-tmpinfo->shape_bounds.top) / 2.0;
subshape->center.x = tmpinfo->shape_bounds.left + subshape->half_width;
subshape->center.y = tmpinfo->shape_bounds.top + subshape->half_height;
subshape->type = GE_SUBSHAPE;
subshape->display_list = tmpinfo->display_list;
subshape->v_anchor_method = OFFSET_METHOD_FIXED;
subshape->h_anchor_method = OFFSET_METHOD_FIXED;
subshape->default_scale = 0.0;
if (!v_anchor_attr || !strcmp((const char*)v_anchor_attr,"fixed.top"))
subshape->v_anchor_method = OFFSET_METHOD_FIXED;
else if (v_anchor_attr && !strcmp((const char*)v_anchor_attr,"fixed.bottom"))
subshape->v_anchor_method = -OFFSET_METHOD_FIXED;
else if (v_anchor_attr && !strcmp((const char*)v_anchor_attr,"proportional"))
subshape->v_anchor_method = OFFSET_METHOD_PROPORTIONAL;
else
fprintf( stderr, "illegal v_anchor `%s', defaulting to fixed.top\n",
v_anchor_attr );
if (!h_anchor_attr || !strcmp((const char*)h_anchor_attr,"fixed.left"))
subshape->h_anchor_method = OFFSET_METHOD_FIXED;
else if (h_anchor_attr && !strcmp((const char*)h_anchor_attr,"fixed.right"))
subshape->h_anchor_method = -OFFSET_METHOD_FIXED;
else if (h_anchor_attr && !strcmp((const char*)h_anchor_attr,"proportional"))
subshape->h_anchor_method = OFFSET_METHOD_PROPORTIONAL;
else
fprintf( stderr, "illegal h_anchor `%s', defaulting to fixed.left\n",
h_anchor_attr );
info->subshapes = g_list_append(info->subshapes, subshape);
/* gfree( tmpinfo );*/
xmlFree(v_anchor_attr);
xmlFree(h_anchor_attr);
el = (GraphicElement *)subshape;
}
}
if (el) {
el->any.s = s;
if (el->any.s.font)
el->any.s.font = g_object_ref(s.font);
info->display_list = g_list_append(info->display_list, el);
}
if (s.font)
dia_font_unref (s.font);
}
}