adg/adg-entity.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:adg-entity
  23  * @short_description: The base class for renderable objects
  24  *
  25  * This abstract class provides the base for all renderable objects.
  26  *
  27  * To provide a proper #AdgEntity derived type, you must at least
  28  * implement its arrange() and render() virtual methods. Also, if
  29  * you are using some sort of caching, ensure to clear it in the
  30  * invalidate() method.
  31  **/
  32
  33 /**
  34  * AdgEntity:
  35  *
  36  * All fields are private and should not be used directly.
  37  * Use its public methods instead.
  38  **/
  39
  40 /**
  41  * AdgEntityClass:
  42  * @parent_set: called after the parent has changed
  43  * @invalidate: invalidating callback, used to clear the cache
  44  * @arrange: prepare the layout and fill the extents struct
  45  * @render: rendering callback, it must be implemented
  46  *
  47  * Any entity (if not abstract) must implement at least the @render method.
  48  **/
  49
  50 /**
  51  * AdgEntityCallback:
  52  * @entity: an #AdgEntity
  53  * @user_data: a general purpose pointer
  54  *
  55  * Callback used when inspecting or browsing entities. For example,
  56  * it is passed to adg_model_foreach_dependency() to perform an
  57  * operation on all the entities depending on an #AdgModel.
  58  **/
  59
  60
  61 #include "adg-entity.h"
  62 #include "adg-entity-private.h"
  63 #include "adg-canvas.h"
  64 #include "adg-font-style.h"
  65 #include "adg-dim-style.h"
  66 #include "adg-marshal.h"
  67 #include "adg-intl.h"
  68
  69 #define PARENT_OBJECT_CLASS  ((GObjectClass *) adg_entity_parent_class)
  70
  71
  72 enum {
  73     PROP_0,
  74     PROP_PARENT,
  75     PROP_GLOBAL_MAP,
  76     PROP_LOCAL_MAP,
  77     PROP_LOCAL_METHOD
  78 };
  79
  80 enum {
  81     PARENT_SET,
  82     GLOBAL_CHANGED,
  83     LOCAL_CHANGED,
  84     INVALIDATE,
  85     ARRANGE,
  86     RENDER,
  87     LAST_SIGNAL
  88 };
  89
  90
  91 static void             dispose                 (GObject         *object);
  92 static void             get_property            (GObject         *object,
  93                                                  guint            prop_id,
  94                                                  GValue          *value,
  95                                                  GParamSpec      *pspec);
  96 static void             set_property            (GObject         *object,
  97                                                  guint            prop_id,
  98                                                  const GValue    *value,
  99                                                  GParamSpec      *pspec);
 100 static gboolean         set_parent              (AdgEntity       *entity,
 101                                                  AdgEntity       *parent);
 102 static void             global_changed          (AdgEntity       *entity);
 103 static void             local_changed           (AdgEntity       *entity);
 104 static gboolean         set_global_map          (AdgEntity       *entity,
 105                                                  const AdgMatrix *map);
 106 static gboolean         set_local_map           (AdgEntity       *entity,
 107                                                  const AdgMatrix *map);
 108 static gboolean         set_local_method        (AdgEntity       *entity,
 109                                                  AdgMixMethod     local_method);
 110 static void             real_invalidate         (AdgEntity       *entity);
 111 static void             real_arrange            (AdgEntity       *entity);
 112 static void             real_render             (AdgEntity       *entity,
 113                                                  cairo_t         *cr);
 114
 115 static guint    signals[LAST_SIGNAL] = { 0 };
 116
 117
 118 G_DEFINE_ABSTRACT_TYPE(AdgEntity, adg_entity, G_TYPE_INITIALLY_UNOWNED);
 119
 120
 121 static void
 122 adg_entity_class_init(AdgEntityClass *klass)
 123 {
 124     GObjectClass *gobject_class;
 125     GParamSpec *param;
 126     GClosure *closure;
 127     GType param_types[1];
 128
 129     gobject_class = (GObjectClass *) klass;
 130
 131     g_type_class_add_private(klass, sizeof(AdgEntityPrivate));
 132
 133     gobject_class->dispose = dispose;
 134     gobject_class->get_property = get_property;
 135     gobject_class->set_property = set_property;
 136
 137     klass->parent_set = NULL;
 138     klass->global_changed = global_changed;
 139     klass->local_changed = local_changed;
 140     klass->invalidate = NULL;
 141     klass->arrange= NULL;
 142     klass->render = NULL;
 143
 144     param = g_param_spec_object("parent",
 145                                 P_("Parent Entity"),
 146                                 P_("The parent entity of this entity or NULL if this is a top-level entity"),
 147                                 ADG_TYPE_ENTITY,
 148                                 G_PARAM_READWRITE);
 149     g_object_class_install_property(gobject_class, PROP_PARENT, param);
 150
 151     param = g_param_spec_boxed("global-map",
 152                                P_("Global Map"),
 153                                P_("The transformation to be combined with the parent ones to get the global matrix"),
 154                                ADG_TYPE_MATRIX,
 155                                G_PARAM_READWRITE);
 156     g_object_class_install_property(gobject_class, PROP_GLOBAL_MAP, param);
 157
 158     param = g_param_spec_boxed("local-map",
 159                                P_("Local Map"),
 160                                P_("The local transformation that could be used to compute the local matrix in the way specified by the #AdgEntity:local-method property"),
 161                                ADG_TYPE_MATRIX,
 162                                G_PARAM_READWRITE);
 163     g_object_class_install_property(gobject_class, PROP_LOCAL_MAP, param);
 164
 165     param = g_param_spec_enum("local-method",
 166                               P_("Local Mix Method"),
 167                               P_("Define how the local maps of the entity and its ancestors should be combined to get the local matrix"),
 168                               ADG_TYPE_MIX_METHOD, ADG_MIX_ANCESTORS,
 169                               G_PARAM_READWRITE);
 170     g_object_class_install_property(gobject_class, PROP_LOCAL_METHOD, param);
 171
 172     /**
 173      * AdgEntity::parent-set:
 174      * @entity: an #AdgEntity
 175      * @old_parent: the old parent
 176      *
 177      * Emitted after the parent entity has changed. The new parent
 178      * can be inspected using adg_entity_get_parent().
 179      *
 180      * It is allowed for both old and new parent to be %NULL.
 181      **/
 182     signals[PARENT_SET] = g_signal_new("parent-set",
 183                                        G_OBJECT_CLASS_TYPE(gobject_class),
 184                                        G_SIGNAL_RUN_FIRST,
 185                                        G_STRUCT_OFFSET(AdgEntityClass, parent_set),
 186                                        NULL, NULL,
 187                                        adg_marshal_VOID__OBJECT,
 188                                        G_TYPE_NONE, 1, ADG_TYPE_ENTITY);
 189
 190     /**
 191      * AdgEntity::global-changed
 192      * @entity: an #AdgEntity
 193      *
 194      * Emitted when the global map of @entity or any of its parent
 195      * has changed. The default handler will compute the new global
 196      * matrix, updating the internal cache.
 197      **/
 198     signals[GLOBAL_CHANGED] = g_signal_new("global-changed",
 199                                            G_OBJECT_CLASS_TYPE(gobject_class),
 200                                            G_SIGNAL_RUN_FIRST,
 201                                            G_STRUCT_OFFSET(AdgEntityClass, global_changed),
 202                                            NULL, NULL,
 203                                            adg_marshal_VOID__VOID,
 204                                            G_TYPE_NONE, 0);
 205
 206     /**
 207      * AdgEntity::local-changed
 208      * @entity: an #AdgEntity
 209      *
 210      * Emitted when the local map of @entity or any of its parent
 211      * has changed. The default handler will compute the new local
 212      * matrix, updating the internal cache.
 213      **/
 214     signals[LOCAL_CHANGED] = g_signal_new("local-changed",
 215                                           G_OBJECT_CLASS_TYPE(gobject_class),
 216                                           G_SIGNAL_RUN_FIRST,
 217                                           G_STRUCT_OFFSET(AdgEntityClass, local_changed),
 218                                           NULL, NULL,
 219                                           adg_marshal_VOID__VOID,
 220                                           G_TYPE_NONE, 0);
 221
 222     /**
 223      * AdgEntity::invalidate:
 224      * @entity: an #AdgEntity
 225      *
 226      * Invalidates the whole @entity, that is resets all the cache
 227      * (if present) built during the #AdgEntity::arrange signal.
 228      * The resulting state is a clean entity, similar to what you
 229      * have just before the first rendering.
 230      **/
 231     closure = g_cclosure_new(G_CALLBACK(real_invalidate), NULL, NULL);
 232     signals[INVALIDATE] = g_signal_newv("invalidate", ADG_TYPE_ENTITY,
 233                                         G_SIGNAL_RUN_LAST, closure, NULL, NULL,
 234                                         adg_marshal_VOID__VOID,
 235                                         G_TYPE_NONE, 0, param_types);
 236
 237     /**
 238      * AdgEntity::arrange:
 239      * @entity: an #AdgEntity
 240      *
 241      * Arranges the layout of @entity, updating the cache if necessary,
 242      * and computes the extents of @entity.
 243      **/
 244     closure = g_cclosure_new(G_CALLBACK(real_arrange), NULL, NULL);
 245     signals[ARRANGE] = g_signal_newv("arrange", ADG_TYPE_ENTITY,
 246                                      G_SIGNAL_RUN_LAST, closure, NULL, NULL,
 247                                      adg_marshal_VOID__VOID,
 248                                      G_TYPE_NONE, 0, param_types);
 249     /**
 250      * AdgEntity::render:
 251      * @entity: an #AdgEntity
 252      * @cr: a #cairo_t drawing context
 253      *
 254      * Causes the rendering of @entity on @cr. A render signal will
 255      * automatically emit #AdgEntity::arrange just before the real
 256      * rendering on the cairo context.
 257      **/
 258     closure = g_cclosure_new(G_CALLBACK(real_render), NULL, NULL);
 259     param_types[0] = G_TYPE_POINTER;
 260     signals[RENDER] = g_signal_newv("render", ADG_TYPE_ENTITY,
 261                                     G_SIGNAL_RUN_LAST, closure, NULL, NULL,
 262                                     adg_marshal_VOID__POINTER,
 263                                     G_TYPE_NONE, 1, param_types);
 264 }
 265
 266 static void
 267 adg_entity_init(AdgEntity *entity)
 268 {
 269     AdgEntityPrivate *data = G_TYPE_INSTANCE_GET_PRIVATE(entity,
 270                                                          ADG_TYPE_ENTITY,
 271                                                          AdgEntityPrivate);
 272     data->parent = NULL;
 273     cairo_matrix_init_identity(&data->global_map);
 274     cairo_matrix_init_identity(&data->local_map);
 275     data->local_method = ADG_MIX_ANCESTORS;
 276     data->hash_styles = NULL;
 277     cairo_matrix_init_identity(&data->global_matrix);
 278     cairo_matrix_init_identity(&data->local_matrix);
 279     data->extents.is_defined = FALSE;
 280
 281     entity->data = data;
 282 }
 283
 284 static void
 285 dispose(GObject *object)
 286 {
 287     AdgEntity *entity;
 288     AdgEntityPrivate *data;
 289
 290     entity = (AdgEntity *) object;
 291     data = entity->data;
 292
 293     /* This call will emit a "notify" signal for parent.
 294      * Consequentially, the references to the old parent is dropped. */
 295     adg_entity_set_parent(entity, NULL);
 296
 297     if (data->hash_styles != NULL) {
 298         g_hash_table_destroy(data->hash_styles);
 299         data->hash_styles = NULL;
 300     }
 301
 302     if (PARENT_OBJECT_CLASS->dispose != NULL)
 303         PARENT_OBJECT_CLASS->dispose(object);
 304 }
 305
 306
 307 static void
 308 get_property(GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
 309 {
 310     AdgEntity *entity;
 311     AdgEntityPrivate *data;
 312
 313     entity = (AdgEntity *) object;
 314     data = entity->data;
 315
 316     switch (prop_id) {
 317     case PROP_PARENT:
 318         g_value_set_object(value, data->parent);
 319         break;
 320     case PROP_GLOBAL_MAP:
 321         g_value_set_boxed(value, &data->global_map);
 322         break;
 323     case PROP_LOCAL_MAP:
 324         g_value_set_boxed(value, &data->local_map);
 325         break;
 326     case PROP_LOCAL_METHOD:
 327         g_value_set_enum(value, data->local_method);
 328         break;
 329     default:
 330         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
 331         break;
 332     }
 333 }
 334
 335 static void
 336 set_property(GObject *object,
 337              guint prop_id, const GValue *value, GParamSpec *pspec)
 338 {
 339     AdgEntity *entity;
 340     AdgEntityPrivate *data;
 341
 342     entity = (AdgEntity *) object;
 343     data = entity->data;
 344
 345     switch (prop_id) {
 346     case PROP_PARENT:
 347         set_parent(entity, g_value_get_object(value));
 348         break;
 349     case PROP_GLOBAL_MAP:
 350         set_global_map(entity, g_value_get_boxed(value));
 351         break;
 352     case PROP_LOCAL_MAP:
 353         set_local_map(entity, g_value_get_boxed(value));
 354         break;
 355     case PROP_LOCAL_METHOD:
 356         set_local_method(entity, g_value_get_enum(value));
 357         break;
 358     default:
 359         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
 360         break;
 361     }
 362 }
 363
 364
 365 /**
 366  * adg_entity_get_parent:
 367  * @entity: an #AdgEntity
 368  *
 369  * Gets the parent of @entity.
 370  *
 371  * Returns: the parent entity or %NULL on errors or if @entity is a toplevel
 372  **/
 373 AdgEntity *
 374 adg_entity_get_parent(AdgEntity *entity)
 375 {
 376     AdgEntityPrivate *data;
 377
 378     g_return_val_if_fail(ADG_IS_ENTITY(entity), NULL);
 379
 380     data = entity->data;
 381
 382     return data->parent;
 383 }
 384
 385 /**
 386  * adg_entity_set_parent:
 387  * @entity: an #AdgEntity
 388  * @parent: the parent entity
 389  *
 390  * <note><para>
 391  * This function is only useful in entity implementations.
 392  * </para></note>
 393  *
 394  * Sets a new parent on @entity.
 395  **/
 396 void
 397 adg_entity_set_parent(AdgEntity *entity, AdgEntity *parent)
 398 {
 399     g_return_if_fail(ADG_IS_ENTITY(entity));
 400
 401     if (set_parent(entity, parent))
 402         g_object_notify((GObject *) entity, "parent");
 403 }
 404
 405 /**
 406  * adg_entity_get_canvas:
 407  * @entity: an #AdgEntity
 408  *
 409  * Walks on the @entity hierarchy and gets the first parent of @entity that is
 410  * of #AdgCanvas derived type.
 411  *
 412  * Returns: the requested canvas or %NULL on errors or if there is
 413  *          no #AdgCanvas in the @entity hierarchy
 414  **/
 415 AdgCanvas *
 416 adg_entity_get_canvas(AdgEntity *entity)
 417 {
 418     g_return_val_if_fail(ADG_IS_ENTITY(entity), NULL);
 419
 420     while (entity) {
 421         if (ADG_IS_CANVAS(entity))
 422             return (AdgCanvas *) entity;
 423
 424         entity = (AdgEntity *) adg_entity_get_parent(entity);
 425     }
 426
 427     return NULL;
 428 }
 429
 430 /**
 431  * adg_entity_get_global_map:
 432  * @entity: an #AdgEntity object
 433  * @map: where to store the global map
 434  *
 435  * Gets the transformation to be used to compute the global matrix
 436  * of @entity and store it in @map.
 437  **/
 438 void
 439 adg_entity_get_global_map(AdgEntity *entity, AdgMatrix *map)
 440 {
 441     AdgEntityPrivate *data;
 442
 443     g_return_if_fail(ADG_IS_ENTITY(entity));
 444     g_return_if_fail(map != NULL);
 445
 446     data = entity->data;
 447     adg_matrix_copy(map, &data->global_map);
 448 }
 449
 450 /**
 451  * adg_entity_set_global_map:
 452  * @entity: an #AdgEntity object
 453  * @map: the new map
 454  *
 455  * Sets the new global transformation of @entity to @map:
 456  * the old map is discarded. If @map is %NULL an identity
 457  * matrix is implied.
 458  **/
 459 void
 460 adg_entity_set_global_map(AdgEntity *entity, const AdgMatrix *map)
 461 {
 462     g_return_if_fail(ADG_IS_ENTITY(entity));
 463
 464     if (set_global_map(entity, map))
 465         g_object_notify((GObject *) entity, "global-map");
 466 }
 467
 468 /**
 469  * adg_entity_transform_global_map:
 470  * @entity: an #AdgEntity object
 471  * @transformation: the transformation to apply
 472  * @mode: how @transformation should be applied
 473  *
 474  * Convenient function to change the global map of @entity by
 475  * applying @tranformation using the @mode operator. This is
 476  * logically equivalent to the following:
 477  *
 478  * |[
 479  * AdgMatrix tmp_map;
 480  * adg_entity_get_global_map(entity, &tmp_map);
 481  * adg_matrix_transform(&tmp_map, transformation, mode);
 482  * adg_entity_set_global_map(entity, &tmp_map);
 483  * ]|
 484  **/
 485 void
 486 adg_entity_transform_global_map(AdgEntity *entity,
 487                                 const AdgMatrix *transformation,
 488                                 AdgTransformMode mode)
 489 {
 490     AdgEntityPrivate *data;
 491     AdgMatrix map;
 492
 493     g_return_if_fail(ADG_IS_ENTITY(entity));
 494     g_return_if_fail(transformation != NULL);
 495
 496     data = entity->data;
 497
 498     adg_matrix_copy(&map, &data->global_map);
 499     adg_matrix_transform(&map, transformation, mode);
 500
 501     if (set_global_map(entity, &map))
 502         g_object_notify((GObject *) entity, "global-map");
 503 }
 504
 505 /**
 506  * adg_entity_get_local_map:
 507  * @entity: an #AdgEntity object
 508  * @map: where to store the local map
 509  *
 510  * Gets the transformation to be used to compute the local matrix
 511  * of @entity and store it in @map.
 512  **/
 513 void
 514 adg_entity_get_local_map(AdgEntity *entity, AdgMatrix *map)
 515 {
 516     AdgEntityPrivate *data;
 517
 518     g_return_if_fail(ADG_IS_ENTITY(entity));
 519     g_return_if_fail(map != NULL);
 520
 521     data = entity->data;
 522
 523     adg_matrix_copy(map, &data->local_map);
 524 }
 525
 526 /**
 527  * adg_entity_set_local_map:
 528  * @entity: an #AdgEntity object
 529  * @map: the new map
 530  *
 531  * Sets the new local transformation of @entity to @map:
 532  * the old map is discarded. If @map is %NULL an identity
 533  * matrix is implied.
 534  **/
 535 void
 536 adg_entity_set_local_map(AdgEntity *entity, const AdgMatrix *map)
 537 {
 538     g_return_if_fail(ADG_IS_ENTITY(entity));
 539
 540     if (set_local_map(entity, map))
 541         g_object_notify((GObject *) entity, "local-map");
 542 }
 543
 544 /**
 545  * adg_entity_transform_local_map:
 546  * @entity: an #AdgEntity object
 547  * @transformation: the transformation to apply
 548  * @mode: how @transformation should be applied
 549  *
 550  * Convenient function to change the local map of @entity by
 551  * applying @tranformation using the @mode operator. This is
 552  * logically equivalent to the following:
 553  *
 554  * |[
 555  * AdgMatrix tmp_map;
 556  * adg_entity_get_local_map(entity, &tmp_map);
 557  * adg_matrix_transform(&tmp_map, transformation, mode);
 558  * adg_entity_set_local_map(entity, &tmp_map);
 559  * ]|
 560  **/
 561 void
 562 adg_entity_transform_local_map(AdgEntity *entity,
 563                                const AdgMatrix *transformation,
 564                                AdgTransformMode mode)
 565 {
 566     AdgEntityPrivate *data;
 567     AdgMatrix map;
 568
 569     g_return_if_fail(ADG_IS_ENTITY(entity));
 570     g_return_if_fail(transformation != NULL);
 571
 572     data = entity->data;
 573
 574     adg_matrix_copy(&map, &data->local_map);
 575     adg_matrix_transform(&map, transformation, mode);
 576
 577     if (set_local_map(entity, &map))
 578         g_object_notify((GObject *) entity, "local-map");
 579 }
 580
 581 /**
 582  * adg_entity_get_local_method:
 583  * @entity: an #AdgEntity object
 584  *
 585  * Gets the local mix method of @entity. Check out the
 586  * adg_entity_set_local_method() documentation to know what the
 587  * local method is used for.
 588  *
 589  * Returns: the local method of @entity or %ADG_MIX_UNDEFINED on errors
 590  **/
 591 AdgMixMethod
 592 adg_entity_get_local_method(AdgEntity *entity)
 593 {
 594     AdgEntityPrivate *data;
 595
 596     g_return_val_if_fail(ADG_IS_ENTITY(entity), ADG_MIX_UNDEFINED);
 597
 598     data = entity->data;
 599
 600     return data->local_method;
 601 }
 602
 603 /**
 604  * adg_entity_set_local_method:
 605  * @entity: an #AdgEntity object
 606  * @local_method: new method
 607  *
 608  * Sets a new local mix method on @entity. The
 609  * #AdgEntity:local-method property defines how the local
 610  * matrix must be computed: check out the #AdgMixMethod
 611  * documentation to know what are the availables methods
 612  * and how they affect the local matrix computation.
 613  *
 614  * Setting a different local method emits an #Adgentity::local-changed
 615  * signal on @entity.
 616  **/
 617 void
 618 adg_entity_set_local_method(AdgEntity *entity, AdgMixMethod local_method)
 619 {
 620     g_return_if_fail(ADG_IS_ENTITY(entity));
 621
 622     if (set_local_method(entity, local_method))
 623         g_object_notify((GObject *) entity, "local-method");
 624 }
 625
 626 /**
 627  * adg_entity_extents:
 628  * @entity: an #AdgEntity
 629  *
 630  * Gets the bounding box of @entity. The returned struct is
 631  * owned by @entity and should not modified or freed.
 632  *
 633  * This struct specifies the surface portion (in global space
 634  * of @entity) occupied by the entity without taking into
 635  * account rendering properties such as line thickness or caps.
 636  *
 637  * The #AdgEntity::arrange signal should be emitted before
 638  * this call (either explicitely trought adg_entity_arrange()
 639  * or implicitely with adg_entity_render()) in order to get
 640  * an up to date boundary box.
 641  *
 642  * Returns: the bounding box of @entity or %NULL on errors
 643  **/
 644 const CpmlExtents *
 645 adg_entity_extents(AdgEntity *entity)
 646 {
 647     AdgEntityPrivate *data;
 648
 649     g_return_val_if_fail(ADG_IS_ENTITY(entity), NULL);
 650
 651     data = entity->data;
 652
 653     return &data->extents;
 654 }
 655
 656 /**
 657  * adg_entity_set_extents:
 658  * @entity: an #AdgEntity
 659  * @extents: the new extents
 660  *
 661  * <note><para>
 662  * This function is only useful in entity implementations.
 663  * </para></note>
 664  *
 665  * Sets a new bounding box for @entity. @extents can be %NULL,
 666  * in which case the extents are unset.
 667  **/
 668 void
 669 adg_entity_set_extents(AdgEntity *entity, const CpmlExtents *extents)
 670 {
 671     AdgEntityPrivate *data;
 672
 673     g_return_if_fail(ADG_IS_ENTITY(entity));
 674
 675     data = entity->data;
 676
 677     if (extents == NULL)
 678         data->extents.is_defined = FALSE;
 679     else
 680         cpml_extents_copy(&data->extents, extents);
 681 }
 682
 683 /**
 684  * adg_entity_style:
 685  * @entity: an #AdgEntity
 686  * @dress: the dress of the style to get
 687  *
 688  * Gets the style to be used for @entity. @dress specifies which
 689  * "family" of style to get.
 690  *
 691  * The following sequence of checks is performed to get the proper
 692  * style, stopping at the first succesfull result:
 693  *
 694  * <orderedlist>
 695  * <listitem>check if the style is directly overriden by this entity,
 696  *           as returned by adg_entity_get_style();</listitem>
 697  * <listitem>check if @entity has a parent, in which case returns the
 698  *           adg_entity_style() of the parent;</listitem>
 699  * <listitem>returns the main style with adg_dress_get_fallback().</listitem>
 700  * </orderedlist>
 701  *
 702  * Returns: the requested style or %NULL for transparent dresses or errors
 703  **/
 704 AdgStyle *
 705 adg_entity_style(AdgEntity *entity, AdgDress dress)
 706 {
 707     AdgStyle *style;
 708
 709     g_return_val_if_fail(ADG_IS_ENTITY(entity), NULL);
 710
 711     style = adg_entity_get_style(entity, dress);
 712
 713     if (style == NULL) {
 714         AdgEntityPrivate *data = entity->data;
 715
 716         if (data->parent != NULL)
 717             style = adg_entity_style(data->parent, dress);
 718         else
 719             style = adg_dress_get_fallback(dress);
 720     }
 721
 722     return style;
 723 }
 724
 725 /**
 726  * adg_entity_get_style:
 727  * @entity: an #AdgEntity
 728  * @dress: the dress of the style to get
 729  *
 730  * Gets the overriden @dress style from @entity. This is a kind
 731  * of accessor function: to get the style to be used for rendering
 732  * purpose, use adg_entity_style() instead.
 733  *
 734  * Returns: the requested style or %NULL if the @dress style
 735  *          is not overriden
 736  **/
 737 AdgStyle *
 738 adg_entity_get_style(AdgEntity *entity, AdgDress dress)
 739 {
 740     AdgEntityPrivate *data;
 741
 742     g_return_val_if_fail(ADG_IS_ENTITY(entity), NULL);
 743
 744     data = entity->data;
 745
 746     if (data->hash_styles == NULL)
 747         return NULL;
 748
 749     return g_hash_table_lookup(data->hash_styles, GINT_TO_POINTER(dress));
 750 }
 751
 752 /**
 753  * adg_entity_set_style:
 754  * @entity: an #AdgEntity
 755  * @dress: a dress style
 756  * @style: the new style to use
 757  *
 758  * Overrides the style of @dress for @entity and its children.
 759  * If @style is %NULL, any previous override is removed.
 760  *
 761  * The new style must still be compatible with @dress: check out
 762  * the adg_dress_style_is_compatible() documentation to know
 763  * what a compatible style means.
 764  **/
 765 void
 766 adg_entity_set_style(AdgEntity *entity, AdgDress dress, AdgStyle *style)
 767 {
 768     AdgEntityPrivate *data;
 769     gpointer p_dress;
 770     AdgStyle *old_style;
 771
 772     g_return_if_fail(ADG_IS_ENTITY(entity));
 773
 774     data = entity->data;
 775
 776     if (data->hash_styles == NULL && style == NULL)
 777         return;
 778
 779     if (data->hash_styles == NULL)
 780         data->hash_styles = g_hash_table_new_full(NULL, NULL,
 781                                                   NULL, g_object_unref);
 782
 783     p_dress = GINT_TO_POINTER(dress);
 784     old_style = g_hash_table_lookup(data->hash_styles, p_dress);
 785
 786     if (style == old_style)
 787         return;
 788
 789     if (style == NULL) {
 790         g_hash_table_remove(data->hash_styles, p_dress);
 791         return;
 792     }
 793
 794     if (!adg_dress_style_is_compatible(dress, style)) {
 795         GType ancestor_type = adg_dress_get_ancestor_type(dress);
 796
 797         g_warning(_("%s: `%s' is not compatible with `%s' for `%s' dress"),
 798                   G_STRLOC, g_type_name(G_TYPE_FROM_INSTANCE(style)),
 799                   g_type_name(ancestor_type), adg_dress_name(dress));
 800
 801         return;
 802     }
 803
 804     g_object_ref(style);
 805     g_hash_table_replace(data->hash_styles, p_dress, style);
 806 }
 807
 808 /**
 809  * adg_entity_apply_dress:
 810  * @entity: an #AdgEntity
 811  * @dress: the dress style to apply
 812  * @cr: a #cairo_t drawing context
 813  *
 814  * Convenient function to apply a @dress style (as returned by
 815  * adg_entity_style()) to the @cr cairo context.
 816  **/
 817 void
 818 adg_entity_apply_dress(AdgEntity *entity, AdgDress dress, cairo_t *cr)
 819 {
 820     AdgStyle *style;
 821
 822     g_return_if_fail(ADG_IS_ENTITY(entity));
 823     g_return_if_fail(cr != NULL);
 824
 825     style = adg_entity_style(entity, dress);
 826
 827     if (style != NULL)
 828         adg_style_apply(style, entity, cr);
 829 }
 830
 831 /**
 832  * adg_entity_global_changed:
 833  * @entity: an #AdgEntity
 834  *
 835  * Emits the #AdgEntity::global-changed signal on @entity and on all of
 836  * its children, if any.
 837  **/
 838 void
 839 adg_entity_global_changed(AdgEntity *entity)
 840 {
 841     g_return_if_fail(ADG_IS_ENTITY(entity));
 842
 843     g_signal_emit(entity, signals[GLOBAL_CHANGED], 0);
 844 }
 845
 846 /**
 847  * adg_entity_local_changed:
 848  * @entity: an #AdgEntity
 849  *
 850  * Emits the #AdgEntity::local-changed signal on @entity and on all of
 851  * its children, if any.
 852  **/
 853 void
 854 adg_entity_local_changed(AdgEntity *entity)
 855 {
 856     g_return_if_fail(ADG_IS_ENTITY(entity));
 857
 858     g_signal_emit(entity, signals[LOCAL_CHANGED], 0);
 859 }
 860
 861 /**
 862  * adg_entity_global_matrix:
 863  * @entity: an #AdgEntity object
 864  *
 865  * Gets the global matrix by combining all the global maps of the
 866  * @entity hierarchy using the %ADG_MIX_ANCESTORS method. The
 867  * returned value is owned by @entity and should not be changed
 868  * or freed.
 869  *
 870  * Returns: the global matrix or %NULL on errors
 871  **/
 872 const AdgMatrix *
 873 adg_entity_global_matrix(AdgEntity *entity)
 874 {
 875     AdgEntityPrivate *data;
 876
 877     g_return_val_if_fail(ADG_IS_ENTITY(entity), NULL);
 878
 879     data = entity->data;
 880
 881     return &data->global_matrix;
 882 }
 883
 884 /**
 885  * adg_entity_local_matrix:
 886  * @entity: an #AdgEntity object
 887  * @matrix: where to store the local matrix
 888  *
 889  * Gets the local matrix of @entity in the way specified by the
 890  * #AdgEntity:local-method property. The returned value is owned
 891  * by @entity and should not be changed or freed.
 892  *
 893  * Returns: the local matrix or %NULL on errors
 894  **/
 895 const AdgMatrix *
 896 adg_entity_local_matrix(AdgEntity *entity)
 897 {
 898     AdgEntityPrivate *data;
 899
 900     g_return_val_if_fail(ADG_IS_ENTITY(entity), NULL);
 901
 902     data = entity->data;
 903
 904     return &data->local_matrix;
 905 }
 906
 907 /**
 908  * adg_entity_ctm:
 909  * @entity: an #AdgEntity object
 910  *
 911  * Returns the current transformation matrix (ctm) of @entity
 912  * by applying the global matrix above the local matrix. This
 913  * is roughly equivalent to the following pseudo code:
 914  *
 915  * |[
 916  * cairo_matrix_multiply(ctm, local_matrix, global_matrix);
 917  * ]|
 918  *
 919  * This method is only useful inside or after the #AdgEntity::arrange
 920  * default signal handler has been called, that is at the arranging
 921  * or rendering stage. In the other cases, the returned matrix will
 922  * luckely be not up to date.
 923  *
 924  * Returns: the current transformation matrix or %NULL on errors
 925  **/
 926 const AdgMatrix *
 927 adg_entity_ctm(AdgEntity *entity)
 928 {
 929     AdgEntityPrivate *data;
 930
 931     g_return_val_if_fail(ADG_IS_ENTITY(entity), NULL);
 932
 933     data = entity->data;
 934
 935     return &data->ctm;
 936 }
 937
 938 /**
 939  * adg_entity_invalidate:
 940  * @entity: an #AdgEntity
 941  *
 942  * Emits the #AdgEntity::invalidate signal on @entity and on all of
 943  * its children, if any, clearing the eventual cache stored by the
 944  * #AdgEntity::arrange signal and setting the entity state similary
 945  * to the just initialized entity.
 946  **/
 947 void
 948 adg_entity_invalidate(AdgEntity *entity)
 949 {
 950     g_return_if_fail(ADG_IS_ENTITY(entity));
 951
 952     g_signal_emit(entity, signals[INVALIDATE], 0);
 953 }
 954
 955 /**
 956  * adg_entity_arrange:
 957  * @entity: an #AdgEntity
 958  *
 959  * Emits the #AdgEntity::arrange signal on @entity and all its children,
 960  * if any. This function is rarely needed as the arrange call is usually
 961  * implicitely called by the #AdgEntity::render signal or iby a call to
 962  * adg_entity_get_extents().
 963  **/
 964 void
 965 adg_entity_arrange(AdgEntity *entity)
 966 {
 967     g_return_if_fail(ADG_IS_ENTITY(entity));
 968
 969     g_signal_emit(entity, signals[ARRANGE], 0);
 970 }
 971
 972 /**
 973  * adg_entity_render:
 974  * @entity: an #AdgEntity
 975  * @cr: a #cairo_t drawing context
 976  *
 977  * Emits the #AdgEntity::render signal on @entity and on all of its
 978  * children, if any, causing the rendering to the @cr cairo context.
 979  **/
 980 void
 981 adg_entity_render(AdgEntity *entity, cairo_t *cr)
 982 {
 983     g_return_if_fail(ADG_IS_ENTITY(entity));
 984
 985     g_signal_emit(entity, signals[RENDER], 0, cr);
 986 }
 987
 988
 989 static gboolean
 990 set_parent(AdgEntity *entity, AdgEntity *parent)
 991 {
 992     AdgEntityPrivate *data;
 993     AdgEntity *old_parent;
 994
 995     data = entity->data;
 996     old_parent = data->parent;
 997
 998     /* Check if parent has changed */
 999     if (parent == old_parent)
1000         return FALSE;
1001
1002     if (parent != NULL)
1003         g_object_ref(parent);
1004
1005     data->parent = parent;
1006
1007     g_signal_emit(entity, signals[PARENT_SET], 0, old_parent);
1008     g_signal_emit(entity, signals[GLOBAL_CHANGED], 0);
1009     g_signal_emit(entity, signals[LOCAL_CHANGED], 0);
1010
1011     if (old_parent != NULL)
1012         g_object_unref(old_parent);
1013
1014     return TRUE;
1015 }
1016
1017 static void
1018 global_changed(AdgEntity *entity)
1019 {
1020     AdgEntityPrivate *data;
1021     AdgMatrix *map, *matrix;
1022
1023     data = entity->data;
1024     map = &data->global_map;
1025     matrix = &data->global_matrix;
1026
1027     if (data->parent == NULL) {
1028         adg_matrix_copy(matrix, map);
1029     } else {
1030         adg_matrix_copy(matrix, adg_entity_global_matrix(data->parent));
1031         adg_matrix_transform(matrix, map, ADG_TRANSFORM_AFTER);
1032     }
1033 }
1034
1035 static void
1036 local_changed(AdgEntity *entity)
1037 {
1038     AdgEntityPrivate *data;
1039     AdgMatrix *matrix;
1040
1041     data = entity->data;
1042     matrix = &data->local_matrix;
1043
1044     switch (data->local_method) {
1045     case ADG_MIX_DISABLED:
1046         adg_matrix_copy(matrix, adg_matrix_identity());
1047         break;
1048     case ADG_MIX_NONE:
1049         adg_matrix_copy(matrix, &data->local_map);
1050         break;
1051     case ADG_MIX_ANCESTORS:
1052         if (data->parent != NULL) {
1053             adg_matrix_copy(matrix, adg_entity_local_matrix(data->parent));
1054             adg_matrix_transform(matrix, &data->local_map, ADG_TRANSFORM_AFTER);
1055         } else {
1056             adg_matrix_copy(matrix, &data->local_map);
1057         }
1058         break;
1059     case ADG_MIX_ANCESTORS_NORMALIZED:
1060         if (data->parent != NULL) {
1061             adg_matrix_copy(matrix, adg_entity_local_matrix(data->parent));
1062             adg_matrix_transform(matrix, &data->local_map, ADG_TRANSFORM_AFTER);
1063         } else {
1064             adg_matrix_copy(matrix, &data->local_map);
1065         }
1066         adg_matrix_normalize(matrix);
1067         break;
1068     case ADG_MIX_PARENT:
1069         if (data->parent != NULL) {
1070             adg_entity_get_local_map(data->parent, matrix);
1071             adg_matrix_transform(matrix, &data->local_map, ADG_TRANSFORM_AFTER);
1072         } else {
1073             adg_matrix_copy(matrix, &data->local_map);
1074         }
1075         break;
1076     case ADG_MIX_PARENT_NORMALIZED:
1077         if (data->parent != NULL) {
1078             adg_entity_get_local_map(data->parent, matrix);
1079             adg_matrix_transform(matrix, &data->local_map, ADG_TRANSFORM_AFTER);
1080         } else {
1081             adg_matrix_copy(matrix, &data->local_map);
1082         }
1083         adg_matrix_normalize(matrix);
1084         break;
1085     case ADG_MIX_UNDEFINED:
1086         g_warning(_("%s: requested to mix the maps using an undefined method"),
1087                   G_STRLOC);
1088         break;
1089     default:
1090         g_assert_not_reached();
1091         break;
1092     }
1093 }
1094
1095 static gboolean
1096 set_global_map(AdgEntity *entity, const AdgMatrix *map)
1097 {
1098     AdgEntityPrivate *data = entity->data;
1099
1100     if (map != NULL && adg_matrix_equal(&data->global_map, map))
1101         return FALSE;
1102
1103     if (map == NULL)
1104         cairo_matrix_init_identity(&data->global_map);
1105     else
1106         adg_matrix_copy(&data->global_map, map);
1107
1108     g_signal_emit(entity, signals[GLOBAL_CHANGED], 0);
1109     return TRUE;
1110 }
1111
1112 static gboolean
1113 set_local_map(AdgEntity *entity, const AdgMatrix *map)
1114 {
1115     AdgEntityPrivate *data = entity->data;
1116
1117     if (map != NULL && adg_matrix_equal(&data->local_map, map))
1118         return FALSE;
1119
1120     if (map == NULL)
1121         cairo_matrix_init_identity(&data->local_map);
1122     else
1123         adg_matrix_copy(&data->local_map, map);
1124
1125     g_signal_emit(entity, signals[LOCAL_CHANGED], 0);
1126     return TRUE;
1127 }
1128
1129 static gboolean
1130 set_local_method(AdgEntity *entity, AdgMixMethod local_method)
1131 {
1132     AdgEntityPrivate *data = entity->data;
1133
1134     if (data->local_method == local_method)
1135         return FALSE;
1136
1137     data->local_method = local_method;
1138     g_signal_emit(entity, signals[LOCAL_CHANGED], 0);
1139
1140     return TRUE;
1141 }
1142
1143 static void
1144 real_invalidate(AdgEntity *entity)
1145 {
1146     AdgEntityPrivate *data = entity->data;
1147     AdgEntityClass *klass = ADG_ENTITY_GET_CLASS(entity);
1148
1149     if (klass->invalidate == NULL) {
1150         /* Do not raise any warning if invalidate() is not defined,
1151          * assuming entity does not have cache to be cleared */
1152     } else {
1153         klass->invalidate(entity);
1154     }
1155
1156     data->extents.is_defined = FALSE;
1157 }
1158
1159 static void
1160 real_arrange(AdgEntity *entity)
1161 {
1162     AdgEntityClass *klass = ADG_ENTITY_GET_CLASS(entity);
1163
1164     if (klass->arrange == NULL) {
1165         /* The arrange() method must be defined */
1166         g_warning(_("%s: `arrange' method not implemented for type `%s'"),
1167                   G_STRLOC, g_type_name(G_OBJECT_TYPE(entity)));
1168     } else {
1169         AdgEntityPrivate *data;
1170         AdgMatrix *ctm;
1171
1172         data = entity->data;
1173         ctm = &data->ctm;
1174
1175         /* Update the ctm (current transformation matrix) */
1176         adg_matrix_copy(ctm, &data->global_matrix);
1177         adg_matrix_transform(ctm, &data->local_matrix, ADG_TRANSFORM_BEFORE);
1178
1179         klass->arrange(entity);
1180     }
1181 }
1182
1183 static void
1184 real_render(AdgEntity *entity, cairo_t *cr)
1185 {
1186     AdgEntityPrivate *data = entity->data;
1187     AdgEntityClass *klass = ADG_ENTITY_GET_CLASS(entity);
1188
1189     if (klass->render == NULL) {
1190         /* The render method must be defined */
1191         g_warning(_("%s: `render' method not implemented for type `%s'"),
1192                   G_STRLOC, g_type_name(G_OBJECT_TYPE(entity)));
1193     } else {
1194         /* Before the rendering, the entity should be arranged */
1195         g_signal_emit(entity, signals[ARRANGE], 0);
1196
1197         cairo_save(cr);
1198         cairo_set_matrix(cr, &data->global_matrix);
1199         klass->render(entity, cr);
1200         cairo_restore(cr);
1201     }
1202 }