void layer_set_object_list(Layer *layer, GList *list) { GList *ol; /* signal removal on all objects */ ol = layer->objects; while (ol) { if (!g_list_find (list, ol->data)) /* only if it really vanishes */ data_emit (layer_get_parent_diagram(layer), layer, ol->data, "object_remove"); ol = g_list_next (ol); } /* restore old list */ ol = layer->objects; g_list_foreach(layer->objects, set_parent_layer, NULL); g_list_foreach(layer->objects, layer_remove_dynobj, NULL); layer->objects = list; g_list_foreach(layer->objects, set_parent_layer, layer); /* signal addition on all objects */ list = layer->objects; while (list) { if (!g_list_find (ol, list->data)) /* only if it is new */ data_emit (layer_get_parent_diagram(layer), layer, list->data, "object_add"); list = g_list_next (list); } g_list_free(ol); }
static void delete_objects_revert(struct DeleteObjectsChange *change, Diagram *dia) { GList *list; DEBUG_PRINTF(("delete_objects_revert()\n")); change->applied = 0; layer_set_object_list(change->layer, g_list_copy(change->original_objects)); object_add_updates_list(change->obj_list, dia); list = change->obj_list; while (list) { DiaObject *obj = (DiaObject *) list->data; if (obj->parent) /* Restore child references */ obj->parent->children = g_list_append(obj->parent->children, obj); /* Emit a signal per object reverted */ data_emit(layer_get_parent_diagram(change->layer),change->layer,obj,"object_add"); list = g_list_next(list); } diagram_tree_add_objects(diagram_tree(), dia, change->obj_list); }
/*! * \brief Add an object to a layer at a specific position. * @param layer The layer to add the object to. * @param obj The object to add. This must not be part of another layer. * @param pos The top-to-bottom position this object should be inserted at. * \memberof _Layer */ void layer_add_object_at(Layer *layer, DiaObject *obj, int pos) { layer->objects = g_list_insert(layer->objects, (gpointer) obj, pos); set_parent_layer(obj, layer); /* send a signal that we have added a object to the diagram */ data_emit (layer_get_parent_diagram(layer), layer, obj, "object_add"); }
/*! * \brief Remove an object from a layer. * @param layer The layer to remove the object from. * @param obj The object to remove. * \memberof _Layer */ void layer_remove_object(Layer *layer, DiaObject *obj) { /* send a signal that we'll remove a object from the diagram */ data_emit (layer_get_parent_diagram(layer), layer, obj, "object_remove"); layer->objects = g_list_remove(layer->objects, obj); dynobj_list_remove_object(obj); set_parent_layer(obj, NULL); }
static gboolean _dtm_iter_children (GtkTreeModel *tree_model, GtkTreeIter *iter, GtkTreeIter *parent) { if (parent) { if (NODE_OBJECT(parent)) return FALSE; else if (NODE_LAYER(parent)) { NODE_OBJECT(iter) = layer_object_get_nth(NODE_LAYER(parent), 0); if (NODE_OBJECT(iter)) { NODE_LAYER(iter) = dia_object_get_parent_layer(NODE_OBJECT(iter)); NODE_DIAGRAM(iter) = layer_get_parent_diagram (NODE_LAYER(iter)); return TRUE; } } else if (NODE_DIAGRAM(parent)) { NODE_LAYER(iter) = data_layer_get_nth(NODE_DIAGRAM(parent), 0); if (NODE_LAYER(iter)) { NODE_DIAGRAM(iter) = layer_get_parent_diagram (NODE_LAYER(iter)); NODE_OBJECT(iter) = NULL; return TRUE; } } else { /* deliver root's children */ parent = NULL; } } if (!parent) { /* the first diagram */ GList *list = dia_open_diagrams(); NODE_DIAGRAM(iter) = list ? list->data : NULL; NODE_LAYER(iter) = NULL; NODE_OBJECT(iter) = NULL; return NODE_DIAGRAM(iter) != NULL; } return FALSE; }
/*! * \brief Swaps a list of objects with a single object * * This function exchanges the given object with the list of objects. * Ownership of remove_obj and insert_list objects is swapped, too. * * \memberof _Layer */ void layer_replace_object_with_list(Layer *layer, DiaObject *remove_obj, GList *insert_list) { GList *list, *il; list = g_list_find(layer->objects, remove_obj); g_assert(list!=NULL); dynobj_list_remove_object(remove_obj); data_emit (layer_get_parent_diagram(layer), layer, remove_obj, "object_remove"); set_parent_layer(remove_obj, NULL); g_list_foreach(insert_list, set_parent_layer, layer); if (list->prev == NULL) { layer->objects = insert_list; } else { list->prev->next = insert_list; insert_list->prev = list->prev; } if (list->next != NULL) { GList *last; last = g_list_last(insert_list); last->next = list->next; list->next->prev = last; } il = insert_list; while (il) { data_emit (layer_get_parent_diagram(layer), layer, il->data, "object_add"); il = g_list_next(il); } g_list_free_1(list); /* with transformed groups the list and the single object are not necessarily * of the same size */ layer_update_extents (layer); }
/*! * \brief Add a list of objects to the end of a layer. * @param layer The layer to add objects to. * @param obj_list The list of objects to add. These must not already * be part of another layer. * \memberof _Layer */ void layer_add_objects(Layer *layer, GList *obj_list) { GList *list = obj_list; layer->objects = g_list_concat(layer->objects, obj_list); g_list_foreach(obj_list, set_parent_layer, layer); while (list != NULL) { DiaObject *obj = (DiaObject *)list->data; /* send a signal that we have added a object to the diagram */ data_emit (layer_get_parent_diagram(layer), layer, obj, "object_add"); list = g_list_next(list); } }
static GtkTreePath * _dtm_get_path (GtkTreeModel *tree_model, GtkTreeIter *iter) { GtkTreePath *result; int index = 0; if (!NODE_DIAGRAM(iter) && !NODE_LAYER(iter) && !NODE_OBJECT(iter)) { /* the root path */ return gtk_tree_path_new_first (); } result = gtk_tree_path_new (); if (NODE_DIAGRAM(iter)) { GList *list = dia_open_diagrams(); gtk_tree_path_append_index (result, g_list_index (list, NODE_DIAGRAM(iter))); } if (NODE_LAYER(iter)) { g_return_val_if_fail (NODE_DIAGRAM(iter) == layer_get_parent_diagram (NODE_LAYER(iter)), NULL); index = data_layer_get_index (NODE_DIAGRAM(iter), NODE_LAYER(iter)); if (index >= 0) gtk_tree_path_append_index (result, index); } if (index >= 0 && NODE_OBJECT(iter)) { g_return_val_if_fail (NODE_LAYER(iter) == dia_object_get_parent_layer (NODE_OBJECT(iter)), NULL); index = layer_object_get_index (NODE_LAYER(iter), NODE_OBJECT(iter)); if (index >= 0) gtk_tree_path_append_index (result, index); } if (index < 0) { gtk_tree_path_free (result); return NULL; } return result; }
static void newgroup_update_data(NewGroup *group) { Element *elem = &group->element; /* ElementBBExtras *extra = &elem->extra_spacing; */ DiaObject *obj = &elem->object; /* Update connections: */ group->connections[0].pos.x = elem->corner.x; group->connections[0].pos.y = elem->corner.y; group->connections[1].pos.x = elem->corner.x + elem->width / 2.0; group->connections[1].pos.y = elem->corner.y; group->connections[2].pos.x = elem->corner.x + elem->width; group->connections[2].pos.y = elem->corner.y; group->connections[3].pos.x = elem->corner.x; group->connections[3].pos.y = elem->corner.y + elem->height / 2.0; group->connections[4].pos.x = elem->corner.x + elem->width; group->connections[4].pos.y = elem->corner.y + elem->height / 2.0; group->connections[5].pos.x = elem->corner.x; group->connections[5].pos.y = elem->corner.y + elem->height; group->connections[6].pos.x = elem->corner.x + elem->width / 2.0; group->connections[6].pos.y = elem->corner.y + elem->height; group->connections[7].pos.x = elem->corner.x + elem->width; group->connections[7].pos.y = elem->corner.y + elem->height; group->connections[8].pos.x = elem->corner.x + elem->width / 2.0; group->connections[8].pos.y = elem->corner.y + elem->height / 2.0; group->connections[0].directions = DIR_NORTH|DIR_WEST; group->connections[1].directions = DIR_NORTH; group->connections[2].directions = DIR_NORTH|DIR_EAST; group->connections[3].directions = DIR_WEST; group->connections[4].directions = DIR_EAST; group->connections[5].directions = DIR_SOUTH|DIR_WEST; group->connections[6].directions = DIR_SOUTH; group->connections[7].directions = DIR_SOUTH|DIR_EAST; group->connections[8].directions = DIR_ALL; element_update_boundingbox(elem); obj->position = elem->corner; element_update_handles(elem); if (group->is_open) { obj->flags &= ~DIA_OBJECT_GRABS_CHILD_INPUT; } else { gboolean newlySet = FALSE; Layer *layer; if (!object_flags_set(obj, DIA_OBJECT_GRABS_CHILD_INPUT)) { newlySet = TRUE; } obj->flags |= DIA_OBJECT_GRABS_CHILD_INPUT; if (newlySet) { layer = dia_object_get_parent_layer(obj); if (layer != NULL) { /* Placed in diagram already */ GList *children = g_list_prepend(NULL, obj); children = parent_list_affected(children); /* Remove the group object that stayed at the start of the list, leaving only the children */ children = g_list_remove_link(children, children); #if 0 /* this introduces a crircular dependency, does not work on win32 and is bad style everywhere */ diagram_unselect_objects(layer_get_parent_diagram(layer), children); #else g_warning ("used to call diagram_unselect_objects()"); #endif g_list_free(children); } } } }