static Object *
implements_load(ObjectNode obj_node, int version, const char *filename)
{
Implements *implements;
AttributeNode attr;
Connection *conn;
Object *obj;
if (implements_font == NULL)
implements_font = font_getfont("Courier");
implements = g_malloc(sizeof(Implements));
conn = &implements->connection;
obj = (Object *) implements;
obj->type = &implements_type;
obj->ops = &implements_ops;
connection_load(conn, obj_node);
connection_init(conn, 4, 0);
implements->circle_diameter = 1.0;
attr = object_find_attribute(obj_node, "diameter");
if (attr != NULL)
implements->circle_diameter = data_real(attribute_first_data(attr));
implements->text = NULL;
attr = object_find_attribute(obj_node, "text");
if (attr != NULL)
implements->text = data_string(attribute_first_data(attr));
attr = object_find_attribute(obj_node, "text_pos");
if (attr != NULL)
data_point(attribute_first_data(attr), &implements->text_pos);
implements->text_width =
font_string_width(implements->text, implements_font,
IMPLEMENTS_FONTHEIGHT);
implements->text_handle.id = HANDLE_MOVE_TEXT;
implements->text_handle.type = HANDLE_MINOR_CONTROL;
implements->text_handle.connect_type = HANDLE_NONCONNECTABLE;
implements->text_handle.connected_to = NULL;
obj->handles[2] = &implements->text_handle;
implements->circle_handle.id = HANDLE_CIRCLE_SIZE;
implements->circle_handle.type = HANDLE_MINOR_CONTROL;
implements->circle_handle.connect_type = HANDLE_NONCONNECTABLE;
implements->circle_handle.connected_to = NULL;
obj->handles[3] = &implements->circle_handle;
implements->properties_dialog = NULL;
implements_update_data(implements);
return (Object *)implements;
}
static DiaObject *
bus_load(ObjectNode obj_node, int version, const char *filename)
{
Bus *bus;
Connection *conn;
LineBBExtras *extra;
DiaObject *obj;
AttributeNode attr;
DataNode data;
int i;
bus = g_malloc0(sizeof(Bus));
conn = &bus->connection;
obj = &conn->object;
extra = &conn->extra_spacing;
obj->type = &bus_type;
obj->ops = &bus_ops;
connection_load(conn, obj_node);
attr = object_find_attribute(obj_node, "bus_handles");
bus->num_handles = 0;
if (attr != NULL)
bus->num_handles = attribute_num_data(attr);
connection_init(conn, 2 + bus->num_handles, 0);
data = attribute_first_data(attr);
bus->handles = g_malloc(sizeof(Handle *)*bus->num_handles);
bus->parallel_points = g_malloc(sizeof(Point)*bus->num_handles);
for (i=0;i<bus->num_handles;i++) {
bus->handles[i] = g_new0(Handle,1);
bus->handles[i]->id = HANDLE_BUS;
bus->handles[i]->type = HANDLE_MINOR_CONTROL;
bus->handles[i]->connect_type = HANDLE_CONNECTABLE_NOBREAK;
bus->handles[i]->connected_to = NULL;
data_point(data, &bus->handles[i]->pos);
obj->handles[2+i] = bus->handles[i];
data = data_next(data);
}
bus->line_color = color_black;
attr = object_find_attribute(obj_node, "line_color");
if (attr != NULL)
data_color(attribute_first_data(attr), &bus->line_color);
extra->start_trans =
extra->end_trans =
extra->start_long =
extra->end_long = LINE_WIDTH/2.0;
bus_update_data(bus);
return &bus->connection.object;
}
/* *NOT A CALLBACK* --> Must be called by inherited class (see aadldata.c) */
void aadlbox_load(ObjectNode obj_node, int version, DiaContext *ctx,
Aadlbox *aadlbox)
{
AttributeNode attr;
DataNode composite, data;
Aadl_type type;
gchar *declaration;
Aadlport *port;
ConnectionPoint *connection;
int i, num;
attr = object_find_attribute(obj_node, "aadlbox_ports");
composite = attribute_first_data(attr);
num = attribute_num_data(attr);
for (i=0; i<num; i++) {
Point p;
attr = composite_find_attribute(composite, "point");
data_point(attribute_first_data(attr), &p, ctx);
attr = composite_find_attribute(composite, "port_type");
type = data_enum(attribute_first_data(attr), ctx);
attr = composite_find_attribute(composite, "port_declaration");
declaration = data_string(attribute_first_data(attr), ctx);
port = g_new0(Aadlport,1);
port->handle = g_new0(Handle,1);
port->type = type;
port->declaration = declaration;
aadlbox_add_port(aadlbox, &p, port);
composite = data_next(composite);
}
attr = object_find_attribute(obj_node, "aadlbox_connections");
num = attribute_num_data(attr);
data = attribute_first_data(attr);
for (i=0; i<num; i++) {
Point p;
data_point(data, &p, ctx);
connection = g_new0(ConnectionPoint,1);
aadlbox_add_connection(aadlbox, &p, connection);
data = data_next(data);
}
object_load_props(&aadlbox->element.object,obj_node, ctx);
}
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 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;
}
static DiaObject *
function_load(ObjectNode obj_node, int version, const char *filename)
{
Function *pkg;
AttributeNode attr;
Element *elem;
DiaObject *obj;
int i;
pkg = g_malloc0(sizeof(Function));
elem = &pkg->element;
obj = &elem->object;
obj->type = &function_type;
obj->ops = &function_ops;
element_load(elem, obj_node);
pkg->text = NULL;
attr = object_find_attribute(obj_node, "text");
if (attr != NULL)
pkg->text = data_text(attribute_first_data(attr));
attr = object_find_attribute(obj_node, "is_wish");
if (attr != NULL)
pkg->is_wish = data_boolean(attribute_first_data(attr));
else
pkg->is_wish = FALSE;
attr = object_find_attribute(obj_node, "is_user");
if (attr != NULL)
pkg->is_user = data_boolean(attribute_first_data(attr));
else
pkg->is_user = FALSE;
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 = pkg->text ? pkg->text->height : FUNCTION_FONTHEIGHT / FUNCTION_BORDERWIDTH_SCALE/2.0;
function_update_data(pkg);
for (i=0;i<8;i++) {
obj->handles[i]->type = HANDLE_NON_MOVABLE;
}
return &pkg->element.object;
}
static Object *
message_load(ObjectNode obj_node, int version, const char *filename)
{
Message *message;
AttributeNode attr;
Connection *conn;
Object *obj;
if (message_font == NULL)
message_font = font_getfont("Helvetica");
message = g_malloc(sizeof(Message));
conn = &message->connection;
obj = (Object *) message;
obj->type = &message_type;
obj->ops = &message_ops;
connection_load(conn, obj_node);
connection_init(conn, 3, 0);
message->text = NULL;
attr = object_find_attribute(obj_node, "text");
if (attr != NULL)
message->text = data_string(attribute_first_data(attr));
attr = object_find_attribute(obj_node, "text_pos");
if (attr != NULL)
data_point(attribute_first_data(attr), &message->text_pos);
attr = object_find_attribute(obj_node, "type");
if (attr != NULL)
message->type = (MessageType)data_int(attribute_first_data(attr));
if (message->text)
message->text_width =
font_string_width(message->text, message_font, MESSAGE_FONTHEIGHT);
else
message->text_width = 0;
message->text_handle.id = HANDLE_MOVE_TEXT;
message->text_handle.type = HANDLE_MINOR_CONTROL;
message->text_handle.connect_type = HANDLE_NONCONNECTABLE;
message->text_handle.connected_to = NULL;
obj->handles[2] = &message->text_handle;
message_update_data(message);
return (Object *)message;
}
Object *render_object_load(ObjectNode obj_node,
const RenderObjectDescriptor *desc)
{
RenderObject *rend_obj;
Element *elem;
Object *obj;
AttributeNode attr;
int i;
Point startpoint = {0.0, 0.0};
rend_obj = g_malloc(sizeof(RenderObject));
elem = &rend_obj->element;
obj = &elem->object;
obj->type = desc->obj_type;
obj->ops = &rendobj_ops;
element_load(elem, obj_node);
rend_obj->desc = desc;
rend_obj->magnify = 1.0;
attr = object_find_attribute(obj_node, "magnify");
if (attr != NULL)
rend_obj->magnify = data_real( attribute_first_data(attr) );
if (desc->use_text) {
attr = object_find_attribute(obj_node, "text");
if (attr != NULL)
rend_obj->text = data_text( attribute_first_data(attr) );
else
rend_obj->text = new_text("", font_getfont("Courier"), 1.0,
&startpoint, &color_black, ALIGN_CENTER);
}
element_init(elem, 8, desc->num_connection_points);
rend_obj->connections = g_new(ConnectionPoint,
desc->num_connection_points);
for (i=0;i<desc->num_connection_points;i++) {
obj->connections[i] = &rend_obj->connections[i];
rend_obj->connections[i].object = obj;
rend_obj->connections[i].connected = NULL;
}
rendobj_update_data(rend_obj);
return (Object *)rend_obj;
}
static Object *
generalization_load(ObjectNode obj_node, int version,
const char *filename)
{
Generalization *genlz;
AttributeNode attr;
OrthConn *orth;
Object *obj;
if (genlz_font == NULL) {
genlz_font = font_getfont("Courier");
}
genlz = g_new(Generalization, 1);
orth = &genlz->orth;
obj = (Object *) genlz;
obj->type = &generalization_type;
obj->ops = &generalization_ops;
orthconn_load(orth, obj_node);
genlz->name = NULL;
attr = object_find_attribute(obj_node, "name");
if (attr != NULL)
genlz->name = data_string(attribute_first_data(attr));
genlz->stereotype = NULL;
attr = object_find_attribute(obj_node, "stereotype");
if (attr != NULL)
genlz->stereotype = data_string(attribute_first_data(attr));
genlz->text_width = 0.0;
genlz->properties_dialog = NULL;
if (genlz->name != NULL) {
genlz->text_width =
font_string_width(genlz->name, genlz_font, GENERALIZATION_FONTHEIGHT);
}
if (genlz->stereotype != NULL) {
genlz->text_width = MAX(genlz->text_width,
font_string_width(genlz->stereotype, genlz_font, GENERALIZATION_FONTHEIGHT));
}
generalization_update_data(genlz);
return (Object *)genlz;
}
static DiaObject *
participation_load(ObjectNode obj_node, int version,DiaContext *ctx)
{
AttributeNode attr;
Participation *participation;
OrthConn *orth;
DiaObject *obj;
participation = g_new0(Participation, 1);
orth = &participation->orth;
obj = &orth->object;
obj->type = &participation_type;
obj->ops = &participation_ops;
orthconn_load(orth, obj_node, ctx);
attr = object_find_attribute(obj_node, "total");
if (attr != NULL)
participation->total = data_boolean(attribute_first_data(attr), ctx);
participation_update_data(participation);
return &participation->orth.object;
}
gboolean
prop_list_load(GPtrArray *props, DataNode data_node, DiaContext *ctx)
{
guint i;
gboolean ret = TRUE;
for (i = 0; i < props->len; i++) {
Property *prop = g_ptr_array_index(props,i);
AttributeNode attr = object_find_attribute(data_node, prop->descr->name);
DataNode data = attr ? attribute_first_data(attr) : NULL;
if ((!attr || !data) && prop->descr->flags & PROP_FLAG_OPTIONAL) {
prop->experience |= PXP_NOTSET;
continue;
}
if ((!attr) || (!data)) {
dia_context_add_message(ctx,
_("No attribute '%s' (%p) or no data (%p) in this attribute"),
prop->descr->name,attr,data);
prop->experience |= PXP_NOTSET;
ret = FALSE;
continue;
}
prop->ops->load(prop,attr,data,ctx);
}
return ret;
}
static Object *
participation_load(ObjectNode obj_node, int version, const char *filename)
{
AttributeNode attr;
Participation *participation;
OrthConn *orth;
Object *obj;
participation = g_new(Participation, 1);
orth = &participation->orth;
obj = (Object *) participation;
obj->type = &participation_type;
obj->ops = &participation_ops;
orthconn_load(orth, obj_node);
attr = object_find_attribute(obj_node, "total");
if (attr != NULL)
participation->total = data_boolean(attribute_first_data(attr));
participation->properties_dialog = NULL;
participation_update_data(participation);
return (Object *)participation;
}
static Object *
constraint_load(ObjectNode obj_node, int version, const char *filename)
{
Constraint *constraint;
AttributeNode attr;
Connection *conn;
Object *obj;
if (constraint_font == NULL)
constraint_font = font_getfont("Courier");
constraint = g_malloc(sizeof(Constraint));
conn = &constraint->connection;
obj = (Object *) constraint;
obj->type = &constraint_type;
obj->ops = &constraint_ops;
connection_load(conn, obj_node);
connection_init(conn, 3, 0);
constraint->text = NULL;
attr = object_find_attribute(obj_node, "text");
if (attr != NULL)
constraint->text = data_string(attribute_first_data(attr));
attr = object_find_attribute(obj_node, "text_pos");
if (attr != NULL)
data_point(attribute_first_data(attr), &constraint->text_pos);
constraint->text_width =
font_string_width(constraint->text, constraint_font, CONSTRAINT_FONTHEIGHT);
constraint->text_handle.id = HANDLE_MOVE_TEXT;
constraint->text_handle.type = HANDLE_MINOR_CONTROL;
constraint->text_handle.connect_type = HANDLE_NONCONNECTABLE;
constraint->text_handle.connected_to = NULL;
obj->handles[2] = &constraint->text_handle;
constraint->properties_dialog = NULL;
constraint_update_data(constraint);
return (Object *)constraint;
}
static DiaObject *
beziergon_load(ObjectNode obj_node, int version, DiaContext *ctx)
{
Beziergon *beziergon;
BezierShape *bez;
DiaObject *obj;
AttributeNode attr;
beziergon = g_malloc0(sizeof(Beziergon));
bez = &beziergon->bezier;
obj = &bez->object;
obj->type = &beziergon_type;
obj->ops = &beziergon_ops;
beziershape_load(bez, obj_node, ctx);
beziergon->line_color = color_black;
attr = object_find_attribute(obj_node, "line_color");
if (attr != NULL)
data_color(attribute_first_data(attr), &beziergon->line_color, ctx);
beziergon->line_width = 0.1;
attr = object_find_attribute(obj_node, PROP_STDNAME_LINE_WIDTH);
if (attr != NULL)
beziergon->line_width = data_real(attribute_first_data(attr), ctx);
beziergon->inner_color = color_white;
attr = object_find_attribute(obj_node, "inner_color");
if (attr != NULL)
data_color(attribute_first_data(attr), &beziergon->inner_color, ctx);
beziergon->show_background = TRUE;
attr = object_find_attribute(obj_node, "show_background");
if (attr != NULL)
beziergon->show_background = data_boolean(attribute_first_data(attr), ctx);
beziergon->line_style = LINESTYLE_SOLID;
attr = object_find_attribute(obj_node, "line_style");
if (attr != NULL)
beziergon->line_style = data_enum(attribute_first_data(attr), ctx);
beziergon->line_join = LINEJOIN_MITER;
attr = object_find_attribute(obj_node, "line_join");
if (attr != NULL)
beziergon->line_join = data_enum(attribute_first_data(attr), ctx);
beziergon->dashlength = DEFAULT_LINESTYLE_DASHLEN;
attr = object_find_attribute(obj_node, "dashlength");
if (attr != NULL)
beziergon->dashlength = data_real(attribute_first_data(attr), ctx);
beziergon_update_data(beziergon);
return &beziergon->bezier.object;
}
static Object *
state_load(ObjectNode obj_node, int version, const char *filename)
{
State *state;
Element *elem;
Object *obj;
int i;
AttributeNode attr;
state = g_malloc(sizeof(State));
elem = &state->element;
obj = (Object *) state;
obj->type = &state_type;
obj->ops = &state_ops;
element_load(elem, obj_node);
attr = object_find_attribute(obj_node, "text");
if (attr != NULL)
state->text = data_text(attribute_first_data(attr));
attr = object_find_attribute(obj_node, "type");
if (attr != NULL)
state->state_type = data_int(attribute_first_data(attr));
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;
}
state_update_data(state);
for (i=0;i<8;i++) {
obj->handles[i]->type = HANDLE_NON_MOVABLE;
}
return (Object *)state;
}
static DiaObject *
wanlink_load(ObjectNode obj_node, int version,DiaContext *ctx)
{
WanLink *wanlink;
Connection *conn;
DiaObject *obj;
AttributeNode attr;
DataNode data;
wanlink = g_malloc0(sizeof(WanLink));
conn = &wanlink->connection;
obj = (DiaObject *) wanlink;
obj->type = &wanlink_type;
obj->ops = &wanlink_ops;
connection_load(conn, obj_node, ctx);
connection_init(conn, 2, 0);
attr = object_find_attribute(obj_node, "width");
if (attr != NULL) {
data = attribute_first_data(attr);
wanlink->width = data_real(data, ctx);
}
wanlink->line_color = color_black;
attr = object_find_attribute(obj_node, "line_color");
if (attr != NULL)
data_color(attribute_first_data(attr), &wanlink->line_color, ctx);
/* both colors where black at the time this was hardcoded ... */
wanlink->fill_color = color_black;
attr = object_find_attribute(obj_node, "fill_color");
if (attr != NULL)
data_color(attribute_first_data(attr), &wanlink->fill_color, ctx);
wanlink_update_data (wanlink);
return obj;
}
static DiaObject *
dependency_load(ObjectNode obj_node, int version, const char *filename)
{
DiaObject *obj = object_load_using_properties(&dependency_type,
obj_node,version,filename);
if (version == 0) {
AttributeNode attr;
/* In old objects with no autorouting, set it to false. */
attr = object_find_attribute(obj_node, "autorouting");
if (attr == NULL)
((OrthConn*)obj)->autorouting = FALSE;
}
return obj;
}
static DiaObject *
compfeat_load(ObjectNode obj_node, int version,DiaContext *ctx)
{
DiaObject *obj = object_load_using_properties(&compfeat_type,
obj_node,version,ctx);
if (version == 0) {
AttributeNode attr;
/* In old objects with no autorouting, set it to false. */
attr = object_find_attribute(obj_node, "autorouting");
if (attr == NULL)
((OrthConn*)obj)->autorouting = FALSE;
}
return obj;
}
static DiaObject *
largepackage_load(ObjectNode obj_node, int version, const char *filename)
{
DiaObject *obj = object_load_using_properties(&largepackage_type,
obj_node,version,filename);
AttributeNode attr;
/* For compatibility with previous dia files. If no line_width, use
* LARGEPACKAGE_BORDERWIDTH, that was the previous line width.
*/
attr = object_find_attribute(obj_node, PROP_STDNAME_LINE_WIDTH);
if (attr == NULL)
((LargePackage*)obj)->line_width = LARGEPACKAGE_BORDERWIDTH;
return obj;
}
static DiaObject *
usecase_load(ObjectNode obj_node, int version,DiaContext *ctx)
{
DiaObject *obj = object_load_using_properties(&usecase_type,
obj_node,version,ctx);
AttributeNode attr;
/* For compatibility with previous dia files. If no line_width, use
* USECASE_LINEWIDTH, that was the previous line width.
*/
attr = object_find_attribute(obj_node, PROP_STDNAME_LINE_WIDTH);
if (attr == NULL)
((Usecase*)obj)->line_width = USECASE_LINEWIDTH;
return obj;
}
void
polyconn_load(PolyConn *poly, ObjectNode obj_node, DiaContext *ctx) /* NOTE: Does object_init() */
{
int i;
AttributeNode attr;
DataNode data;
DiaObject *obj = &poly->object;
object_load(obj, obj_node, ctx);
attr = object_find_attribute(obj_node, "poly_points");
if (attr != NULL)
poly->numpoints = attribute_num_data(attr);
else
poly->numpoints = 0;
object_init(obj, poly->numpoints, 0);
data = attribute_first_data(attr);
poly->points = g_malloc(poly->numpoints*sizeof(Point));
for (i=0;i<poly->numpoints;i++) {
data_point(data, &poly->points[i], ctx);
data = data_next(data);
}
obj->handles[0] = g_malloc(sizeof(Handle));
obj->handles[0]->connect_type = HANDLE_CONNECTABLE;
obj->handles[0]->connected_to = NULL;
obj->handles[0]->type = HANDLE_MAJOR_CONTROL;
obj->handles[0]->id = HANDLE_MOVE_STARTPOINT;
obj->handles[poly->numpoints-1] = g_malloc(sizeof(Handle));
obj->handles[poly->numpoints-1]->connect_type = HANDLE_CONNECTABLE;
obj->handles[poly->numpoints-1]->connected_to = NULL;
obj->handles[poly->numpoints-1]->type = HANDLE_MAJOR_CONTROL;
obj->handles[poly->numpoints-1]->id = HANDLE_MOVE_ENDPOINT;
for (i=1;i<poly->numpoints-1;i++) {
obj->handles[i] = g_malloc(sizeof(Handle));
setup_handle(obj->handles[i], PC_HANDLE_CORNER);
}
polyconn_update_data(poly);
}
static DiaObject *transition_load(ObjectNode obj_node, int version,DiaContext *ctx)
{
DiaObject *obj = object_load_using_properties(¨_transition_type,
obj_node,version,ctx);
if (version == 0) {
AttributeNode attr;
/* In old objects with no autorouting, set it to false. */
attr = object_find_attribute(obj_node, "autorouting");
if (attr == NULL)
((OrthConn*)obj)->autorouting = FALSE;
}
if (version < 2) {
/* Versions prior to 2 have the arrowheads inverted */
((Transition*)obj)->direction_inverted = TRUE;
}
return obj;
}
ConnPointLine *
connpointline_load(DiaObject *obj,ObjectNode obj_node,
const gchar *name, int default_nc,int *realconncount)
{
ConnPointLine *cpl;
int nc = default_nc;
AttributeNode attr;
attr = object_find_attribute(obj_node, name);
if (attr != NULL)
nc = data_int(attribute_first_data(attr));
cpl = connpointline_create(obj,nc);
if (realconncount) (*realconncount) += cpl->num_connections;
return cpl;
/* NOT this !
return cpl_inplacecreate(obj,
load_int(obj_node,name,default_nc),
realconncount);
*/
}
static Object *
smallpackage_load(ObjectNode obj_node, int version, const char *filename)
{
SmallPackage *pkg;
AttributeNode attr;
Element *elem;
Object *obj;
int i;
pkg = g_malloc(sizeof(SmallPackage));
elem = &pkg->element;
obj = (Object *) pkg;
obj->type = &smallpackage_type;
obj->ops = &smallpackage_ops;
element_load(elem, obj_node);
pkg->text = NULL;
attr = object_find_attribute(obj_node, "text");
if (attr != NULL)
pkg->text = data_text(attribute_first_data(attr));
element_init(elem, 8, 8);
for (i=0;i<8;i++) {
obj->connections[i] = &pkg->connections[i];
pkg->connections[i].object = obj;
pkg->connections[i].connected = NULL;
}
smallpackage_update_data(pkg);
for (i=0;i<8;i++) {
obj->handles[i]->type = HANDLE_NON_MOVABLE;
}
return (Object *) pkg;
}
Boolequation *
load_boolequation(ObjectNode obj_node,
const gchar *attrname,
const gchar *defaultvalue,
DiaFont *font,
real fontheight, Color *color)
{
gchar *value = NULL;
Boolequation *booleq;
AttributeNode attr;
booleq = boolequation_create(NULL,font,fontheight,color);
attr = object_find_attribute(obj_node,attrname);
if (attr)
value = data_string(attribute_first_data(attr));
else if (defaultvalue)
value = g_strdup (defaultvalue);
if (value)
boolequation_set_value(booleq,value);
g_free(value);
return booleq;
}
static DiaObject *
box_load(ObjectNode obj_node, int version, DiaContext *ctx)
{
Box *box;
Element *elem;
DiaObject *obj;
int i;
AttributeNode attr;
box = g_malloc0(sizeof(Box));
elem = &box->element;
obj = &elem->object;
obj->type = &box_type;
obj->ops = &box_ops;
element_load(elem, obj_node, ctx);
box->border_width = 0.1;
attr = object_find_attribute(obj_node, "border_width");
if (attr != NULL)
box->border_width = data_real(attribute_first_data(attr), ctx);
box->border_color = color_black;
attr = object_find_attribute(obj_node, "border_color");
if (attr != NULL)
data_color(attribute_first_data(attr), &box->border_color, ctx);
box->inner_color = color_white;
attr = object_find_attribute(obj_node, "inner_color");
if (attr != NULL)
data_color(attribute_first_data(attr), &box->inner_color, ctx);
box->show_background = TRUE;
attr = object_find_attribute(obj_node, "show_background");
if (attr != NULL)
box->show_background = data_boolean(attribute_first_data(attr), ctx);
box->line_style = LINESTYLE_SOLID;
attr = object_find_attribute(obj_node, "line_style");
if (attr != NULL)
box->line_style = data_enum(attribute_first_data(attr), ctx);
box->dashlength = DEFAULT_LINESTYLE_DASHLEN;
attr = object_find_attribute(obj_node, "dashlength");
if (attr != NULL)
box->dashlength = data_real(attribute_first_data(attr), ctx);
box->line_join = LINEJOIN_MITER;
attr = object_find_attribute(obj_node, "line_join");
if (attr != NULL)
box->line_join = data_enum(attribute_first_data(attr), ctx);
box->corner_radius = 0.0;
attr = object_find_attribute(obj_node, "corner_radius");
if (attr != NULL)
box->corner_radius = data_real(attribute_first_data(attr), ctx);
box->aspect = FREE_ASPECT;
attr = object_find_attribute(obj_node, "aspect");
if (attr != NULL)
box->aspect = data_enum(attribute_first_data(attr), ctx);
element_init(elem, 8, NUM_CONNECTIONS);
for (i=0;i<NUM_CONNECTIONS;i++) {
obj->connections[i] = &box->connections[i];
box->connections[i].object = obj;
box->connections[i].connected = NULL;
}
box->connections[8].flags = CP_FLAGS_MAIN;
box_update_data(box);
return &box->element.object;
}
static DiaObject *
zigzagline_load(ObjectNode obj_node, int version, DiaContext *ctx)
{
Zigzagline *zigzagline;
OrthConn *orth;
DiaObject *obj;
AttributeNode attr;
zigzagline = g_malloc0(sizeof(Zigzagline));
orth = &zigzagline->orth;
obj = &orth->object;
obj->type = &zigzagline_type;
obj->ops = &zigzagline_ops;
orthconn_load(orth, obj_node, ctx);
zigzagline->line_color = color_black;
attr = object_find_attribute(obj_node, "line_color");
if (attr != NULL)
data_color(attribute_first_data(attr), &zigzagline->line_color, ctx);
zigzagline->line_width = 0.1;
attr = object_find_attribute(obj_node, PROP_STDNAME_LINE_WIDTH);
if (attr != NULL)
zigzagline->line_width = data_real(attribute_first_data(attr), ctx);
zigzagline->line_style = LINESTYLE_SOLID;
attr = object_find_attribute(obj_node, "line_style");
if (attr != NULL)
zigzagline->line_style = data_enum(attribute_first_data(attr), ctx);
zigzagline->line_join = LINEJOIN_MITER;
attr = object_find_attribute(obj_node, "line_join");
if (attr != NULL)
zigzagline->line_join = data_enum(attribute_first_data(attr), ctx);
zigzagline->line_caps = LINECAPS_BUTT;
attr = object_find_attribute(obj_node, "line_caps");
if (attr != NULL)
zigzagline->line_caps = data_enum(attribute_first_data(attr), ctx);
load_arrow(obj_node, &zigzagline->start_arrow, "start_arrow",
"start_arrow_length", "start_arrow_width", ctx);
load_arrow(obj_node, &zigzagline->end_arrow, "end_arrow",
"end_arrow_length", "end_arrow_width", ctx);
zigzagline->dashlength = DEFAULT_LINESTYLE_DASHLEN;
attr = object_find_attribute(obj_node, "dashlength");
if (attr != NULL)
zigzagline->dashlength = data_real(attribute_first_data(attr), ctx);
zigzagline->corner_radius = 0.0;
attr = object_find_attribute(obj_node, "corner_radius");
if (attr != NULL)
zigzagline->corner_radius = data_real(attribute_first_data(attr), ctx);
zigzagline_update_data(zigzagline);
return &zigzagline->orth.object;
}
static DiaObject *
ellipse_load(ObjectNode obj_node, int version,DiaContext *ctx)
{
Ellipse *ellipse;
Element *elem;
DiaObject *obj;
int i;
AttributeNode attr;
ellipse = g_malloc0(sizeof(Ellipse));
elem = &ellipse->element;
obj = &elem->object;
obj->type = &fc_ellipse_type;
obj->ops = &ellipse_ops;
element_load(elem, obj_node, ctx);
ellipse->border_width = 0.1;
attr = object_find_attribute(obj_node, "border_width");
if (attr != NULL)
ellipse->border_width = data_real(attribute_first_data(attr), ctx);
ellipse->border_color = color_black;
attr = object_find_attribute(obj_node, "border_color");
if (attr != NULL)
data_color(attribute_first_data(attr), &ellipse->border_color, ctx);
ellipse->inner_color = color_white;
attr = object_find_attribute(obj_node, "inner_color");
if (attr != NULL)
data_color(attribute_first_data(attr), &ellipse->inner_color, ctx);
ellipse->show_background = TRUE;
attr = object_find_attribute(obj_node, "show_background");
if (attr != NULL)
ellipse->show_background = data_boolean( attribute_first_data(attr), ctx);
ellipse->line_style = LINESTYLE_SOLID;
attr = object_find_attribute(obj_node, "line_style");
if (attr != NULL)
ellipse->line_style = data_enum(attribute_first_data(attr), ctx);
ellipse->dashlength = DEFAULT_LINESTYLE_DASHLEN;
attr = object_find_attribute(obj_node, "dashlength");
if (attr != NULL)
ellipse->dashlength = data_real(attribute_first_data(attr), ctx);
ellipse->padding = default_properties.padding;
attr = object_find_attribute(obj_node, "padding");
if (attr != NULL)
ellipse->padding = data_real(attribute_first_data(attr), ctx);
ellipse->text = NULL;
attr = object_find_attribute(obj_node, "text");
if (attr != NULL)
ellipse->text = data_text(attribute_first_data(attr), ctx);
else
ellipse->text = new_text_default(&obj->position, &ellipse->border_color, ALIGN_CENTER);
/* old default: only growth, manual shrink */
ellipse->text_fitting = TEXTFIT_WHEN_NEEDED;
attr = object_find_attribute(obj_node, PROP_STDNAME_TEXT_FITTING);
if (attr != NULL)
ellipse->text_fitting = data_enum(attribute_first_data(attr), ctx);
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);
return &ellipse->element.object;
}
static DiaObject *
image_load(ObjectNode obj_node, int version, const char *filename)
{
EImage *image;
Element *elem;
DiaObject *obj;
int i;
AttributeNode attr;
char *diafile_dir;
Diagram *dia;
GList *list;
image = g_malloc0(sizeof(EImage));
elem = &image->element;
obj = &elem->object;
obj->type = &eimage_type;
obj->ops = &eimage_ops;
element_load(elem, obj_node);
image->border_width = 0.1;
attr = object_find_attribute(obj_node, "border_width");
if (attr != NULL)
image->border_width = data_real( attribute_first_data(attr) );
image->border_color = color_black;
attr = object_find_attribute(obj_node, "border_color");
if (attr != NULL)
data_color(attribute_first_data(attr), &image->border_color);
image->line_style = LINESTYLE_SOLID;
attr = object_find_attribute(obj_node, "line_style");
if (attr != NULL)
image->line_style = data_enum( attribute_first_data(attr) );
image->dashlength = DEFAULT_LINESTYLE_DASHLEN;
attr = object_find_attribute(obj_node, "dashlength");
if (attr != NULL)
image->dashlength = data_real(attribute_first_data(attr));
image->draw_border = TRUE;
attr = object_find_attribute(obj_node, "draw_border");
if (attr != NULL)
image->draw_border = data_boolean( attribute_first_data(attr) );
image->keep_aspect = TRUE;
attr = object_find_attribute(obj_node, "keep_aspect");
if (attr != NULL)
image->keep_aspect = data_boolean( attribute_first_data(attr) );
image->keep_orig_aspect = TRUE;
attr = object_find_attribute(obj_node, "keep_orig_aspect");
if (attr != NULL)
image->keep_orig_aspect = data_boolean( attribute_first_data(attr) );
attr = object_find_attribute(obj_node, "file");
if (attr != NULL) {
image->file = data_filename( attribute_first_data(attr) );
} else {
image->file = g_strdup("");
}
attr = object_find_attribute(obj_node, "embed_id");
if (attr) {
image->embed_id =
dtree_conv_longname_from_xml(data_string(attribute_first_data(attr)));
} else {
image->embed_id = get_default_embed_id("embed_image");
}
register_embed_id(image->embed_id);
element_init(elem, 8, NUM_CONNECTIONS);
for (i=0;i<NUM_CONNECTIONS;i++) {
obj->connections[i] = &image->connections[i];
image->connections[i].object = obj;
image->connections[i].connected = NULL;
}
image->connections[8].flags = CP_FLAGS_MAIN;
image->image = NULL;
if (strcmp(image->file, "")!=0) {
diafile_dir = get_directory(filename);
if (g_path_is_absolute(image->file)) { /* Absolute pathname */
image->image = dia_image_load(image->file);
if (image->image == NULL) {
/* Not found as abs path, try in same dir as diagram. */
char *temp_string;
const char *image_file_name = image->file;
const char *psep;
psep = strrchr(image->file, G_DIR_SEPARATOR);
/* try the other G_OS as well */
if (!psep)
psep = strrchr(image->file, G_DIR_SEPARATOR == '/' ? '\\' : '/');
if (psep)
image_file_name = psep + 1;
temp_string = g_build_filename(diafile_dir, image_file_name, NULL);
image->image = dia_image_load(temp_string);
if (image->image != NULL) {
/* Found file in same dir as diagram. */
message_warning(_("The image file '%s' was not found in that directory.\n"
"Using the file '%s' instead\n"), image->file, temp_string);
g_free(image->file);
image->file = temp_string;
} else {
g_free(temp_string);
image->image = dia_image_load((char *)image_file_name);
if (image->image != NULL) {
char *tmp;
/* Found file in current dir. */
message_warning(_("The image file '%s' was not found in that directory.\n"
"Using the file '%s' instead\n"), image->file, image_file_name);
tmp = image->file;
image->file = g_strdup(image_file_name);
g_free(tmp);
} else {
message_warning(_("The image file '%s' was not found.\n"),
image_file_name);
}
}
}
} else { /* Relative pathname: */
char *temp_string;
temp_string = g_build_filename (diafile_dir, image->file, NULL);
image->image = dia_image_load(temp_string);
if (image->image != NULL) {
/* Found file in same dir as diagram. */
g_free(image->file);
image->file = temp_string;
} else {
g_free(temp_string);
image->image = dia_image_load(image->file);
if (image->image == NULL) {
/* Didn't find file in current dir. */
message_warning(_("The image file '%s' was not found.\n"),
image->file);
}
}
}
g_free(diafile_dir);
}
/* update mtime */
{
struct stat st;
if (g_stat (image->file, &st) != 0)
st.st_mtime = 0;
image->mtime = st.st_mtime;
}
image_update_data(image);
obj->node = NULL;
list = dia_open_diagrams();
while (list != NULL) {
dia = (Diagram *)list->data;
if (!g_strcmp0(dia->filename,filename)) {
obj->node = dtree_set_data_by_longname(DIA_DIAGRAM_DATA(dia)->dtree,
image->embed_id,&image->element.object);
}
list = g_list_next(list);
}
return &image->element.object;
}
static DiaObject *
compound_load (ObjectNode obj_node, int version, DiaContext *ctx)
{
Compound * comp;
DiaObject * obj;
AttributeNode attr;
DataNode data;
gint i, num_handles;
comp = g_new0 (Compound, 1);
obj = &comp->object;
/* load the objects position and bounding box */
object_load (obj, obj_node, ctx);
/* init the object */
obj->type = &compound_type;
obj->ops = &compound_ops;
/* load the object's handles and its positions */
attr = object_find_attribute (obj_node, "comp_points");
g_assert (attr != NULL);
num_handles = attribute_num_data (attr);
g_assert (num_handles >= 3);
/* allocate space for object handles and connectionpoints point arrays */
object_init (obj, num_handles, 1);
data = attribute_first_data (attr);
/* init our mount_point */
setup_mount_point (&comp->mount_point, obj, NULL);
data_point (data, &comp->mount_point.pos, ctx);
obj->connections[0] = &comp->mount_point;
/* now init the handles */
comp->num_arms = num_handles-1;
comp->handles = g_new0 (Handle, num_handles);
setup_handle (&comp->handles[0], HANDLE_MOUNT_POINT,
HANDLE_MAJOR_CONTROL, HANDLE_NONCONNECTABLE);
comp->handles[0].pos = comp->mount_point.pos;
obj->handles[0] = &comp->handles[0];
data = data_next (data);
for (i = 1; i < num_handles; i++)
{
obj->handles[i] = &comp->handles[i];
setup_handle (obj->handles[i], HANDLE_ARM,
HANDLE_MINOR_CONTROL, HANDLE_CONNECTABLE_NOBREAK);
data_point (data, &obj->handles[i]->pos, ctx);
data = data_next (data);
}
/* load remainding properties */
attr = object_find_attribute (obj_node, PROP_STDTYPE_LINE_WIDTH);
if (attr == NULL)
comp->line_width = 0.1;
else
comp->line_width = data_real (attribute_first_data (attr), ctx);
attr = object_find_attribute (obj_node, "line_colour");
if (attr == NULL)
comp->line_color = color_black;
else
data_color (attribute_first_data (attr), &comp->line_color, ctx);
compound_update_data (comp);
compound_sanity_check (comp, "Loaded");
return &comp->object;
}