lib/object.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 #include <config.h>
  19
  20 #include <stdio.h>
  21 #include <string.h>
  22
  23 #include <gtk/gtk.h>
  24
  25 #include "object.h"
  26 #include "message.h"
  27
  28 #include "dummy_dep.h"
  29
  30 void
  31 object_init(Object *obj,
  32             int num_handles,
  33             int num_connections)
  34 {
  35   obj->num_handles = num_handles;
  36   if (num_handles>0)
  37     obj->handles = g_new0(Handle *,num_handles);
  38   else
  39     obj->handles = NULL;
  40
  41   obj->num_connections = num_connections;
  42   if (num_connections>0)
  43     obj->connections = g_new0(ConnectionPoint *,num_connections);
  44   else
  45     obj->connections = NULL;
  46 }
  47
  48 void
  49 object_destroy(Object *obj)
  50 {
  51   object_unconnect_all(obj);
  52
  53   if (obj->handles)
  54     g_free(obj->handles);
  55
  56   if (obj->connections)
  57     g_free(obj->connections);
  58
  59 }
  60
  61
  62 /* After this copying you have to fix up:
  63    handles
  64    connections
  65 */
  66 void
  67 object_copy(Object *from, Object *to)
  68 {
  69   to->type = from->type;
  70   to->position = from->position;
  71   to->bounding_box = from->bounding_box;
  72
  73   to->num_handles = from->num_handles;
  74   if (to->handles != NULL) g_free(to->handles);
  75   if (to->num_handles>0)
  76     to->handles = g_malloc(sizeof(Handle *)*to->num_handles);
  77   else
  78     to->handles = NULL;
  79
  80   to->num_connections = from->num_connections;
  81   if (to->connections != NULL) g_free(to->connections);
  82   if (to->num_connections>0)
  83     to->connections = g_malloc(sizeof(ConnectionPoint *) * to->num_connections);
  84   else
  85     to->connections = NULL;
  86
  87   to->ops = from->ops;
  88 }
  89
  90 static guint
  91 pointer_hash(gpointer some_pointer)
  92 {
  93   return (guint) some_pointer;
  94 }
  95
  96 GList *
  97 object_copy_list(GList *list_orig)
  98 {
  99   GList *list_copy;
 100   GList *list;
 101   Object *obj;
 102   Object *obj_copy;
 103   GHashTable *hash_table;
 104   int i;
 105
 106   hash_table = g_hash_table_new((GHashFunc) pointer_hash, NULL);
 107
 108   list = list_orig;
 109   list_copy = NULL;
 110   while (list != NULL) {
 111     obj = (Object *)list->data;
 112     obj_copy = obj->ops->copy(obj);
 113
 114     g_hash_table_insert(hash_table, obj, obj_copy);
 115
 116     list_copy = g_list_append(list_copy, obj_copy);
 117
 118     list = g_list_next(list);
 119   }
 120
 121   /* Rebuild the connections between the objects in the list: */
 122   list = list_orig;
 123   while (list != NULL) {
 124     obj = (Object *)list->data;
 125     obj_copy = g_hash_table_lookup(hash_table, obj);
 126
 127     for (i=0;i<obj->num_handles;i++) {
 128       ConnectionPoint *con_point;
 129       con_point = obj->handles[i]->connected_to;
 130
 131       if ( con_point != NULL ) {
 132         Object *other_obj;
 133         Object *other_obj_copy;
 134         int con_point_nr;
 135
 136         other_obj = con_point->object;
 137         other_obj_copy = g_hash_table_lookup(hash_table, other_obj);
 138
 139         if (other_obj_copy == NULL)
 140           break; /* other object was not on list. */
 141
 142         con_point_nr=0;
 143         while (other_obj->connections[con_point_nr] != con_point) {
 144           con_point_nr++;
 145         }
 146
 147         object_connect(obj_copy, obj_copy->handles[i],
 148                        other_obj_copy->connections[con_point_nr]);
 149       }
 150     }
 151
 152     list = g_list_next(list);
 153   }
 154
 155   g_hash_table_destroy(hash_table);
 156
 157   return list_copy;
 158 }
 159
 160 extern void
 161 object_list_move_delta(GList *objects, Point *delta)
 162 {
 163   GList *list;
 164   Object *obj;
 165   Point pos;
 166
 167   list = objects;
 168   while (list != NULL) {
 169     obj = (Object *) list->data;
 170
 171     pos = obj->position;
 172     point_add(&pos, delta);
 173
 174     obj->ops->move(obj, &pos);
 175
 176     list = g_list_next(list);
 177   }
 178 }
 179
 180 void
 181 destroy_object_list(GList *list_to_be_destroyed)
 182 {
 183   GList *list;
 184   Object *obj;
 185
 186   list = list_to_be_destroyed;
 187   while (list != NULL) {
 188     obj = (Object *)list->data;
 189
 190     obj->ops->destroy(obj);
 191     g_free(obj);
 192
 193     list = g_list_next(list);
 194   }
 195
 196   g_list_free(list_to_be_destroyed);
 197 }
 198
 199 void
 200 object_add_handle(Object *obj, Handle *handle)
 201 {
 202   obj->num_handles++;
 203
 204   obj->handles =
 205     g_realloc(obj->handles, obj->num_handles*sizeof(Handle *));
 206
 207   obj->handles[obj->num_handles-1] = handle;
 208 }
 209
 210 void
 211 object_add_handle_at(Object *obj, Handle *handle, int pos)
 212 {
 213   int i;
 214
 215   obj->num_handles++;
 216
 217   obj->handles =
 218     g_realloc(obj->handles, obj->num_handles*sizeof(Handle *));
 219
 220   for (i=obj->num_handles-1; i > pos; i--) {
 221     obj->handles[i] = obj->handles[i-1];
 222   }
 223   obj->handles[pos] = handle;
 224 }
 225
 226 void
 227 object_remove_handle(Object *obj, Handle *handle)
 228 {
 229   int i, handle_nr;
 230
 231   handle_nr = -1;
 232   for (i=0;i<obj->num_handles;i++) {
 233     if (obj->handles[i] == handle)
 234       handle_nr = i;
 235   }
 236
 237   if (handle_nr < 0) {
 238     message_error("Internal error, object_remove_handle: Handle doesn't exist");
 239     return;
 240   }
 241
 242   for (i=handle_nr;i<(obj->num_handles-1);i++) {
 243     obj->handles[i] = obj->handles[i+1];
 244   }
 245   obj->handles[obj->num_handles-1] = NULL;
 246
 247   obj->num_handles--;
 248
 249   obj->handles =
 250     g_realloc(obj->handles, obj->num_handles*sizeof(Handle *));
 251 }
 252
 253 void
 254 object_add_connectionpoint(Object *obj, ConnectionPoint *conpoint)
 255 {
 256   obj->num_connections++;
 257
 258   obj->connections =
 259     g_realloc(obj->connections,
 260               obj->num_connections*sizeof(ConnectionPoint *));
 261
 262   obj->connections[obj->num_connections-1] = conpoint;
 263 }
 264
 265 void
 266 object_add_connectionpoint_at(Object *obj,
 267                               ConnectionPoint *conpoint, int pos)
 268 {
 269   int i;
 270
 271   obj->num_connections++;
 272
 273   obj->connections =
 274     g_realloc(obj->connections,
 275               obj->num_connections*sizeof(ConnectionPoint *));
 276
 277   for (i=obj->num_connections-1; i > pos; i--) {
 278     obj->connections[i] = obj->connections[i-1];
 279   }
 280   obj->connections[pos] = conpoint;
 281 }
 282
 283 void
 284 object_remove_connectionpoint(Object *obj, ConnectionPoint *conpoint)
 285 {
 286   int i, nr;
 287
 288   object_remove_connections_to(conpoint);
 289
 290   nr = -1;
 291   for (i=0;i<obj->num_connections;i++) {
 292     if (obj->connections[i] == conpoint)
 293       nr = i;
 294   }
 295
 296   if (nr < 0) {
 297     message_error("Internal error, object_remove_connectionpoint: "
 298                   "ConnectionPoint doesn't exist");
 299     return;
 300   }
 301
 302   for (i=nr;i<(obj->num_connections-1);i++) {
 303     obj->connections[i] = obj->connections[i+1];
 304   }
 305   obj->connections[obj->num_connections-1] = NULL;
 306
 307   obj->num_connections--;
 308
 309   obj->connections =
 310     g_realloc(obj->connections, obj->num_connections*sizeof(ConnectionPoint *));
 311 }
 312
 313
 314 void
 315 object_connect(Object *obj, Handle *handle,
 316                ConnectionPoint *connectionpoint)
 317 {
 318   if (handle->connect_type==HANDLE_NONCONNECTABLE) {
 319     message_error("Error? trying to connect a non connectable handle.\n"
 320                   "Check this out...\n");
 321     return;
 322   }
 323   handle->connected_to = connectionpoint;
 324   connectionpoint->connected =
 325     g_list_prepend(connectionpoint->connected, obj);
 326 }
 327
 328 void
 329 object_unconnect(Object *connected_obj, Handle *handle)
 330 {
 331   ConnectionPoint *connectionpoint;
 332
 333   connectionpoint = handle->connected_to;
 334
 335   if (connectionpoint!=NULL) {
 336     connectionpoint->connected =
 337       g_list_remove(connectionpoint->connected, connected_obj);
 338     handle->connected_to = NULL;
 339   }
 340 }
 341
 342 void
 343 object_remove_connections_to(ConnectionPoint *conpoint)
 344 {
 345   GList *list;
 346   Object *connected_obj;
 347   int i;
 348
 349   list = conpoint->connected;
 350   while (list != NULL) {
 351     connected_obj = (Object *)list->data;
 352
 353     for (i=0;i<connected_obj->num_handles;i++) {
 354       if (connected_obj->handles[i]->connected_to == conpoint) {
 355         connected_obj->handles[i]->connected_to = NULL;
 356       }
 357     }
 358     list = g_list_next(list);
 359   }
 360   g_list_free(conpoint->connected);
 361   conpoint->connected = NULL;
 362 }
 363
 364 void
 365 object_unconnect_all(Object *obj)
 366 {
 367   int i;
 368
 369   for (i=0;i<obj->num_handles;i++) {
 370     object_unconnect(obj, obj->handles[i]);
 371   }
 372   for (i=0;i<obj->num_connections;i++) {
 373     object_remove_connections_to(obj->connections[i]);
 374   }
 375 }
 376
 377 void object_save(Object *obj, ObjectNode obj_node)
 378 {
 379   data_add_point(new_attribute(obj_node, "obj_pos"),
 380                  &obj->position);
 381   data_add_rectangle(new_attribute(obj_node, "obj_bb"),
 382                      &obj->bounding_box);
 383 }
 384
 385 void object_load(Object *obj, ObjectNode obj_node)
 386 {
 387   AttributeNode attr;
 388
 389   obj->position.x = 0.0;
 390   obj->position.y = 0.0;
 391   attr = object_find_attribute(obj_node, "obj_pos");
 392   if (attr != NULL)
 393     data_point( attribute_first_data(attr), &obj->position );
 394
 395   obj->bounding_box.left = obj->bounding_box.right = 0.0;
 396   obj->bounding_box.top = obj->bounding_box.bottom = 0.0;
 397   attr = object_find_attribute(obj_node, "obj_bb");
 398   if (attr != NULL)
 399     data_rectangle( attribute_first_data(attr), &obj->bounding_box );
 400 }
 401
 402 Layer *dia_object_get_parent_layer(Object *obj) {
 403   return obj->parent_layer;
 404 }
 405
 406 /****** Object register: **********/
 407
 408 static guint hash(gpointer key)
 409 {
 410   char *string = (char *)key;
 411   int sum;
 412
 413   sum = 0;
 414   while (*string) {
 415     sum += (*string);
 416     string++;
 417   }
 418
 419   return sum;
 420 }
 421
 422 static gint compare(gpointer a, gpointer b)
 423 {
 424   return strcmp((char *)a, (char *)b)==0;
 425 }
 426
 427 static GHashTable *object_type_table = NULL;
 428
 429 void
 430 object_registry_init(void)
 431 {
 432   object_type_table = g_hash_table_new( (GHashFunc) hash, (GCompareFunc) compare );
 433 }
 434
 435 void
 436 object_register_type(ObjectType *type)
 437 {
 438   if (g_hash_table_lookup(object_type_table, type->name) != NULL) {
 439     message_warning("Several object-types were named %s.\n"
 440                     "Only first one will be used.\n"
 441                     "Some things might not work as expected.\n",
 442                     type->name);
 443     return;
 444   }
 445   g_hash_table_insert(object_type_table, type->name, type);
 446 }
 447
 448 void
 449 object_registry_foreach (GHFunc func, gpointer user_data)
 450 {
 451   g_hash_table_foreach (object_type_table, func, user_data);
 452 }
 453
 454 ObjectType *
 455 object_get_type(char *name)
 456 {
 457   return (ObjectType *) g_hash_table_lookup(object_type_table, name);
 458 }
 459
 460
 461 int
 462 object_return_false(Object *obj)
 463 {
 464   return FALSE;
 465 }
 466
 467 void *
 468 object_return_null(Object *obj)
 469 {
 470   return NULL;
 471 }
 472
 473 void
 474 object_return_void(Object *obj)
 475 {
 476   return;
 477 }
 478
 479 Object *
 480 object_load_using_properties(const ObjectType *type,
 481                              ObjectNode obj_node, int version,
 482                              const char *filename)
 483 {
 484   Object *obj;
 485   Point startpoint = {0.0,0.0};
 486   Handle *handle1,*handle2;
 487
 488   obj = type->ops->create(&startpoint,NULL, &handle1,&handle2);
 489   object_load_props(obj,obj_node);
 490   return obj;
 491 }
 492
 493 void
 494 object_save_using_properties(Object *obj, ObjectNode obj_node,
 495                              int version, const char *filename)
 496 {
 497   object_save_props(obj,obj_node);
 498 }
 499
 500 Object *object_copy_using_properties(Object *obj)
 501 {
 502   Point startpoint = {0.0,0.0};
 503   Handle *handle1,*handle2;
 504   Object *newobj = obj->type->ops->create(&startpoint,NULL,
 505                                           &handle1,&handle2);
 506   object_copy_props(newobj,obj,FALSE);
 507   return newobj;
 508 }
 509