lib/diagramdata.c

   1 /* Dia -- an diagram creation/manipulation program
   2  * Copyright (C) 1998 Alexander Larsson
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  17  */
  18
  19 /** \file diagramdata.c  This file defines the DiagramData object, which holds (mostly) saveable
  20  * data global to a diagram.
  21  */
  22
  23 #ifdef HAVE_CONFIG_H
  24 #include <config.h>
  25 #endif
  26
  27 #include "intl.h"
  28 #include "diagramdata.h"
  29 #include "diarenderer.h"
  30 #include "paper.h"
  31 #include "persistence.h"
  32
  33 #include "dynamic_obj.h"
  34 #include "diamarshal.h"
  35
  36
  37 static const Rectangle invalid_extents = { -1.0,-1.0,-1.0,-1.0 };
  38 static void set_parent_layer(gpointer layer, gpointer object);
  39
  40 static void diagram_data_class_init (DiagramDataClass *klass);
  41 static void diagram_data_init (DiagramData *object);
  42
  43 enum {
  44   OBJECT_ADD,
  45   OBJECT_REMOVE,
  46   LAST_SIGNAL
  47 };
  48
  49 static guint diagram_data_signals[LAST_SIGNAL] = { 0, };
  50
  51 static gpointer parent_class = NULL;
  52
  53 /** Get the type object for the DiagramData class.
  54  */
  55 GType
  56 diagram_data_get_type(void)
  57 {
  58   static GType object_type = 0;
  59
  60   if (!object_type)
  61     {
  62       static const GTypeInfo object_info =
  63       {
  64         sizeof (DiagramDataClass),
  65         (GBaseInitFunc) NULL,
  66         (GBaseFinalizeFunc) NULL,
  67         (GClassInitFunc) diagram_data_class_init,
  68         NULL,           /* class_finalize */
  69         NULL,           /* class_data */
  70         sizeof (DiagramData),
  71         0,              /* n_preallocs */
  72         (GInstanceInitFunc)diagram_data_init /* init */
  73       };
  74
  75       object_type = g_type_register_static (G_TYPE_OBJECT,
  76                                             "DiagramData",
  77                                             &object_info, 0);
  78     }
  79
  80   return object_type;
  81 }
  82
  83 /* signal default handlers */
  84 static void
  85 _diagram_data_object_add (DiagramData* dia,Layer* layer,DiaObject* obj)
  86 {
  87 }
  88
  89 static void
  90 _diagram_data_object_remove (DiagramData* dia,Layer* layer,DiaObject* obj)
  91 {
  92 }
  93
  94 /** Initialize a new diagram data object.
  95  * @param data A diagram data object to initialize.
  96  */
  97 static void
  98 diagram_data_init(DiagramData *data)
  99 {
 100   Color* color = persistence_register_color ("new_diagram_bgcolour", &color_white);
 101   gboolean compress = persistence_register_boolean ("compress_save", TRUE);
 102   Layer *first_layer;
 103
 104   data->extents.left = 0.0;
 105   data->extents.right = 10.0;
 106   data->extents.top = 0.0;
 107   data->extents.bottom = 10.0;
 108
 109   data->bg_color = *color;
 110
 111   get_paper_info (&data->paper, -1, NULL);
 112
 113   first_layer = new_layer(g_strdup(_("Background")),data);
 114
 115   data->layers = g_ptr_array_new ();
 116   g_ptr_array_add (data->layers, first_layer);
 117   data->active_layer = first_layer;
 118
 119   data->selected_count_private = 0;
 120   data->selected = NULL;
 121
 122   data->is_compressed = compress; /* Overridden by doc */
 123
 124 }
 125
 126 /** Deallocate memory owned by a DiagramData object.
 127  * @param object A DiagramData object to finalize.
 128  */
 129 static void
 130 diagram_data_finalize(GObject *object)
 131 {
 132   DiagramData *data = DIA_DIAGRAM_DATA(object);
 133
 134   guint i;
 135
 136   g_free(data->paper.name);
 137
 138   for (i=0;i<data->layers->len;i++) {
 139     layer_destroy(g_ptr_array_index(data->layers, i));
 140   }
 141   g_ptr_array_free(data->layers, TRUE);
 142   data->active_layer = NULL;
 143
 144   g_list_free(data->selected);
 145   data->selected = NULL; /* for safety */
 146   data->selected_count_private = 0;
 147 }
 148
 149 /** Initialize the DiagramData class data.
 150  * @param klass The class object to initialize functions for.
 151  */
 152 static void
 153 diagram_data_class_init(DiagramDataClass *klass)
 154 {
 155   GObjectClass *object_class = G_OBJECT_CLASS (klass);
 156
 157   parent_class = g_type_class_peek_parent (klass);
 158
 159   diagram_data_signals[OBJECT_ADD] =
 160     g_signal_new ("object_add",
 161               G_TYPE_FROM_CLASS (klass),
 162               G_SIGNAL_RUN_FIRST,
 163               G_STRUCT_OFFSET (DiagramDataClass, object_add),
 164               NULL, NULL,
 165               dia_marshal_VOID__POINTER_POINTER,
 166               G_TYPE_NONE,
 167               2,
 168               G_TYPE_POINTER,
 169               G_TYPE_POINTER);
 170
 171   diagram_data_signals[OBJECT_REMOVE] =
 172     g_signal_new ("object_remove",
 173               G_TYPE_FROM_CLASS (klass),
 174               G_SIGNAL_RUN_FIRST,
 175               G_STRUCT_OFFSET (DiagramDataClass, object_remove),
 176               NULL, NULL,
 177               dia_marshal_VOID__POINTER_POINTER,
 178               G_TYPE_NONE,
 179               2,
 180               G_TYPE_POINTER,
 181               G_TYPE_POINTER);
 182
 183   object_class->finalize = diagram_data_finalize;
 184   klass->object_add = _diagram_data_object_add;
 185   klass->object_remove = _diagram_data_object_remove;
 186 }
 187
 188 /** Create a new layer in this diagram.
 189  * @param name Name of the new layer.
 190  * @param parent The DiagramData that the layer will belong to,.
 191  * @return A new Layer object.
 192  * @bug Must determine if a NULL name is ok.
 193  * @bug This belongs in a layers.c file.
 194  * @bug Even though this sets parent diagram, it doesn't call the
 195  * update_extents functions that add_layer does.
 196  */
 197 Layer *
 198 new_layer(gchar *name, DiagramData *parent)
 199 {
 200   Layer *layer;
 201
 202   layer = g_new(Layer, 1);
 203
 204   layer->name = name;
 205
 206   layer->parent_diagram = parent;
 207   layer->visible = TRUE;
 208   layer->connectable = TRUE;
 209
 210   layer->objects = NULL;
 211
 212   layer->extents.left = 0.0;
 213   layer->extents.right = 10.0;
 214   layer->extents.top = 0.0;
 215   layer->extents.bottom = 10.0;
 216
 217   return layer;
 218 }
 219
 220 /** Destroy a layer object.
 221  * @param layer The layer object to deallocate entirely.
 222  * @bug This belongs in a layers.c file.
 223  */
 224 void
 225 layer_destroy(Layer *layer)
 226 {
 227   g_free(layer->name);
 228   destroy_object_list(layer->objects);
 229   g_free(layer);
 230 }
 231
 232 /** Raise a layer up one in a diagram.
 233  * @param data The diagram that the layer belongs to.
 234  * @param layer The layer to raise.
 235  * @bug The diagram doesn't really need to be passed, as the layer knows it.
 236  */
 237 void
 238 data_raise_layer(DiagramData *data, Layer *layer)
 239 {
 240   guint i;
 241   int layer_nr = -1;
 242   Layer *tmp;
 243
 244   for (i=0;i<data->layers->len;i++) {
 245     if (g_ptr_array_index(data->layers, i)==layer)
 246       layer_nr = i;
 247   }
 248
 249   g_assert(layer_nr>=0);
 250
 251   if (layer_nr < data->layers->len-1) {
 252     tmp = g_ptr_array_index(data->layers, layer_nr+1);
 253     g_ptr_array_index(data->layers, layer_nr+1) =
 254       g_ptr_array_index(data->layers, layer_nr);
 255     g_ptr_array_index(data->layers, layer_nr) = tmp;
 256   }
 257 }
 258
 259 /** Lower a layer by one in a diagram.
 260  * @param data The diagram that the layer belongs to.
 261  * @param layer The layer to lower.
 262  * @bug The diagram doesn't really need to be passed, as the layer knows it.
 263  */
 264 void
 265 data_lower_layer(DiagramData *data, Layer *layer)
 266 {
 267   guint i;
 268   int layer_nr = -1;
 269   Layer *tmp;
 270
 271   for (i=0;i<data->layers->len;i++) {
 272     if (g_ptr_array_index(data->layers, i)==layer)
 273       layer_nr = i;
 274   }
 275
 276   g_assert(layer_nr>=0);
 277
 278   if (layer_nr > 0) {
 279     tmp = g_ptr_array_index(data->layers, layer_nr-1);
 280     g_ptr_array_index(data->layers, layer_nr-1) =
 281       g_ptr_array_index(data->layers, layer_nr);
 282     g_ptr_array_index(data->layers, layer_nr) = tmp;
 283   }
 284 }
 285
 286 /** Add a layer object to a diagram.
 287  * @param data The diagram to add the layer to.
 288  * @param layer The layer to add.
 289  * @bug Should just call data_add_layer_at().
 290  */
 291 void
 292 data_add_layer(DiagramData *data, Layer *layer)
 293 {
 294   g_ptr_array_add(data->layers, layer);
 295   layer->parent_diagram = data;
 296   layer_update_extents(layer);
 297   data_update_extents(data);
 298 }
 299
 300 void
 301 data_add_layer_at(DiagramData *data, Layer *layer, int pos)
 302 {
 303   int len;
 304   int i;
 305
 306   g_ptr_array_add(data->layers, layer);
 307   len = data->layers->len;
 308
 309   if ( (pos>=0) && (pos < len)) {
 310     for (i=len-1;i>pos;i--) {
 311       g_ptr_array_index(data->layers, i) = g_ptr_array_index(data->layers, i-1);
 312     }
 313     g_ptr_array_index(data->layers, pos) = layer;
 314   }
 315
 316   layer->parent_diagram = data;
 317   layer_update_extents(layer);
 318   data_update_extents(data);
 319 }
 320
 321 /** Set which layer is the active layer in a diagram.
 322  * @param data The diagram in which to set the active layer.
 323  * @param layer The layer that should be active.
 324  * @bug The diagram doesn't really need to be passed, as the layer knows it.
 325  */
 326 void
 327 data_set_active_layer(DiagramData *data, Layer *layer)
 328 {
 329   data->active_layer = layer;
 330 }
 331
 332 /** Delete a layer from a diagram.
 333  * @param data The diagram to delete the layer from.
 334  * @param layer The layer to delete.
 335  * @bug The diagram doesn't really need to be passed, as the layer knows it.
 336  */
 337 void
 338 data_delete_layer(DiagramData *data, Layer *layer)
 339 {
 340   if (data->layers->len<=1)
 341     return;
 342
 343   if (data->active_layer == layer) {
 344     data_remove_all_selected(data);
 345   }
 346   layer->parent_diagram = NULL;
 347   g_ptr_array_remove(data->layers, layer);
 348
 349   if (data->active_layer == layer) {
 350     data->active_layer = g_ptr_array_index(data->layers, 0);
 351   }
 352 }
 353
 354 /** Select an object in a diagram.  Note that this does not unselect other
 355  *  objects currently selected in the diagram.
 356  * @param data The diagram to select in.
 357  * @param obj The object to select.
 358  * @bug Does not need to be passed the diagram, as it can be found from the
 359  *  object.
 360  */
 361 void
 362 data_select(DiagramData *data, DiaObject *obj)
 363 {
 364   if (g_list_find (data->selected, obj))
 365     return; /* should this be an error?`*/
 366   data->selected = g_list_prepend(data->selected, obj);
 367   data->selected_count_private++;
 368 }
 369
 370 /** Deselect an object in a diagram.  Note that other objects may still be
 371  *  selected after this function is done.
 372  * @param data The diagram to deselect in.
 373  * @param obj The object to deselect.
 374  * @bug Does not need to be passed the diagram, as it can be found from the
 375  *  object.
 376  */
 377 void
 378 data_unselect(DiagramData *data, DiaObject *obj)
 379 {
 380   if (!g_list_find (data->selected, obj))
 381     return; /* should this be an error?`*/
 382   data->selected = g_list_remove(data->selected, obj);
 383   data->selected_count_private--;
 384 }
 385
 386 /** Clears the list of selected objects.
 387  * Does *not* remove these objects from the object list, despite its name.
 388  * @param data The diagram to unselect all objects in.
 389  */
 390 void
 391 data_remove_all_selected(DiagramData *data)
 392 {
 393   g_list_free(data->selected); /* Remove previous selection */
 394   data->selected = NULL;
 395   data->selected_count_private = 0;
 396 }
 397
 398 /** Return TRUE if the diagram has visible layers.
 399  * @param data The diagram to check.
 400  * @return TRUE if at least one layer in the diagram is visible.
 401  */
 402 static gboolean
 403 data_has_visible_layers(DiagramData *data)
 404 {
 405   guint i;
 406   for (i = 0; i < data->layers->len; i++) {
 407     Layer *layer = g_ptr_array_index(data->layers, i);
 408     if (layer->visible) return TRUE;
 409   }
 410   return FALSE;
 411 }
 412
 413 /** Set the diagram extents field to the union of the extents of the layers.
 414  * @param data The diagram to get the extents for.
 415  */
 416 static void
 417 data_get_layers_extents_union(DiagramData *data)
 418 {
 419   guint i;
 420   gboolean first = TRUE;
 421   Rectangle new_extents;
 422
 423   for ( i = 0 ; i<data->layers->len; i++) {
 424     Layer *layer = g_ptr_array_index(data->layers, i);
 425     if (!layer->visible) continue;
 426
 427     layer_update_extents(layer);
 428
 429     if (first) {
 430       new_extents = layer->extents;
 431       first = rectangle_equals(&new_extents,&invalid_extents);
 432     } else {
 433       if (!rectangle_equals(&layer->extents,&invalid_extents)) {
 434         rectangle_union(&new_extents, &layer->extents);
 435       }
 436     }
 437   }
 438
 439   data->extents = new_extents;
 440 }
 441
 442 /** Change diagram scaling so that the extents are exactly visible.
 443  * @param data The diagram to adjust.
 444  * @bug Consider making it a teeny bit larger, or check that *all* objects
 445  *  calculate their extents correctly.
 446  */
 447 static void
 448 data_adapt_scaling_to_extents(DiagramData *data)
 449 {
 450   gdouble pwidth = data->paper.width * data->paper.scaling;
 451   gdouble pheight = data->paper.height * data->paper.scaling;
 452
 453   gdouble xscale = data->paper.fitwidth * pwidth /
 454     (data->extents.right - data->extents.left);
 455   gdouble yscale = data->paper.fitheight * pheight /
 456     (data->extents.bottom - data->extents.top);
 457
 458   data->paper.scaling = (float)MIN(xscale, yscale);
 459   data->paper.width  = (float)(pwidth  / data->paper.scaling);
 460   data->paper.height = (float)(pheight / data->paper.scaling);
 461 }
 462
 463 /** Adjust the extents field of a diagram.
 464  * @param data The diagram to adjust.
 465  * @return TRUE if the extents changed.
 466  */
 467 static gboolean
 468 data_compute_extents(DiagramData *data)
 469 {
 470   Rectangle old_extents = data->extents;
 471
 472   if (!data_has_visible_layers(data)) {
 473     if (data->layers->len > 0) {
 474       Layer *layer = g_ptr_array_index(data->layers, 0);
 475       layer_update_extents(layer);
 476
 477       data->extents = layer->extents;
 478     } else {
 479       data->extents = invalid_extents;
 480     }
 481   } else {
 482     data_get_layers_extents_union(data);
 483   }
 484
 485   if (rectangle_equals(&data->extents,&invalid_extents)) {
 486       data->extents.left = 0.0;
 487       data->extents.right = 10.0;
 488       data->extents.top = 0.0;
 489       data->extents.bottom = 10.0;
 490   }
 491   return (!rectangle_equals(&data->extents,&old_extents));
 492 }
 493
 494 /** Update the extents of a diagram and adjust scaling if needed.
 495  * @param data Diagram to update.
 496  * @return TRUE if the diagram extents changed.
 497  */
 498 gboolean
 499 data_update_extents(DiagramData *data)
 500 {
 501
 502   gboolean changed;
 503
 504   changed = data_compute_extents(data);
 505   if (changed && data->paper.fitto) data_adapt_scaling_to_extents(data);
 506
 507   return changed;
 508 }
 509
 510 /** Get a list of selected objects in layer ordering.
 511  * @param data The diagram to get objects from.
 512  * @return A list of all currently selected objects.  These all reside in
 513  *  the currently active layer.  This list should be freed after use.
 514  * @bug Does selection update correctly when the layer changes?
 515  */
 516 GList *
 517 data_get_sorted_selected(DiagramData *data)
 518 {
 519   GList *list;
 520   GList *sorted_list;
 521   GList *found;
 522   DiaObject *obj;
 523
 524   g_assert (g_list_length (data->selected) == data->selected_count_private);
 525   if (data->selected_count_private == 0)
 526     return NULL;
 527
 528   sorted_list = NULL;
 529   list = g_list_last(data->active_layer->objects);
 530   while (list != NULL) {
 531     found = g_list_find(data->selected, list->data);
 532     if (found) {
 533       obj = (DiaObject *)found->data;
 534       sorted_list = g_list_prepend(sorted_list, obj);
 535     }
 536     list = g_list_previous(list);
 537   }
 538
 539   return sorted_list;
 540 }
 541
 542 /** Remove the currently selected objects from the list of objects.
 543  * The selected objects are returned in a newly created GList.
 544  * @param data The diagram to get and remove the selected objects from.
 545  * @return A list of all selected objects in the current diagram.  This list
 546  *  should be freed after use.  Unlike data_get_sorted_selected, the
 547  *  objects in the list are not in the diagram anymore.
 548  */
 549 GList *
 550 data_get_sorted_selected_remove(DiagramData *data)
 551 {
 552   GList *list,*tmp;
 553   GList *sorted_list;
 554   GList *found;
 555   DiaObject *obj;
 556
 557   g_assert (g_list_length (data->selected) == data->selected_count_private);
 558   if (data->selected_count_private == 0)
 559     return NULL;
 560
 561   sorted_list = NULL;
 562   list = g_list_last(data->active_layer->objects);
 563   while (list != NULL) {
 564     found = g_list_find(data->selected, list->data);
 565     if (found) {
 566       obj = (DiaObject *)found->data;
 567       sorted_list = g_list_prepend(sorted_list, obj);
 568
 569       tmp = list;
 570       list = g_list_previous(list);
 571       data->active_layer->objects =
 572         g_list_remove_link(data->active_layer->objects, tmp);
 573     } else {
 574       list = g_list_previous(list);
 575     }
 576   }
 577
 578   return sorted_list;
 579 }
 580
 581
 582 /** Emits a GObject signal on DiagramData
 583  *  @param data The DiagramData that emits the signal.
 584  *  @param layer The Layer that the fired signal carries.
 585  *  @param obj The DiaObject that the fired signal carries.
 586  *  @param signal_name The name of the signal.
 587  */
 588 void
 589 data_emit(DiagramData *data, Layer *layer, DiaObject* obj,
 590           const char *signal_name)
 591 {
 592   /* check what signal it is */
 593   if (strcmp("object_add",signal_name) == 0)
 594     g_signal_emit(data, diagram_data_signals[OBJECT_ADD], 0, layer, obj);
 595
 596   if (strcmp("object_remove",signal_name) == 0)
 597     g_signal_emit(data, diagram_data_signals[OBJECT_REMOVE], 0, layer, obj);
 598
 599 }
 600
 601
 602 /** Render a diagram.
 603  * @param data The diagram to render.
 604  * @param renderer The renderer to render on.
 605  * @param update The area that needs updating.
 606  * @param obj_renderer If non-NULL, an alternative renderer of objects.
 607  * @param gdata User data passed on to inner calls.
 608  * @bug Describe obj_renderer better.
 609  */
 610 void
 611 data_render(DiagramData *data, DiaRenderer *renderer, Rectangle *update,
 612             ObjectRenderer obj_renderer,
 613             gpointer gdata)
 614 {
 615   Layer *layer;
 616   int i;
 617   int active_layer;
 618
 619   if (!renderer->is_interactive) (DIA_RENDERER_GET_CLASS(renderer)->begin_render)(renderer);
 620
 621   for (i=0; i<data->layers->len; i++) {
 622     layer = (Layer *) g_ptr_array_index(data->layers, i);
 623     active_layer = (layer == data->active_layer);
 624     if (layer->visible)
 625       layer_render(layer, renderer, update, obj_renderer, gdata, active_layer);
 626   }
 627
 628   if (!renderer->is_interactive) (DIA_RENDERER_GET_CLASS(renderer)->end_render)(renderer);
 629 }
 630
 631 /** The default object renderer.
 632  * @param obj An object to render.
 633  * @param renderer The renderer to render on.
 634  * @param active_layer The layer containing the object.
 635  * @param data The diagram containing the layer.
 636  * @bug The active_layer and data variables can be inferred from the object.
 637  */
 638 static void
 639 normal_render(DiaObject *obj, DiaRenderer *renderer,
 640               int active_layer,
 641               gpointer data)
 642 {
 643   DIA_RENDERER_GET_CLASS(renderer)->draw_object(renderer, obj);
 644 }
 645
 646
 647 int render_bounding_boxes = FALSE;
 648
 649 /** Render all components of a single layer.  This function also handles
 650  *  rendering of bounding boxes for debugging purposes.
 651  * @param layer The layer to render.
 652  * @param renderer The renderer to draw things with.
 653  * @param update The rectangle that requires update.  Only objects that
 654  *  intersect with this rectangle will actually be get rendered.
 655  * @param obj_renderer A function that will render an object.
 656  * @param data The diagram that the layer belongs to.
 657  * @param active_layer Which number layer in the diagram is currently active.
 658  * @bug data and active_layer can be inferred from layer, though possibly
 659  *  slowly.
 660  */
 661 void
 662 layer_render(Layer *layer, DiaRenderer *renderer, Rectangle *update,
 663              ObjectRenderer obj_renderer,
 664              gpointer data,
 665              int active_layer)
 666 {
 667   GList *list;
 668   DiaObject *obj;
 669
 670   if (obj_renderer == NULL)
 671     obj_renderer = normal_render;
 672
 673   /* Draw all objects: */
 674   list = layer->objects;
 675   while (list!=NULL) {
 676     obj = (DiaObject *) list->data;
 677
 678     if (update==NULL || rectangle_intersects(update, &obj->bounding_box)) {
 679       if ((render_bounding_boxes) && (renderer->is_interactive)) {
 680         Point p1, p2;
 681         Color col;
 682         p1.x = obj->bounding_box.left;
 683         p1.y = obj->bounding_box.top;
 684         p2.x = obj->bounding_box.right;
 685         p2.y = obj->bounding_box.bottom;
 686         col.red = 1.0;
 687         col.green = 0.0;
 688         col.blue = 1.0;
 689
 690         DIA_RENDERER_GET_CLASS(renderer)->set_linewidth(renderer,0.01);
 691         DIA_RENDERER_GET_CLASS(renderer)->draw_rect(renderer, &p1, &p2, &col);
 692       }
 693       (*obj_renderer)(obj, renderer, active_layer, data);
 694     }
 695
 696     list = g_list_next(list);
 697   }
 698 }
 699
 700 /** Set the parent layer of an object.
 701  * @param element A DiaObject that should be part of a layer.
 702  * @param user_data The layer it should be part of.
 703  */
 704 static void
 705 set_parent_layer(gpointer element, gpointer user_data)
 706 {
 707   ((DiaObject*)element)->parent_layer = (Layer*)user_data;
 708   /* FIXME: even group members need a parent_layer and what about parent objects  ???
 709       * Now I know again why I always try to avoid back-pointers )-; --hb.
 710       * If the group objects didn't actually leave the diagram, this wouldn't
 711       * be a problem.  --LC */
 712 }
 713
 714 /** Get the index of an object in a layer.
 715  * @param layer The layer the object is (should be) in.
 716  * @param obj The object to look for.
 717  * @return The index of the object in the layers list of objects.  This is also
 718  *  the vertical position of the object.
 719  * @bug This should be in a separate layer.c file.
 720  * @bug The layer could be inferred from the object, in which case the
 721  *  layer arg is not needed, and we would be sure we always looked in the
 722  *  right layer.
 723  */
 724 int
 725 layer_object_index(Layer *layer, DiaObject *obj)
 726 {
 727   return (int)g_list_index(layer->objects, (gpointer) obj);
 728 }
 729
 730 /** Add an object to the top of a layer.
 731  * @param layer The layer to add the object to.
 732  * @param obj The object to add.  This must not already be part of another
 733  *  layer.
 734  * @bug This should be in a separate layer.c file.
 735  * @bug This should just call layer_add_object_at().
 736  */
 737 void
 738 layer_add_object(Layer *layer, DiaObject *obj)
 739 {
 740   layer->objects = g_list_append(layer->objects, (gpointer) obj);
 741   set_parent_layer(obj, layer);
 742
 743   /* send a signal that we have added a object to the diagram */
 744   g_signal_emit (layer_get_parent_diagram(layer), diagram_data_signals[OBJECT_ADD], 0,layer,obj);
 745 }
 746
 747 /** Add an object to a layer at a specific position.
 748  * @param layer The layer to add the object to.
 749  * @param obj The object to add.  This must not be part of another layer.
 750  * @param pos The top-to-bottom position this object should be inserted at.
 751  * @bug This should be in a separate layer.c file.
 752  */
 753 void
 754 layer_add_object_at(Layer *layer, DiaObject *obj, int pos)
 755 {
 756   layer->objects = g_list_insert(layer->objects, (gpointer) obj, pos);
 757   set_parent_layer(obj, layer);
 758
 759   /* send a signal that we have added a object to the diagram */
 760   g_signal_emit (layer_get_parent_diagram(layer), diagram_data_signals[OBJECT_ADD], 0,layer,obj);
 761 }
 762
 763 /** Add a list of objects to the end of a layer.
 764  * @param layer The layer to add objects to.
 765  * @param obj_list The list of objects to add.  These must not already
 766  *  be part of another layer.
 767  * @bug Determine if the list is kept by g_list_concat.
 768  */
 769 void
 770 layer_add_objects(Layer *layer, GList *obj_list)
 771 {
 772   GList *list = obj_list;
 773
 774   layer->objects = g_list_concat(layer->objects, obj_list);
 775   g_list_foreach(obj_list, set_parent_layer, layer);
 776
 777   while (list != NULL)
 778   {
 779     /* send a signal that we have added a object to the diagram */
 780     g_signal_emit (layer_get_parent_diagram(layer), diagram_data_signals[OBJECT_ADD], 0,layer,list->data);
 781
 782     list = g_list_next(list);
 783   }
 784 }
 785
 786 /** Add a list of objects to the top of a layer.
 787  * @param layer The layer to add objects to.
 788  * @param obj_list The list of objects to add.  These must not already
 789  *  be part of another layer.
 790  * @bug Determine if the list is kept by g_list_concat.
 791  */
 792 void
 793 layer_add_objects_first(Layer *layer, GList *obj_list)
 794 {
 795   GList *list = obj_list;
 796
 797   layer->objects = g_list_concat(obj_list, layer->objects);
 798   g_list_foreach(obj_list, set_parent_layer, layer);
 799
 800   /* Send one signal per object added */
 801   while (list != NULL)
 802   {
 803     /* send a signal that we have added a object to the diagram */
 804     g_signal_emit (layer_get_parent_diagram(layer), diagram_data_signals[OBJECT_ADD], 0,layer,list->data);
 805
 806     list = g_list_next(list);
 807   }
 808
 809 }
 810
 811 /** Remove an object from a layer.
 812  * @param layer The layer to remove the object from.
 813  * @param obj The object to remove.
 814  * @bug Why don't the layer_add functions deal with dynobj?
 815  */
 816 void
 817 layer_remove_object(Layer *layer, DiaObject *obj)
 818 {
 819   layer->objects = g_list_remove(layer->objects, obj);
 820   dynobj_list_remove_object(obj);
 821   set_parent_layer(obj, NULL);
 822
 823   /* send a signal that we have removed a object from the diagram */
 824   g_signal_emit (layer_get_parent_diagram(layer), diagram_data_signals[OBJECT_REMOVE], 0,layer,obj);
 825 }
 826
 827 /** Remove a list of objects from a layer.
 828  * @param layer The layer to remove the objects from.
 829  * @param obj The objects to remove.
 830  * @bug This should call layer_remove_object repeatedly.
 831  */
 832 void
 833 layer_remove_objects(Layer *layer, GList *obj_list)
 834 {
 835   DiaObject *obj;
 836   while (obj_list != NULL) {
 837     obj = (DiaObject *) obj_list->data;
 838
 839     layer->objects = g_list_remove(layer->objects, obj);
 840
 841     obj_list = g_list_next(obj_list);
 842     dynobj_list_remove_object(obj);
 843     set_parent_layer(obj, NULL);
 844     /* send a signal that we have removed a object from the diagram */
 845     g_signal_emit (layer_get_parent_diagram(layer), diagram_data_signals[OBJECT_REMOVE], 0,layer,obj);
 846   }
 847 }
 848
 849 /** Find the objects that intersect a given rectangle.
 850  * @param layer The layer to search in.
 851  * @param rect The rectangle to intersect with.
 852  * @return List of objects whose bounding box intersect the rectangle.  The
 853  *  list should be freed by the caller.
 854  */
 855 GList *
 856 layer_find_objects_intersecting_rectangle(Layer *layer, Rectangle *rect)
 857 {
 858   GList *list;
 859   GList *selected_list;
 860   DiaObject *obj;
 861
 862   selected_list = NULL;
 863   list = layer->objects;
 864   while (list != NULL) {
 865     obj = (DiaObject *)list->data;
 866
 867     if (rectangle_intersects(rect, &obj->bounding_box)) {
 868       if (dia_object_is_selectable(obj)) {
 869         selected_list = g_list_prepend(selected_list, obj);
 870       }
 871       /* Objects in closed groups do not get selected, but their parents do.
 872       * Since the parents bbox is outside the objects, they will be found
 873       * anyway and the inner object can just be skipped. */
 874     }
 875
 876     list = g_list_next(list);
 877   }
 878
 879   return selected_list;
 880 }
 881
 882 /** Find objects entirely contained in a rectangle.
 883  * @param layer The layer to search for objects in.
 884  * @param rect The rectangle that the objects should be in.
 885  * @return A list containing the objects that are entirely contained in the
 886  *  rectangle.  The list should be freed by the caller.
 887  */
 888 GList *
 889 layer_find_objects_in_rectangle(Layer *layer, Rectangle *rect)
 890 {
 891   GList *list;
 892   GList *selected_list;
 893   DiaObject *obj;
 894
 895   selected_list = NULL;
 896   list = layer->objects;
 897   while (list != NULL) {
 898     DiaObject *parent;
 899     obj = (DiaObject *)list->data;
 900
 901     if (rectangle_in_rectangle(rect, &obj->bounding_box)) {
 902       if (dia_object_is_selectable(obj)) {
 903         selected_list = g_list_prepend(selected_list, obj);
 904       }
 905     }
 906
 907     list = g_list_next(list);
 908   }
 909
 910   return selected_list;
 911 }
 912
 913 /** Find the object closest to the given point in the layer,
 914  * no further away than maxdist, and not included in avoid.
 915  * Stops it if finds an object that includes the point.
 916  * @param layer The layer to search in.
 917  * @param pos The point to compare to.
 918  * @param maxdist The maximum distance the object can be from the point.
 919  * @param avoid A list of objects that cannot be returned by this search.
 920  * @return The closest object, or NULL if no allowed objects are closer than
 921  *  maxdist.
 922  */
 923 DiaObject *
 924 layer_find_closest_object_except(Layer *layer, Point *pos,
 925                                  real maxdist, GList *avoid)
 926 {
 927   GList *l;
 928   DiaObject *closest;
 929   DiaObject *obj;
 930   real dist;
 931   GList *avoid_tmp;
 932
 933   closest = NULL;
 934
 935   for (l = layer->objects; l!=NULL; l = g_list_next(l)) {
 936     obj = (DiaObject *) l->data;
 937
 938     /* Check bounding box here too. Might give speedup. */
 939     dist = obj->ops->distance_from(obj, pos);
 940
 941     if (maxdist-dist > 0.00000001) {
 942       for (avoid_tmp = avoid; avoid_tmp != NULL; avoid_tmp = avoid_tmp->next) {
 943         if (avoid_tmp->data == obj) {
 944           goto NEXTOBJECT;
 945         }
 946       }
 947       closest = obj;
 948     }
 949   NEXTOBJECT:
 950   ;
 951   }
 952
 953   /* If the object is within a closed group, find the group. */
 954   closest = dia_object_get_parent_with_flags(closest,
 955                                              DIA_OBJECT_GRABS_CHILD_INPUT);
 956
 957   return closest;
 958 }
 959
 960 /** Find the object closest to the given point in the layer,
 961  * no further away than maxdist.
 962  * Stops it if finds an object that includes the point.
 963  * @param layer The layer to search in.
 964  * @param pos The point to compare to.
 965  * @param maxdist The maximum distance the object can be from the point.
 966  * @return The closest object, or NULL if none are closer than maxdist.
 967  */
 968 DiaObject *
 969 layer_find_closest_object(Layer *layer, Point *pos, real maxdist)
 970 {
 971   return layer_find_closest_object_except(layer, pos, maxdist, NULL);
 972 }
 973
 974
 975 /** Find the connectionpoint closest to pos in a layer.
 976  * @param layer
 977  * @param closest
 978  * @param pos
 979  * @param notthis
 980  * @return
 981  */
 982 real
 983 layer_find_closest_connectionpoint(Layer *layer,
 984                                         ConnectionPoint **closest,
 985                                         Point *pos,
 986                                         DiaObject *notthis)
 987 {
 988   GList *l;
 989   DiaObject *obj;
 990   ConnectionPoint *cp;
 991   real mindist, dist;
 992   int i;
 993
 994   mindist = 1000000.0; /* Realy big value... */
 995
 996   *closest = NULL;
 997
 998   for (l = layer->objects; l!=NULL; l = g_list_next(l) ) {
 999     obj = (DiaObject *) l->data;
1000
1001     if (obj == notthis) continue;
1002     if (obj != dia_object_get_parent_with_flags(obj, DIA_OBJECT_GRABS_CHILD_INPUT))
1003       continue;
1004     for (i=0;i<obj->num_connections;i++) {
1005       cp = obj->connections[i];
1006       /* Note: Uses manhattan metric for speed... */
1007       dist = distance_point_point_manhattan(pos, &cp->pos);
1008       if (dist<mindist) {
1009         mindist = dist;
1010         *closest = cp;
1011       }
1012     }
1013
1014  }
1015
1016   return mindist;
1017 }
1018
1019 int
1020 layer_update_extents(Layer *layer)
1021 {
1022   GList *l;
1023   DiaObject *obj;
1024   Rectangle new_extents;
1025
1026   l = layer->objects;
1027   if (l!=NULL) {
1028     obj = (DiaObject *) l->data;
1029     new_extents = obj->bounding_box;
1030     l = g_list_next(l);
1031
1032     while(l!=NULL) {
1033       obj = (DiaObject *) l->data;
1034       rectangle_union(&new_extents, &obj->bounding_box);
1035       l = g_list_next(l);
1036     }
1037   } else {
1038     new_extents = invalid_extents;
1039   }
1040
1041   if (rectangle_equals(&new_extents,&layer->extents)) return FALSE;
1042
1043   layer->extents = new_extents;
1044   return TRUE;
1045 }
1046
1047 void
1048 layer_replace_object_with_list(Layer *layer, DiaObject *remove_obj,
1049                                GList *insert_list)
1050 {
1051   GList *list;
1052
1053   list = g_list_find(layer->objects, remove_obj);
1054
1055   g_assert(list!=NULL);
1056   set_parent_layer(remove_obj, NULL);
1057   dynobj_list_remove_object(remove_obj);
1058   g_list_foreach(insert_list, set_parent_layer, layer);
1059
1060   if (list->prev == NULL) {
1061     layer->objects = insert_list;
1062   } else {
1063     list->prev->next = insert_list;
1064     insert_list->prev = list->prev;
1065   }
1066   if (list->next != NULL) {
1067     GList *last;
1068     last = g_list_last(insert_list);
1069     last->next = list->next;
1070     list->next->prev = last;
1071   }
1072   g_list_free_1(list);
1073 }
1074
1075 static void
1076 layer_remove_dynobj(gpointer obj, gpointer userdata)
1077 {
1078   dynobj_list_remove_object((DiaObject*)obj);
1079 }
1080
1081 void layer_set_object_list(Layer *layer, GList *list)
1082 {
1083   g_list_foreach(layer->objects, set_parent_layer, NULL);
1084   g_list_foreach(layer->objects, layer_remove_dynobj, NULL);
1085   g_list_free(layer->objects);
1086   layer->objects = list;
1087   g_list_foreach(layer->objects, set_parent_layer, layer);
1088 }
1089
1090 DiagramData *
1091 layer_get_parent_diagram(Layer *layer)
1092 {
1093   return layer->parent_diagram;
1094 }