adg/adg-container.c

   1 /* ADG - Automatic Drawing Generation
   2  * Copyright (C) 2007,2008,2009 Nicola Fontana <ntd at entidi.it>
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library 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 GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  17  * Boston, MA  02110-1301, USA.
  18  */
  19
  20
  21 /**
  22  * SECTION:container
  23  * @title: AdgContainer
  24  * @short_description: Base class for entity that can contain other entities
  25  *
  26  * The #AdgContainer is an entity that can contains more sub-entities.
  27  * Each AdgContainer has its paper matrix (#AdgContainer:paper_matrix) to be
  28  * used on paper-dependent references (such as font and arrow sizes, line
  29  * thickness etc...) and a model matrix usually applied to the model view. See
  30  * http://adg.entidi.com/tutorial/view/3 for details on this topic.
  31  *
  32  * This means an AdgContainer can be thought as a group of entities with the
  33  * same geometrical identity (same scale, reference point ecc...).
  34  */
  35
  36 #include "adg-container.h"
  37 #include "adg-container-private.h"
  38 #include "adg-intl.h"
  39
  40
  41 enum {
  42     PROP_0,
  43     PROP_CHILD,
  44     PROP_MODEL_TRANSFORMATION,
  45     PROP_PAPER_TRANSFORMATION
  46 };
  47
  48 enum {
  49     ADD,
  50     REMOVE,
  51     LAST_SIGNAL
  52 };
  53
  54
  55 static void             get_property            (GObject        *object,
  56                                                  guint           prop_id,
  57                                                  GValue         *value,
  58                                                  GParamSpec     *pspec);
  59 static void             set_property            (GObject        *object,
  60                                                  guint           prop_id,
  61                                                  const GValue   *value,
  62                                                  GParamSpec     *pspec);
  63 static void             dispose                 (GObject        *object);
  64 static const AdgMatrix *get_model_matrix        (AdgEntity      *entity);
  65 static const AdgMatrix *get_paper_matrix        (AdgEntity      *entity);
  66 static void             model_matrix_changed    (AdgEntity      *entity,
  67                                                  AdgMatrix      *parent_matrix);
  68 static void             paper_matrix_changed    (AdgEntity      *entity,
  69                                                  AdgMatrix      *parent_matrix);
  70 static GSList *         get_children            (AdgContainer   *container);
  71 static gboolean         add                     (AdgContainer   *container,
  72                                                  AdgEntity      *entity);
  73 static void             real_add                (AdgContainer   *container,
  74                                                  AdgEntity      *entity,
  75                                                  gpointer        user_data);
  76 static gboolean         remove                  (AdgContainer   *container,
  77                                                  AdgEntity      *entity);
  78 static void             real_remove             (AdgContainer   *container,
  79                                                  AdgEntity      *entity,
  80                                                  gpointer        user_data);
  81 static void             invalidate              (AdgEntity      *entity);
  82 static void             render                  (AdgEntity      *entity,
  83                                                  cairo_t        *cr);
  84
  85 static guint signals[LAST_SIGNAL] = { 0 };
  86
  87
  88 G_DEFINE_TYPE(AdgContainer, adg_container, ADG_TYPE_ENTITY)
  89
  90
  91 static void
  92 adg_container_class_init(AdgContainerClass *klass)
  93 {
  94     GObjectClass *gobject_class;
  95     AdgEntityClass *entity_class;
  96     GParamSpec *param;
  97     GClosure *closure;
  98     GType param_types[1];
  99
 100     gobject_class = (GObjectClass *) klass;
 101     entity_class = (AdgEntityClass *) klass;
 102
 103     g_type_class_add_private(klass, sizeof(AdgContainerPrivate));
 104
 105     gobject_class->get_property = get_property;
 106     gobject_class->set_property = set_property;
 107     gobject_class->dispose = dispose;
 108
 109     entity_class->model_matrix_changed = model_matrix_changed;
 110     entity_class->paper_matrix_changed = paper_matrix_changed;
 111     entity_class->get_model_matrix = get_model_matrix;
 112     entity_class->get_paper_matrix = get_paper_matrix;
 113     entity_class->invalidate = invalidate;
 114     entity_class->render = render;
 115
 116     klass->get_children = get_children;
 117     klass->add = add;
 118     klass->remove = remove;
 119
 120     param = g_param_spec_boxed("child",
 121                                P_("Child"),
 122                                P_("Can be used to add a new child to the container"),
 123                                ADG_TYPE_ENTITY, G_PARAM_WRITABLE);
 124     g_object_class_install_property(gobject_class, PROP_CHILD, param);
 125
 126     param = g_param_spec_boxed("model-transformation",
 127                                P_("The model transformation"),
 128                                P_("The model transformation to be applied to this container and its children entities"),
 129                                ADG_TYPE_MATRIX, G_PARAM_READWRITE);
 130     g_object_class_install_property(gobject_class,
 131                                     PROP_MODEL_TRANSFORMATION, param);
 132
 133     param = g_param_spec_boxed("paper-transformation",
 134                                P_("The paper transformation"),
 135                                P_("The paper transformation to be applied to this container and its children entities"),
 136                                ADG_TYPE_MATRIX, G_PARAM_READWRITE);
 137     g_object_class_install_property(gobject_class,
 138                                     PROP_PAPER_TRANSFORMATION, param);
 139
 140     /**
 141      * AdgContainer::add:
 142      * @container: an #AdgContainer
 143      * @entity: the #AdgEntity to add
 144      *
 145      * Adds @entity to @container.
 146      **/
 147     closure = g_cclosure_new(G_CALLBACK(real_add), (gpointer)0xdeadbeaf, NULL);
 148     param_types[0] = G_TYPE_OBJECT;
 149     signals[ADD] = g_signal_newv("add", ADG_TYPE_CONTAINER,
 150                                  G_SIGNAL_RUN_FIRST, closure, NULL, NULL,
 151                                  g_cclosure_marshal_VOID__OBJECT,
 152                                  G_TYPE_NONE, 1, param_types);
 153
 154     /**
 155      * AdgContainer::remove:
 156      * @container: an #AdgContainer
 157      * @entity: the #AdgEntity to remove
 158      *
 159      * Removes @entity from @container.
 160      **/
 161     closure = g_cclosure_new(G_CALLBACK(real_remove), (gpointer)0xdeadbeaf, NULL);
 162     param_types[0] = G_TYPE_OBJECT;
 163     signals[REMOVE] = g_signal_newv("remove", ADG_TYPE_CONTAINER,
 164                                     G_SIGNAL_RUN_FIRST, closure, NULL, NULL,
 165                                     g_cclosure_marshal_VOID__OBJECT,
 166                                     G_TYPE_NONE, 1, param_types);
 167 }
 168
 169 static void
 170 adg_container_init(AdgContainer *container)
 171 {
 172     AdgContainerPrivate *priv = G_TYPE_INSTANCE_GET_PRIVATE(container,
 173                                                             ADG_TYPE_CONTAINER,
 174                                                             AdgContainerPrivate);
 175
 176     priv->children = NULL;
 177     cairo_matrix_init_identity(&priv->model_transformation);
 178     cairo_matrix_init_identity(&priv->paper_transformation);
 179     cairo_matrix_init_identity(&priv->model_matrix);
 180     cairo_matrix_init_identity(&priv->paper_matrix);
 181
 182     container->priv = priv;
 183 }
 184
 185 static void
 186 get_property(GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
 187 {
 188     AdgContainer *container = (AdgContainer *) object;
 189
 190     switch (prop_id) {
 191     case PROP_MODEL_TRANSFORMATION:
 192         g_value_set_boxed(value, &container->priv->model_transformation);
 193         break;
 194     case PROP_PAPER_TRANSFORMATION:
 195         g_value_set_boxed(value, &container->priv->paper_transformation);
 196         break;
 197     default:
 198         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
 199         break;
 200     }
 201 }
 202
 203 static void
 204 set_property(GObject *object,
 205              guint prop_id, const GValue *value, GParamSpec *pspec)
 206 {
 207     AdgContainer *container = (AdgContainer *) object;
 208
 209     switch (prop_id) {
 210     case PROP_CHILD:
 211         adg_container_add(container, g_value_get_object(value));
 212         break;
 213     case PROP_MODEL_TRANSFORMATION:
 214         adg_matrix_copy(&container->priv->model_transformation,
 215                         g_value_get_boxed(value));
 216         break;
 217     case PROP_PAPER_TRANSFORMATION:
 218         adg_matrix_copy(&container->priv->paper_transformation,
 219                         g_value_get_boxed(value));
 220         break;
 221     default:
 222         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
 223     }
 224 }
 225
 226 static void
 227 dispose(GObject *object)
 228 {
 229     GObjectClass *object_class = (GObjectClass *) adg_container_parent_class;
 230
 231     adg_container_foreach((AdgContainer *) object,
 232                           G_CALLBACK(adg_entity_unparent), NULL);
 233
 234     if (object_class->dispose != NULL)
 235         object_class->dispose(object);
 236 }
 237
 238
 239 static GSList *
 240 get_children(AdgContainer *container)
 241 {
 242     return g_slist_copy(container->priv->children);
 243 }
 244
 245 static gboolean
 246 add(AdgContainer *container, AdgEntity *entity)
 247 {
 248     container->priv->children = g_slist_append(container->priv->children,
 249                                                entity);
 250     return TRUE;
 251 }
 252
 253 static void
 254 real_add(AdgContainer *container, AdgEntity *entity, gpointer user_data)
 255 {
 256     AdgContainer *old_parent;
 257
 258     g_assert(user_data == (gpointer) 0xdeadbeaf);
 259
 260     old_parent = adg_entity_get_parent(entity);
 261
 262     if (old_parent != NULL) {
 263         g_warning("Attempting to add an object with type %s to a container "
 264                   "of type %s, but the object is already inside a container "
 265                   "of type %s.",
 266                   g_type_name(G_OBJECT_TYPE(entity)),
 267                   g_type_name(G_OBJECT_TYPE(container)),
 268                   g_type_name(G_OBJECT_TYPE(old_parent)));
 269         return;
 270     }
 271
 272     if (ADG_CONTAINER_GET_CLASS(container)->add(container, entity))
 273         adg_entity_set_parent(entity, container);
 274     else
 275         g_signal_stop_emission(container, signals[ADD], 0);
 276 }
 277
 278 static gboolean
 279 remove(AdgContainer *container, AdgEntity *entity)
 280 {
 281     GSList *node = g_slist_find(container->priv->children, entity);
 282
 283     if (!node)
 284         return FALSE;
 285
 286     container->priv->children = g_slist_delete_link(container->priv->children,
 287                                                     node);
 288     return TRUE;
 289 }
 290
 291 static void
 292 real_remove(AdgContainer *container, AdgEntity *entity, gpointer user_data)
 293 {
 294     g_assert(user_data == (gpointer) 0xdeadbeaf);
 295
 296     if (ADG_CONTAINER_GET_CLASS(container)->remove(container, entity))
 297         adg_entity_unparent(entity);
 298     else
 299         g_signal_stop_emission(container, signals[REMOVE], 0);
 300 }
 301
 302
 303 static void
 304 model_matrix_changed(AdgEntity *entity, AdgMatrix *parent_matrix)
 305 {
 306     AdgContainer *container;
 307     AdgEntityClass *entity_class;
 308
 309     container = (AdgContainer *) entity;
 310     entity_class = (AdgEntityClass *) adg_container_parent_class;
 311
 312     if (entity_class->model_matrix_changed != NULL)
 313         entity_class->model_matrix_changed(entity, parent_matrix);
 314
 315     if (parent_matrix)
 316         cairo_matrix_multiply(&container->priv->model_matrix,
 317                               &container->priv->model_transformation,
 318                               parent_matrix);
 319     else
 320         adg_matrix_copy(&container->priv->model_matrix,
 321                         &container->priv->model_transformation);
 322
 323     adg_container_propagate_by_name(container, "model-matrix-changed",
 324                                     &container->priv->model_matrix);
 325 }
 326
 327 static void
 328 paper_matrix_changed(AdgEntity *entity, AdgMatrix *parent_matrix)
 329 {
 330     AdgContainer *container;
 331     AdgEntityClass *entity_class;
 332
 333     container = (AdgContainer *) entity;
 334     entity_class = (AdgEntityClass *) adg_container_parent_class;
 335
 336     if (entity_class->paper_matrix_changed != NULL)
 337         entity_class->paper_matrix_changed(entity, parent_matrix);
 338
 339     if (parent_matrix)
 340         cairo_matrix_multiply(&container->priv->paper_matrix,
 341                               &container->priv->paper_transformation,
 342                               parent_matrix);
 343     else
 344         adg_matrix_copy(&container->priv->paper_matrix,
 345                         &container->priv->paper_transformation);
 346
 347     adg_container_propagate_by_name(container, "paper-matrix-changed",
 348                                     &container->priv->paper_matrix);
 349 }
 350
 351 static const AdgMatrix *
 352 get_model_matrix(AdgEntity *entity)
 353 {
 354     AdgContainer *container = (AdgContainer *) entity;
 355
 356     return &container->priv->model_matrix;
 357 }
 358
 359 static const AdgMatrix *
 360 get_paper_matrix(AdgEntity *entity)
 361 {
 362     AdgContainer *container = (AdgContainer *) entity;
 363
 364     return &container->priv->paper_matrix;
 365 }
 366
 367
 368 static void
 369 invalidate(AdgEntity *entity)
 370 {
 371     AdgEntityClass *entity_class = (AdgEntityClass *) adg_container_parent_class;
 372
 373     adg_container_propagate_by_name((AdgContainer *) entity, "invalidate");
 374
 375     if (entity_class->invalidate)
 376         entity_class->invalidate(entity);
 377 }
 378
 379 static void
 380 render(AdgEntity *entity, cairo_t *cr)
 381 {
 382     AdgEntityClass *entity_class = (AdgEntityClass *) adg_container_parent_class;
 383
 384     cairo_set_matrix(cr, adg_entity_get_model_matrix(entity));
 385     adg_container_propagate_by_name((AdgContainer *) entity, "render", cr);
 386
 387     if (entity_class->render)
 388         entity_class->render(entity, cr);
 389 }
 390
 391
 392 /**
 393  * adg_container_new:
 394  *
 395  * Creates a new container entity.
 396  *
 397  * Return value: the newly created entity
 398  **/
 399 AdgEntity *
 400 adg_container_new(void)
 401 {
 402     return (AdgEntity *) g_object_new(ADG_TYPE_CONTAINER, NULL);
 403 }
 404
 405
 406 /**
 407  * adg_container_add:
 408  * @container: an #AdgContainer
 409  * @entity: an #AdgEntity
 410  *
 411  * Emits a #AdgContainer::add signal on @container passing
 412  * @entity as argument.
 413  *
 414  * @entity may be added to only one container at a time; you can't
 415  * place the same entity inside two different containers.
 416  **/
 417 void
 418 adg_container_add(AdgContainer *container, AdgEntity *entity)
 419 {
 420     g_return_if_fail(ADG_IS_CONTAINER(container));
 421     g_return_if_fail(ADG_IS_ENTITY(entity));
 422
 423     g_signal_emit(container, signals[ADD], 0, entity);
 424 }
 425
 426 /**
 427  * adg_container_remove:
 428  * @container: an #AdgContainer
 429  * @entity: an #AdgEntity
 430  *
 431  * Emits a #AdgContainer::remove signal on @container passing
 432  * @entity as argument. @entity must be inside @container.
 433  *
 434  * Note that @container will own a reference to @entity
 435  * and that this may be the last reference held; so removing an
 436  * entity from its container can destroy it.
 437  *
 438  * If you want to use @entity again, you need to add a reference
 439  * to it, using g_object_ref(), before removing it from @container.
 440  *
 441  * If you don't want to use @entity again, it's usually more
 442  * efficient to simply destroy it directly using g_object_unref()
 443  * since this will remove it from the container.
 444  **/
 445 void
 446 adg_container_remove(AdgContainer *container, AdgEntity *entity)
 447 {
 448     g_return_if_fail(ADG_IS_CONTAINER(container));
 449     g_return_if_fail(ADG_IS_ENTITY(entity));
 450
 451     g_signal_emit(container, signals[REMOVE], 0, entity);
 452 }
 453
 454 /**
 455  * adg_container_get_children:
 456  * @container: an #AdgContainer
 457  *
 458  * Gets the children list of @container.
 459  * This list must be manually freed when no longer user.
 460  *
 461  * Returns: a newly allocated #GSList or %NULL on error
 462  **/
 463 GSList *
 464 adg_container_get_children(AdgContainer *container)
 465 {
 466     g_return_val_if_fail(ADG_IS_CONTAINER(container), NULL);
 467
 468     return ADG_CONTAINER_GET_CLASS(container)->get_children(container);
 469 }
 470
 471 /**
 472  * adg_container_foreach:
 473  * @container: an #AdgContainer
 474  * @callback: a callback
 475  * @user_data: callback user data
 476  *
 477  * Invokes @callback on each child of @container.
 478  * The callback should be declared as:
 479  *
 480  * <code>
 481  * void callback(AdgEntity *entity, gpointer user_data);
 482  * </code>
 483  **/
 484 void
 485 adg_container_foreach(AdgContainer *container,
 486                       GCallback callback, gpointer user_data)
 487 {
 488     GSList *children;
 489
 490     g_return_if_fail(ADG_IS_CONTAINER(container));
 491     g_return_if_fail(callback != NULL);
 492
 493     children = adg_container_get_children (container);
 494
 495     while (children) {
 496         if (children->data)
 497             ((void (*) (gpointer, gpointer)) callback) (children->data, user_data);
 498
 499         children = g_slist_delete_link(children, children);
 500     }
 501 }
 502
 503 /**
 504  * adg_container_propagate:
 505  * @container: an #AdgContainer
 506  * @signal_id: the signal id
 507  * @detail: the detail
 508  * @...: parameters to be passed to the signal, followed by a location for
 509  *       the return value. If the return type of the signal is G_TYPE_NONE,
 510  *       the return value location can be omitted.
 511  *
 512  * Emits the specified signal to all the children of @container
 513  * using g_signal_emit_valist() calls.
 514  **/
 515 void
 516 adg_container_propagate(AdgContainer *container,
 517                         guint signal_id, GQuark detail, ...)
 518 {
 519     va_list var_args;
 520
 521     va_start(var_args, detail);
 522     adg_container_propagate_valist(container, signal_id, detail, var_args);
 523     va_end(var_args);
 524 }
 525
 526 /**
 527  * adg_container_propagate_by_name:
 528  * @container: an #AdgContainer
 529  * @detailed_signal: a string of the form "signal-name::detail".
 530  * @...: a list of parameters to be passed to the signal, followed by
 531  *       a location for the return value. If the return type of the signal
 532  *       is G_TYPE_NONE, the return value location can be omitted.
 533  *
 534  * Emits the specified signal to all the children of @container
 535  * using g_signal_emit_valist() calls.
 536  **/
 537 void
 538 adg_container_propagate_by_name(AdgContainer *container,
 539                                 const gchar *detailed_signal, ...)
 540 {
 541     guint   signal_id;
 542     GQuark  detail = 0;
 543     va_list var_args;
 544
 545     if (!g_signal_parse_name(detailed_signal, G_TYPE_FROM_INSTANCE(container),
 546                              &signal_id, &detail, FALSE)) {
 547         g_warning("%s: signal `%s' is invalid for instance `%p'",
 548                   G_STRLOC, detailed_signal, container);
 549         return;
 550     }
 551
 552     va_start(var_args, detailed_signal);
 553     adg_container_propagate_valist(container, signal_id, detail, var_args);
 554     va_end(var_args);
 555 }
 556
 557 /**
 558  * adg_container_propagate_valist:
 559  * @container: an #AdgContainer
 560  * @signal_id: the signal id
 561  * @detail: the detail
 562  * @var_args: a list of parameters to be passed to the signal, followed by a
 563  *            location for the return value. If the return type of the signal
 564  *            is G_TYPE_NONE, the return value location can be omitted.
 565  *
 566  * Emits the specified signal to all the children of @container
 567  * using g_signal_emit_valist() calls.
 568  **/
 569 void
 570 adg_container_propagate_valist(AdgContainer *container,
 571                                guint signal_id, GQuark detail, va_list var_args)
 572 {
 573     GSList *children;
 574     va_list var_copy;
 575
 576     g_return_if_fail(ADG_IS_CONTAINER(container));
 577
 578     children = adg_container_get_children(container);
 579
 580     while (children) {
 581         if (children->data) {
 582             G_VA_COPY(var_copy, var_args);
 583             g_signal_emit_valist(children->data, signal_id, detail, var_copy);
 584         }
 585
 586         children = g_slist_delete_link(children, children);
 587     }
 588 }
 589
 590 /**
 591  * adg_container_get_model_transformation:
 592  * @container: an #AdgContainer
 593  *
 594  * Returns the transformation to be combined with the transformations of the
 595  * parent hierarchy to get the final matrix to be applied in the model space.
 596  *
 597  * Return value: the model transformation
 598  **/
 599 const AdgMatrix *
 600 adg_container_get_model_transformation(AdgContainer *container)
 601 {
 602     g_return_val_if_fail(ADG_IS_CONTAINER(container), NULL);
 603     return &container->priv->model_transformation;
 604 }
 605
 606 /**
 607  * adg_container_set_model_transformation:
 608  * @container: an #AdgContainer
 609  * @transformation: the new model transformation
 610  *
 611  * Sets the transformation to be applied in model space.
 612  **/
 613 void
 614 adg_container_set_model_transformation(AdgContainer *container,
 615                                        const AdgMatrix *transformation)
 616 {
 617     AdgEntity *entity;
 618     AdgEntity *parent;
 619     const AdgMatrix *parent_matrix;
 620
 621     g_return_if_fail(ADG_IS_CONTAINER(container));
 622     g_return_if_fail(transformation != NULL);
 623
 624     entity = (AdgEntity *) container;
 625     parent = (AdgEntity *) adg_entity_get_parent(entity);
 626     parent_matrix = parent ? adg_entity_get_model_matrix(parent) : NULL;
 627
 628     adg_matrix_copy(&container->priv->model_transformation, transformation);
 629     adg_entity_model_matrix_changed(entity, parent_matrix);
 630 }
 631
 632 /**
 633  * adg_container_get_paper_transformation:
 634  * @container: an #AdgContainer
 635  *
 636  * Returns the transformation to be combined with the transformations of the
 637  * parent hierarchy to get the final matrix to be applied in the paper space.
 638  *
 639  * Return value: the paper transformation
 640  **/
 641 const AdgMatrix *
 642 adg_container_get_paper_transformation(AdgContainer *container)
 643 {
 644     g_return_val_if_fail(ADG_IS_CONTAINER(container), NULL);
 645     return &container->priv->paper_transformation;
 646 }
 647
 648 /**
 649  * adg_container_set_paper_transformation:
 650  * @container: an #AdgContainer
 651  * @transformation: the new paper transformation
 652  *
 653  * Sets the transformation to be applied in paper space.
 654  **/
 655 void
 656 adg_container_set_paper_transformation(AdgContainer *container,
 657                                        const AdgMatrix *transformation)
 658 {
 659     AdgEntity *entity;
 660     AdgEntity *parent;
 661     const AdgMatrix *parent_matrix;
 662
 663     g_return_if_fail(ADG_IS_CONTAINER(container));
 664     g_return_if_fail(transformation != NULL);
 665
 666     entity = (AdgEntity *) container;
 667     parent = (AdgEntity *) adg_entity_get_parent(entity);
 668     parent_matrix = parent ? adg_entity_get_paper_matrix(parent) : NULL;
 669
 670     adg_matrix_copy(&container->priv->paper_transformation, transformation);
 671     adg_entity_paper_matrix_changed(entity, parent_matrix);
 672 }