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 Add a layer object to a diagram.
* @param data The diagram to add the layer to.
* @param layer The layer to add.
* \memberof _DiagramData
*/
void
data_add_layer(DiagramData *data, Layer *layer)
{
g_ptr_array_add(data->layers, layer);
layer->parent_diagram = data;
data_emit (data, layer, NULL, "object_add");
layer_update_extents(layer);
data_update_extents(data);
}
/*!
* \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);
}
/*!
* \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);
}
}
/*!
* \brief Remove a layer from a diagram.
* @param data The diagram to remove the layer from.
* @param layer The layer to remove.
* \memberof _DiagramData
*/
void
data_remove_layer(DiagramData *data, Layer *layer)
{
if (data->layers->len<=1)
return;
if (data->active_layer == layer) {
data_remove_all_selected(data);
}
data_emit (data, layer, NULL, "object_remove");
layer->parent_diagram = NULL;
g_ptr_array_remove(data->layers, layer);
if (data->active_layer == layer) {
data->active_layer = g_ptr_array_index(data->layers, 0);
}
}
/*!
* \brief Add a layer at a defined postion in the stack
*
* If the given pos is out of range the layer is added at the top of the stack.
*
* @param data the diagram
* @param layer layer to add
* @param pos the position in the layer stack
* \memberof _DiagramData
*/
void
data_add_layer_at(DiagramData *data, Layer *layer, int pos)
{
int len;
int i;
g_ptr_array_add(data->layers, layer);
len = data->layers->len;
if ( (pos>=0) && (pos < len)) {
for (i=len-1;i>pos;i--) {
g_ptr_array_index(data->layers, i) = g_ptr_array_index(data->layers, i-1);
}
g_ptr_array_index(data->layers, pos) = layer;
}
layer->parent_diagram = data;
data_emit (data, layer, NULL, "object_add");
layer_update_extents(layer);
data_update_extents(data);
}
