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 the render() virtual method. Also, if you are using
  29  * some sort of caching, you must implement invalidate() to clear
  30  * this cache.
  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  * @render: rendering callback, it must be implemented
  45  *
  46  * Any entity (if not abstract) must implement at least the @render method.
  47  **/
  48
  49
  50 #include "adg-entity.h"
  51 #include "adg-entity-private.h"
  52 #include "adg-canvas.h"
  53 #include "adg-font-style.h"
  54 #include "adg-dim-style.h"
  55 #include "adg-intl.h"
  56
  57 #define PARENT_OBJECT_CLASS  ((GObjectClass *) adg_entity_parent_class)
  58
  59
  60 enum {
  61     PROP_0,
  62     PROP_PARENT,
  63     PROP_GLOBAL_MAP,
  64     PROP_LOCAL_MAP
  65 };
  66
  67 enum {
  68     PARENT_SET,
  69     INVALIDATE,
  70     RENDER,
  71     LAST_SIGNAL
  72 };
  73
  74
  75 static void             dispose                 (GObject         *object);
  76 static void             get_property            (GObject         *object,
  77                                                  guint            prop_id,
  78                                                  GValue          *value,
  79                                                  GParamSpec      *pspec);
  80 static void             set_property            (GObject         *object,
  81                                                  guint            prop_id,
  82                                                  const GValue    *value,
  83                                                  GParamSpec      *pspec);
  84 static gboolean         set_parent              (AdgEntity       *entity,
  85                                                  AdgEntity       *parent);
  86 static void             set_global_map          (AdgEntity       *entity,
  87                                                  const AdgMatrix *map);
  88 static void             set_local_map           (AdgEntity       *entity,
  89                                                  const AdgMatrix *map);
  90 static void             get_global_matrix       (AdgEntity       *entity,
  91                                                  AdgMatrix       *matrix);
  92 static void             get_local_matrix        (AdgEntity       *entity,
  93                                                  AdgMatrix       *matrix);
  94 static void             real_invalidate         (AdgEntity       *entity,
  95                                                  gpointer         user_data);
  96 static void             real_render             (AdgEntity       *entity,
  97                                                  cairo_t         *cr,
  98                                                  gpointer         user_data);
  99
 100 static guint signals[LAST_SIGNAL] = { 0 };
 101
 102
 103 G_DEFINE_ABSTRACT_TYPE(AdgEntity, adg_entity, G_TYPE_INITIALLY_UNOWNED);
 104
 105
 106 static void
 107 adg_entity_class_init(AdgEntityClass *klass)
 108 {
 109     GObjectClass *gobject_class;
 110     GParamSpec *param;
 111     GClosure *closure;
 112     GType param_types[1];
 113
 114     gobject_class = (GObjectClass *) klass;
 115
 116     g_type_class_add_private(klass, sizeof(AdgEntityPrivate));
 117
 118     gobject_class->dispose = dispose;
 119     gobject_class->get_property = get_property;
 120     gobject_class->set_property = set_property;
 121
 122     klass->parent_set = NULL;
 123     klass->get_global_matrix = get_global_matrix;
 124     klass->get_local_matrix = get_local_matrix;
 125     klass->invalidate = NULL;
 126     klass->render = NULL;
 127
 128     param = g_param_spec_object("parent",
 129                                 P_("Parent Entity"),
 130                                 P_("The parent entity of this entity or NULL if this is a top-level entity"),
 131                                 ADG_TYPE_ENTITY, G_PARAM_READWRITE);
 132     g_object_class_install_property(gobject_class, PROP_PARENT, param);
 133
 134     param = g_param_spec_boxed("global-map",
 135                                P_("Global Map"),
 136                                P_("The transformation to be combined with the parent ones to get the global matrix"),
 137                                ADG_TYPE_MATRIX, G_PARAM_READWRITE);
 138     g_object_class_install_property(gobject_class, PROP_GLOBAL_MAP, param);
 139
 140     param = g_param_spec_boxed("local-map",
 141                                P_("Local Map"),
 142                                P_("The transformation to be combined with the parent ones to get the local matrix"),
 143                                ADG_TYPE_MATRIX, G_PARAM_READWRITE);
 144     g_object_class_install_property(gobject_class, PROP_LOCAL_MAP, param);
 145
 146     /**
 147      * AdgEntity::parent-set:
 148      * @entity: an #AdgEntity
 149      * @old_parent: the old parent
 150      *
 151      * Emitted after the parent entity has changed. The new parent
 152      * can be inspected using adg_entity_get_parent().
 153      *
 154      * It is allowed for both old and new parent to be %NULL.
 155      **/
 156     signals[PARENT_SET] = g_signal_new("parent-set",
 157                                        G_OBJECT_CLASS_TYPE(gobject_class),
 158                                        G_SIGNAL_RUN_FIRST,
 159                                        G_STRUCT_OFFSET(AdgEntityClass, parent_set),
 160                                        NULL, NULL,
 161                                        g_cclosure_marshal_VOID__OBJECT,
 162                                        G_TYPE_NONE, 1, ADG_TYPE_ENTITY);
 163
 164     /**
 165      * AdgEntity::invalidate:
 166      * @entity: an #AdgEntity
 167      *
 168      * The inverse of the rendering. Usually, invalidation causes the
 169      * cache of @entity to be cleared. After a succesful invalidation
 170      * the rendered flag is reset: you can access its state using
 171      * adg_entity_get_rendered().
 172      **/
 173     closure = g_cclosure_new(G_CALLBACK(real_invalidate),
 174                              (gpointer)0xdeadbeaf, NULL);
 175     signals[INVALIDATE] = g_signal_newv("invalidate", ADG_TYPE_ENTITY,
 176                                         G_SIGNAL_RUN_LAST, closure, NULL, NULL,
 177                                         g_cclosure_marshal_VOID__VOID,
 178                                         G_TYPE_NONE, 0, param_types);
 179
 180     /**
 181      * AdgEntity::render:
 182      * @entity: an #AdgEntity
 183      * @cr: a #cairo_t drawing context
 184      *
 185      * Causes the rendering of @entity on @cr. After a succesful rendering
 186      * the rendered flag is set: you can access its state using
 187      * adg_entity_get_rendered().
 188      **/
 189     closure = g_cclosure_new(G_CALLBACK(real_render),
 190                              (gpointer)0xdeadbeaf, NULL);
 191     param_types[0] = G_TYPE_POINTER;
 192     signals[RENDER] = g_signal_newv("render", ADG_TYPE_ENTITY,
 193                                     G_SIGNAL_RUN_LAST, closure, NULL, NULL,
 194                                     g_cclosure_marshal_VOID__POINTER,
 195                                     G_TYPE_NONE, 1, param_types);
 196 }
 197
 198 static void
 199 adg_entity_init(AdgEntity *entity)
 200 {
 201     AdgEntityPrivate *data = G_TYPE_INSTANCE_GET_PRIVATE(entity,
 202                                                          ADG_TYPE_ENTITY,
 203                                                          AdgEntityPrivate);
 204     data->parent = NULL;
 205     data->flags = 0;
 206     cairo_matrix_init_identity(&data->local_map);
 207     cairo_matrix_init_identity(&data->global_map);
 208     data->hash_styles = NULL;
 209
 210     entity->data = data;
 211 }
 212
 213 static void
 214 dispose(GObject *object)
 215 {
 216     AdgEntity *entity;
 217     AdgEntityPrivate *data;
 218
 219     entity = (AdgEntity *) object;
 220     data = entity->data;
 221
 222     /* This call will emit a "notify" signal for parent.
 223      * Consequentially, the references to the old parent is dropped. */
 224     adg_entity_set_parent(entity, NULL);
 225
 226     if (data->hash_styles != NULL) {
 227         g_hash_table_destroy(data->hash_styles);
 228         data->hash_styles = NULL;
 229     }
 230
 231     if (PARENT_OBJECT_CLASS->dispose != NULL)
 232         PARENT_OBJECT_CLASS->dispose(object);
 233 }
 234
 235
 236 static void
 237 get_property(GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
 238 {
 239     AdgEntity *entity;
 240     AdgEntityPrivate *data;
 241
 242     entity = (AdgEntity *) object;
 243     data = entity->data;
 244
 245     switch (prop_id) {
 246     case PROP_PARENT:
 247         g_value_set_object(value, data->parent);
 248         break;
 249     case PROP_GLOBAL_MAP:
 250         g_value_set_boxed(value, &data->global_map);
 251         break;
 252     case PROP_LOCAL_MAP:
 253         g_value_set_boxed(value, &data->local_map);
 254         break;
 255     default:
 256         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
 257         break;
 258     }
 259 }
 260
 261 static void
 262 set_property(GObject *object,
 263              guint prop_id, const GValue *value, GParamSpec *pspec)
 264 {
 265     AdgEntity *entity = (AdgEntity *) object;
 266
 267     switch (prop_id) {
 268     case PROP_PARENT:
 269         set_parent(entity, g_value_get_object(value));
 270         break;
 271     case PROP_GLOBAL_MAP:
 272         set_global_map(entity, g_value_get_boxed(value));
 273         break;
 274     case PROP_LOCAL_MAP:
 275         set_local_map(entity, g_value_get_boxed(value));
 276         break;
 277     default:
 278         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
 279         break;
 280     }
 281 }
 282
 283
 284 /**
 285  * adg_entity_get_parent:
 286  * @entity: an #AdgEntity
 287  *
 288  * Gets the parent of @entity.
 289  *
 290  * Returns: the parent entity or %NULL on errors or if @entity is a toplevel
 291  **/
 292 AdgEntity *
 293 adg_entity_get_parent(AdgEntity *entity)
 294 {
 295     AdgEntityPrivate *data;
 296
 297     g_return_val_if_fail(ADG_IS_ENTITY(entity), NULL);
 298
 299     data = entity->data;
 300
 301     return data->parent;
 302 }
 303
 304 /**
 305  * adg_entity_set_parent:
 306  * @entity: an #AdgEntity
 307  * @parent: the parent entity
 308  *
 309  * <note><para>
 310  * This function is only useful in entity implementations.
 311  * </para></note>
 312  *
 313  * Sets a new parent on @entity.
 314  **/
 315 void
 316 adg_entity_set_parent(AdgEntity *entity, AdgEntity *parent)
 317 {
 318     g_return_if_fail(ADG_IS_ENTITY(entity));
 319
 320     if (set_parent(entity, parent))
 321         g_object_notify((GObject *) entity, "parent");
 322 }
 323
 324 /**
 325  * adg_entity_get_canvas:
 326  * @entity: an #AdgEntity
 327  *
 328  * Walks on the @entity hierarchy and gets the first parent of @entity that is
 329  * of #AdgCanvas derived type.
 330  *
 331  * Returns: the requested canvas or %NULL on errors or if there is
 332  *          no #AdgCanvas in the @entity hierarchy
 333  **/
 334 AdgCanvas *
 335 adg_entity_get_canvas(AdgEntity *entity)
 336 {
 337     g_return_val_if_fail(ADG_IS_ENTITY(entity), NULL);
 338
 339     while (entity) {
 340         if (ADG_IS_CANVAS(entity))
 341             return (AdgCanvas *) entity;
 342
 343         entity = (AdgEntity *) adg_entity_get_parent(entity);
 344     }
 345
 346     return NULL;
 347 }
 348
 349 /**
 350  * adg_entity_get_rendered:
 351  * @entity: an #AdgEntity object
 352  *
 353  * <note><para>
 354  * This function is only useful in entity implementations.
 355  * </para></note>
 356  *
 357  * Gets the rendered flag of @entity.
 358  *
 359  * Returns: the current rendered state
 360  **/
 361 gboolean
 362 adg_entity_get_rendered(AdgEntity *entity)
 363 {
 364     AdgEntityPrivate *data;
 365
 366     g_return_val_if_fail(ADG_IS_ENTITY(entity), FALSE);
 367
 368     data = entity->data;
 369
 370     return ADG_ISSET(data->flags, RENDERED);
 371 }
 372
 373 /**
 374  * adg_entity_set_rendered:
 375  * @entity: an #AdgEntity object
 376  * @rendered: new state for the rendered flag
 377  *
 378  * <note><para>
 379  * This function is only useful in entity implementations.
 380  * </para></note>
 381  *
 382  * Sets the rendered flag of @entity to @rendered.
 383  **/
 384 void
 385 adg_entity_set_rendered(AdgEntity *entity, gboolean rendered)
 386 {
 387     AdgEntityPrivate *data;
 388
 389     g_return_if_fail(ADG_IS_ENTITY(entity));
 390
 391     data = entity->data;
 392
 393     if (rendered)
 394         ADG_SET(data->flags, RENDERED);
 395     else
 396         ADG_UNSET(data->flags, RENDERED);
 397 }
 398
 399 /**
 400  * adg_entity_get_global_map:
 401  * @entity: an #AdgEntity object
 402  * @map: where to store the global map
 403  *
 404  * Gets the transformation to be used to compute the global matrix
 405  * of @entity and store it in @map.
 406  **/
 407 void
 408 adg_entity_get_global_map(AdgEntity *entity, AdgMatrix *map)
 409 {
 410     AdgEntityPrivate *data;
 411
 412     g_return_if_fail(ADG_IS_ENTITY(entity));
 413     g_return_if_fail(map != NULL);
 414
 415     data = entity->data;
 416     adg_matrix_copy(map, &data->global_map);
 417 }
 418
 419 /**
 420  * adg_entity_set_global_map:
 421  * @entity: an #AdgEntity object
 422  * @map: the new map
 423  *
 424  * Sets the new global transformation of @entity to @map:
 425  * the old map is discarded. If @map is %NULL an identity
 426  * matrix is implied.
 427  **/
 428 void
 429 adg_entity_set_global_map(AdgEntity *entity, const AdgMatrix *map)
 430 {
 431     g_return_if_fail(ADG_IS_ENTITY(entity));
 432
 433     set_global_map(entity, map);
 434     g_object_notify((GObject *) entity, "global-map");
 435 }
 436
 437 /**
 438  * adg_entity_transform_global_map:
 439  * @entity: an #AdgEntity object
 440  * @transformation: the transformation to apply
 441  *
 442  * Applies a transformation to the global map of @entity. This is
 443  * equivalent to the following code:
 444  *
 445  * |[
 446  * AdgMatrix tmp_map;
 447  * adg_entity_get_global_map(entity, &tmp_map);
 448  * cairo_matrix_multiply(&tmp_map, transformation, &tmp_map);
 449  * adg_entity_set_global_map(entity, &tmp_map);
 450  * ]|
 451  **/
 452 void
 453 adg_entity_transform_global_map(AdgEntity *entity,
 454                                 const AdgMatrix *transformation)
 455 {
 456     AdgEntityPrivate *data;
 457
 458     g_return_if_fail(ADG_IS_ENTITY(entity));
 459     g_return_if_fail(transformation != NULL);
 460
 461     data = entity->data;
 462
 463     cairo_matrix_multiply(&data->global_map, transformation, &data->global_map);
 464     g_object_notify((GObject *) entity, "global-map");
 465 }
 466
 467 /**
 468  * adg_entity_get_global_matrix:
 469  * @entity: an #AdgEntity object
 470  * @matrix: where to store the global matrix
 471  *
 472  * Computes the global matrix by combining all the global maps of the
 473  * @entity hierarchy and stores the result in @matrix.
 474  **/
 475 void
 476 adg_entity_get_global_matrix(AdgEntity *entity, AdgMatrix *matrix)
 477 {
 478     g_return_if_fail(ADG_IS_ENTITY(entity));
 479     g_return_if_fail(matrix != NULL);
 480
 481     ADG_ENTITY_GET_CLASS(entity)->get_global_matrix(entity, matrix);
 482 }
 483
 484 /**
 485  * adg_entity_get_local_map:
 486  * @entity: an #AdgEntity object
 487  * @map: where to store the local map
 488  *
 489  * Gets the transformation to be used to compute the local matrix
 490  * of @entity and store it in @map.
 491  **/
 492 void
 493 adg_entity_get_local_map(AdgEntity *entity, AdgMatrix *map)
 494 {
 495     AdgEntityPrivate *data;
 496
 497     g_return_if_fail(ADG_IS_ENTITY(entity));
 498     g_return_if_fail(map != NULL);
 499
 500     data = entity->data;
 501     adg_matrix_copy(map, &data->local_map);
 502 }
 503
 504 /**
 505  * adg_entity_set_local_map:
 506  * @entity: an #AdgEntity object
 507  * @map: the new map
 508  *
 509  * Sets the new global transformation of @entity to @map:
 510  * the old map is discarded. If @map is %NULL an identity
 511  * matrix is implied.
 512  **/
 513 void
 514 adg_entity_set_local_map(AdgEntity *entity, const AdgMatrix *map)
 515 {
 516     g_return_if_fail(ADG_IS_ENTITY(entity));
 517
 518     set_local_map(entity, map);
 519     g_object_notify((GObject *) entity, "local-map");
 520 }
 521
 522 /**
 523  * adg_entity_transform_local_map:
 524  * @entity: an #AdgEntity object
 525  * @transformation: the transformation to apply
 526  *
 527  * Applies a transformation to the local map of @entity. This is
 528  * equivalent to the following code:
 529  *
 530  * |[
 531  * AdgMatrix tmp_map;
 532  * adg_entity_get_local_map(entity, &tmp_map);
 533  * cairo_matrix_multiply(&tmp_map, transformation, &tmp_map);
 534  * adg_entity_set_local_map(entity, &tmp_map);
 535  * ]|
 536  **/
 537 void
 538 adg_entity_transform_local_map(AdgEntity *entity,
 539                                const AdgMatrix *transformation)
 540 {
 541     AdgEntityPrivate *data;
 542
 543     g_return_if_fail(ADG_IS_ENTITY(entity));
 544     g_return_if_fail(transformation != NULL);
 545
 546     data = entity->data;
 547
 548     cairo_matrix_multiply(&data->local_map, transformation, &data->local_map);
 549     g_object_notify((GObject *) entity, "local-map");
 550 }
 551
 552 /**
 553  * adg_entity_get_local_matrix:
 554  * @entity: an #AdgEntity object
 555  * @matrix: where to store the local matrix
 556  *
 557  * Computes the local matrix by combining all the local maps of the
 558  * @entity hierarchy and stores the result in @matrix.
 559  **/
 560 void
 561 adg_entity_get_local_matrix(AdgEntity *entity, AdgMatrix *matrix)
 562 {
 563     g_return_if_fail(ADG_IS_ENTITY(entity));
 564     g_return_if_fail(matrix != NULL);
 565
 566     ADG_ENTITY_GET_CLASS(entity)->get_local_matrix(entity, matrix);
 567 }
 568
 569 /**
 570  * adg_entity_apply_local_matrix:
 571  * @entity: an #AdgEntity object
 572  * @cr: a #cairo_t drawing context
 573  *
 574  * Applies the local matrix of @entity BEFORE the current transformation
 575  * matrix of @cr. This is a convenience function equivalent to:
 576  *
 577  * |[
 578  * AdgMatrix local, ctm;
 579  *
 580  * adg_entity_get_local_matrix(entity, &local);
 581  * cairo_get_matrix(cr, &ctm);
 582  *
 583  * cairo_matrix_multiply(&ctm, &ctm, &local);
 584  * cairo_set_matrix(cr, &ctm);
 585  * ]|
 586  **/
 587 void
 588 adg_entity_apply_local_matrix(AdgEntity *entity, cairo_t *cr)
 589 {
 590     AdgMatrix local, ctm;
 591
 592     g_return_if_fail(ADG_IS_ENTITY(entity));
 593     g_return_if_fail(cr != NULL);
 594
 595     adg_entity_get_local_matrix(entity, &local);
 596     cairo_get_matrix(cr, &ctm);
 597
 598     cairo_matrix_multiply(&ctm, &ctm, &local);
 599     cairo_set_matrix(cr, &ctm);
 600 }
 601
 602 /**
 603  * adg_entity_style:
 604  * @entity: an #AdgEntity
 605  * @dress: the dress of the style to get
 606  *
 607  * Gets the style to be used for @entity. @dress specifies the "type"
 608  * of style to get.
 609  *
 610  * This method is supposed to always return a valid style instance,
 611  * specifically the most appropriate one for this entity. The following
 612  * sequence of checks is performed to get the proper @dress style,
 613  * stopping at the first succesfull result:
 614  *
 615  * <orderedlist>
 616  * <listitem>check if the style is defined directly by this entity type,
 617  *           as returned by adg_entity_get_style();</listitem>
 618  * <listitem>check if @entity has a parent, in which case returns the
 619  *           adg_entity_style() of the parent;</listitem>
 620  * <listitem>returns the main style with adg_dress_get_style().</listitem>
 621  * </orderedlist>
 622  *
 623  * Returns: the requested style or %NULL on errors
 624  **/
 625 AdgStyle *
 626 adg_entity_style(AdgEntity *entity, AdgDress dress)
 627 {
 628     AdgStyle *style;
 629
 630     g_return_val_if_fail(ADG_IS_ENTITY(entity), NULL);
 631     g_return_val_if_fail(dress != ADG_DRESS_UNDEFINED, NULL);
 632
 633     style = adg_entity_get_style(entity, dress);
 634
 635     if (style == NULL) {
 636         AdgEntityPrivate *data = entity->data;
 637
 638         if (data->parent != NULL)
 639             style = adg_entity_style(data->parent, dress);
 640         else
 641             style = adg_dress_get_style(dress);
 642     }
 643
 644     return style;
 645 }
 646
 647 /**
 648  * adg_entity_get_style:
 649  * @entity: an #AdgEntity
 650  * @dress: the dress of the style to get
 651  *
 652  * Gets the overriden @dress style from @entity. This is a kind
 653  * of accessor function: to get the style to be used for rendering
 654  * purpose, consider adg_entity_style().
 655  *
 656  * Returns: the requested style or %NULL if the @dress style
 657  *          is not overriden
 658  **/
 659 AdgStyle *
 660 adg_entity_get_style(AdgEntity *entity, AdgDress dress)
 661 {
 662     AdgEntityPrivate *data;
 663
 664     g_return_val_if_fail(ADG_IS_ENTITY(entity), NULL);
 665     g_return_val_if_fail(dress != ADG_DRESS_UNDEFINED, NULL);
 666
 667     data = entity->data;
 668
 669     if (data->hash_styles == NULL)
 670         return NULL;
 671
 672     return g_hash_table_lookup(data->hash_styles, GINT_TO_POINTER(dress));
 673 }
 674
 675 /**
 676  * adg_entity_set_style:
 677  * @entity: an #AdgEntity
 678  * @dress: a dress style
 679  * @style: the new style to use
 680  *
 681  * Overrides the style of @dress for @entity and its children.
 682  * If @style is %NULL, any previous override is removed.
 683  **/
 684 void
 685 adg_entity_set_style(AdgEntity *entity, AdgDress dress, AdgStyle *style)
 686 {
 687     AdgEntityPrivate *data;
 688     gpointer p_dress;
 689     AdgStyle *old_style;
 690
 691     g_return_if_fail(ADG_IS_ENTITY(entity));
 692
 693     data = entity->data;
 694
 695     if (data->hash_styles == NULL && style == NULL)
 696         return;
 697
 698     if (data->hash_styles == NULL)
 699         data->hash_styles = g_hash_table_new_full(NULL, NULL,
 700                                                   NULL, g_object_unref);
 701
 702     p_dress = GINT_TO_POINTER(dress);
 703     old_style = g_hash_table_lookup(data->hash_styles, p_dress);
 704
 705     if (style == old_style)
 706         return;
 707
 708     if (style == NULL) {
 709         g_hash_table_remove(data->hash_styles, p_dress);
 710     } else {
 711         g_object_ref(style);
 712         g_hash_table_replace(data->hash_styles, p_dress, style);
 713     }
 714 }
 715
 716 /**
 717  * adg_entity_apply_dress:
 718  * @entity: an #AdgEntity
 719  * @dress: the dress style to apply
 720  * @cr: a #cairo_t drawing context
 721  *
 722  * Convenient function to apply a @dress style (as returned by
 723  * adg_entity_style()) to the @cr cairo context.
 724  **/
 725 void
 726 adg_entity_apply_dress(AdgEntity *entity, AdgDress dress, cairo_t *cr)
 727 {
 728     g_return_if_fail(ADG_IS_ENTITY(entity));
 729     g_return_if_fail(cr != NULL);
 730
 731     adg_style_apply(adg_entity_style(entity, dress), cr);
 732 }
 733
 734 /**
 735  * adg_entity_invalidate:
 736  * @entity: an #AdgEntity
 737  *
 738  * Emits the "invalidate" signal on @entity and all its children, if any,
 739  * so subsequent rendering will need a global recomputation.
 740  **/
 741 void
 742 adg_entity_invalidate(AdgEntity *entity)
 743 {
 744     g_return_if_fail(ADG_IS_ENTITY(entity));
 745
 746     g_signal_emit(entity, signals[INVALIDATE], 0, NULL);
 747 }
 748
 749 /**
 750  * adg_entity_render:
 751  * @entity: an #AdgEntity
 752  * @cr: a #cairo_t drawing context
 753  *
 754  * Emits the "render" signal on @entity and all its children, if any,
 755  * causing the rendering operation the @cr cairo context.
 756  **/
 757 void
 758 adg_entity_render(AdgEntity *entity, cairo_t *cr)
 759 {
 760     g_return_if_fail(ADG_IS_ENTITY(entity));
 761
 762     g_signal_emit(entity, signals[RENDER], 0, cr);
 763 }
 764
 765
 766 static gboolean
 767 set_parent(AdgEntity *entity, AdgEntity *parent)
 768 {
 769     AdgEntityPrivate *data;
 770     AdgEntity *old_parent;
 771
 772     data = entity->data;
 773     old_parent = data->parent;
 774
 775     /* Check if parent has changed */
 776     if (parent == old_parent)
 777         return FALSE;
 778
 779     if (parent != NULL)
 780         g_object_ref(parent);
 781
 782     data->parent = parent;
 783     g_signal_emit(entity, signals[PARENT_SET], 0, old_parent);
 784
 785     if (old_parent != NULL)
 786         g_object_unref(old_parent);
 787
 788     return TRUE;
 789 }
 790
 791 static void
 792 set_global_map(AdgEntity *entity, const AdgMatrix *map)
 793 {
 794     AdgEntityPrivate *data = entity->data;
 795
 796     if (map == NULL)
 797         cairo_matrix_init_identity(&data->global_map);
 798     else
 799         adg_matrix_copy(&data->global_map, map);
 800 }
 801
 802 static void
 803 set_local_map(AdgEntity *entity, const AdgMatrix *map)
 804 {
 805     AdgEntityPrivate *data = entity->data;
 806
 807     if (map == NULL)
 808         cairo_matrix_init_identity(&data->local_map);
 809     else
 810         adg_matrix_copy(&data->local_map, map);
 811 }
 812
 813 static void
 814 get_global_matrix(AdgEntity *entity, AdgMatrix *matrix)
 815 {
 816     AdgEntityPrivate *data = entity->data;
 817
 818     if (data->parent == NULL) {
 819         adg_matrix_copy(matrix, &data->global_map);
 820     } else {
 821         adg_entity_get_global_matrix(data->parent, matrix);
 822         cairo_matrix_multiply(matrix, &data->global_map, matrix);
 823     }
 824 }
 825
 826 static void
 827 get_local_matrix(AdgEntity *entity, AdgMatrix *matrix)
 828 {
 829     AdgEntityPrivate *data = entity->data;
 830
 831     if (data->parent == NULL) {
 832         adg_matrix_copy(matrix, &data->local_map);
 833     } else {
 834         adg_entity_get_local_matrix(data->parent, matrix);
 835         cairo_matrix_multiply(matrix, &data->local_map, matrix);
 836     }
 837 }
 838
 839 static void
 840 real_invalidate(AdgEntity *entity, gpointer user_data)
 841 {
 842     AdgEntityClass *klass;
 843     AdgEntityPrivate *data;
 844
 845     g_assert(user_data == (gpointer) 0xdeadbeaf);
 846
 847     klass = ADG_ENTITY_GET_CLASS(entity);
 848     if (klass->invalidate == NULL) {
 849         /* Assume the entity does not have cache to be cleared */
 850     } else if (!klass->invalidate(entity)) {
 851         return;
 852     }
 853
 854     data = entity->data;
 855     ADG_UNSET(data->flags, RENDERED);
 856 }
 857
 858 static void
 859 real_render(AdgEntity *entity, cairo_t *cr, gpointer user_data)
 860 {
 861     AdgEntityClass *klass;
 862     AdgEntityPrivate *data;
 863
 864     g_assert(user_data == (gpointer) 0xdeadbeaf);
 865
 866     klass = ADG_ENTITY_GET_CLASS(entity);
 867     if (klass->render == NULL) {
 868         /* The render method must be defined */
 869         g_warning("%s: `render' method not implemented for type `%s'",
 870                   G_STRLOC, g_type_name(G_OBJECT_TYPE(entity)));
 871         return;
 872     }
 873
 874     data = entity->data;
 875
 876     cairo_save(cr);
 877     cairo_transform(cr, &data->global_map);
 878
 879     if (klass->render(entity, cr))
 880         ADG_SET(data->flags, RENDERED);
 881
 882     cairo_restore(cr);
 883 }