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);
}
}
}
}
