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  * SECTION:entity
  22  * @title: AdgEntity
  23  * @short_description: The base class for renderable objects
  24  *
  25  * This abstract class provides a base interface for all renderable objects
  26  * (all the objects that can be printed or viewed).
  27  */
  28
  29 #include "adg-entity.h"
  30 #include "adg-entity-private.h"
  31 #include "adg-canvas.h"
  32 #include "adg-context.h"
  33 #include "adg-util.h"
  34 #include "adg-intl.h"
  35
  36
  37 enum {
  38     PROP_0,
  39     PROP_PARENT,
  40     PROP_CONTEXT
  41 };
  42
  43 enum {
  44     PARENT_SET,
  45     MODEL_MATRIX_CHANGED,
  46     PAPER_MATRIX_CHANGED,
  47     INVALIDATE,
  48     RENDER,
  49     LAST_SIGNAL
  50 };
  51
  52
  53 static void             get_property            (GObject        *object,
  54                                                  guint           prop_id,
  55                                                  GValue         *value,
  56                                                  GParamSpec     *pspec);
  57 static void             set_property            (GObject        *object,
  58                                                  guint           prop_id,
  59                                                  const GValue   *value,
  60                                                  GParamSpec     *pspec);
  61 static void             dispose                 (GObject        *object);
  62 static AdgContainer *   get_parent              (AdgEntity      *entity);
  63 static void             set_parent              (AdgEntity      *entity,
  64                                                  AdgContainer   *parent);
  65 static void             parent_set              (AdgEntity      *entity,
  66                                                  AdgContainer   *old_parent);
  67 static AdgContext *     get_context             (AdgEntity      *entity);
  68 static void             set_context             (AdgEntity      *entity,
  69                                                  AdgContext     *context);
  70 static void             model_matrix_changed    (AdgEntity      *entity,
  71                                                  AdgMatrix      *parent_matrix);
  72 static void             paper_matrix_changed    (AdgEntity      *entity,
  73                                                  AdgMatrix      *parent_matrix);
  74 static void             render                  (AdgEntity      *entity,
  75                                                  cairo_t        *cr);
  76 static const AdgMatrix *get_model_matrix        (AdgEntity      *entity);
  77 static const AdgMatrix *get_paper_matrix        (AdgEntity      *entity);
  78
  79 static guint signals[LAST_SIGNAL] = { 0 };
  80
  81
  82 G_DEFINE_ABSTRACT_TYPE(AdgEntity, adg_entity, G_TYPE_INITIALLY_UNOWNED)
  83
  84
  85 static void
  86 adg_entity_class_init(AdgEntityClass *klass)
  87 {
  88     GObjectClass *gobject_class;
  89     GParamSpec *param;
  90
  91     gobject_class = (GObjectClass *) klass;
  92
  93     g_type_class_add_private(klass, sizeof(AdgEntityPrivate));
  94
  95     gobject_class->get_property = get_property;
  96     gobject_class->set_property = set_property;
  97     gobject_class->dispose = dispose;
  98
  99     klass->get_parent = get_parent;
 100     klass->set_parent = set_parent;
 101     klass->parent_set = parent_set;
 102     klass->get_context = get_context;
 103     klass->model_matrix_changed = model_matrix_changed;
 104     klass->paper_matrix_changed = paper_matrix_changed;
 105     klass->invalidate = NULL;
 106     klass->render = render;
 107     klass->get_model_matrix = get_model_matrix;
 108     klass->get_paper_matrix = get_paper_matrix;
 109
 110     param = g_param_spec_object("parent",
 111                                 P_("Parent Container"),
 112                                 P_("The parent AdgContainer of this entity or NULL if this is a top-level entity"),
 113                                 ADG_TYPE_CONTAINER, G_PARAM_READWRITE);
 114     g_object_class_install_property(gobject_class, PROP_PARENT, param);
 115
 116     param = g_param_spec_object("context",
 117                                 P_("Context"),
 118                                 P_("The context associated to this entity or NULL to inherit the parent context"),
 119                                 ADG_TYPE_CONTEXT, G_PARAM_READWRITE);
 120     g_object_class_install_property(gobject_class, PROP_CONTEXT, param);
 121
 122   /**
 123    * AdgEntity::parent-set:
 124    * @entity: an #AdgEntity
 125    * @parent: the #AdgContainer parent of @entity
 126    *
 127    * Emitted after the parent container has changed.
 128    */
 129     signals[PARENT_SET] =
 130         g_signal_new("parent-set",
 131                      G_OBJECT_CLASS_TYPE(gobject_class),
 132                      G_SIGNAL_RUN_FIRST,
 133                      G_STRUCT_OFFSET(AdgEntityClass, parent_set),
 134                      NULL, NULL,
 135                      g_cclosure_marshal_VOID__OBJECT,
 136                      G_TYPE_NONE, 1, ADG_TYPE_CONTAINER);
 137
 138   /**
 139    * AdgEntity::model-matrix-changed:
 140    * @entity: an #AdgEntity
 141    * @parent_matrix: the parent model matrix
 142    *
 143    * Emitted after the current model matrix has changed.
 144    */
 145     signals[MODEL_MATRIX_CHANGED] =
 146         g_signal_new("model-matrix-changed",
 147                      G_OBJECT_CLASS_TYPE(gobject_class),
 148                      G_SIGNAL_RUN_FIRST,
 149                      G_STRUCT_OFFSET(AdgEntityClass, model_matrix_changed),
 150                      NULL, NULL,
 151                      g_cclosure_marshal_VOID__BOXED,
 152                      G_TYPE_NONE, 1,
 153                      ADG_TYPE_MATRIX | G_SIGNAL_TYPE_STATIC_SCOPE);
 154
 155   /**
 156    * AdgEntity::paper-matrix-changed:
 157    * @entity: an #AdgEntity
 158    * @parent_matrix: the parent paper matrix
 159    *
 160    * Emitted after the current paper matrix has changed.
 161    */
 162     signals[PAPER_MATRIX_CHANGED] =
 163         g_signal_new("paper-matrix-changed",
 164                      G_OBJECT_CLASS_TYPE(gobject_class),
 165                      G_SIGNAL_RUN_FIRST,
 166                      G_STRUCT_OFFSET(AdgEntityClass, paper_matrix_changed),
 167                      NULL, NULL,
 168                      g_cclosure_marshal_VOID__BOXED,
 169                      G_TYPE_NONE, 1,
 170                      ADG_TYPE_MATRIX | G_SIGNAL_TYPE_STATIC_SCOPE);
 171
 172   /**
 173    * AdgEntity::invalidate:
 174    * @entity: an #AdgEntity
 175    *
 176    * Clears the cached data of @entity.
 177    */
 178     signals[INVALIDATE] =
 179         g_signal_new("invalidate",
 180                      G_OBJECT_CLASS_TYPE(gobject_class),
 181                      G_SIGNAL_RUN_FIRST,
 182                      G_STRUCT_OFFSET(AdgEntityClass, invalidate),
 183                      NULL, NULL,
 184                      g_cclosure_marshal_VOID__BOOLEAN,
 185                      G_TYPE_NONE, 0);
 186
 187   /**
 188    * AdgEntity::render:
 189    * @entity: an #AdgEntity
 190    * @cr: a #cairo_t drawing context
 191    *
 192    * Causes the rendering of @entity on @cr.
 193    */
 194     signals[RENDER] =
 195         g_signal_new("render",
 196                      G_OBJECT_CLASS_TYPE(gobject_class),
 197                      G_SIGNAL_RUN_FIRST,
 198                      G_STRUCT_OFFSET(AdgEntityClass, render),
 199                      NULL, NULL,
 200                      g_cclosure_marshal_VOID__POINTER,
 201                      G_TYPE_NONE, 1, G_TYPE_POINTER);
 202 }
 203
 204 static void
 205 adg_entity_init(AdgEntity *entity)
 206 {
 207     AdgEntityPrivate *priv = G_TYPE_INSTANCE_GET_PRIVATE(entity,
 208                                                          ADG_TYPE_ENTITY,
 209                                                          AdgEntityPrivate);
 210     priv->parent = NULL;
 211     priv->flags = 0;
 212     priv->context = NULL;
 213
 214     entity->priv = priv;
 215 }
 216
 217 static void
 218 get_property(GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
 219 {
 220     AdgEntity *entity = (AdgEntity *) object;
 221
 222     switch (prop_id) {
 223     case PROP_PARENT:
 224         g_value_set_object(value, get_parent(entity));
 225         break;
 226     case PROP_CONTEXT:
 227         g_value_set_object(value, get_context(entity));
 228         break;
 229     default:
 230         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
 231         break;
 232     }
 233 }
 234
 235 static void
 236 set_property(GObject *object,
 237              guint prop_id, const GValue *value, GParamSpec *pspec)
 238 {
 239     AdgEntity *entity = (AdgEntity *) object;
 240
 241     switch (prop_id) {
 242     case PROP_PARENT:
 243         set_parent(entity, (AdgContainer *) g_value_get_object(value));
 244         break;
 245     case PROP_CONTEXT:
 246         set_context(entity, g_value_get_object(value));
 247         break;
 248     default:
 249         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
 250         break;
 251     }
 252 }
 253
 254 static void
 255 dispose(GObject *object)
 256 {
 257     AdgEntity *entity;
 258     GObjectClass *object_class;
 259
 260     entity = (AdgEntity *) object;
 261     object_class = (GObjectClass *) adg_entity_parent_class;
 262
 263     if (entity->priv->parent)
 264         adg_container_remove(entity->priv->parent, entity);
 265
 266     if (object_class->dispose != NULL)
 267         object_class->dispose(object);
 268 }
 269
 270
 271 /**
 272  * adg_entity_get_parent:
 273  * @entity: an #AdgEntity
 274  *
 275  * Gets the container parent of @entity.
 276  *
 277  * This function is only useful in entity implementations.
 278  *
 279  * Return value: the container object or %NULL if @entity is not contained
 280  */
 281 AdgContainer *
 282 adg_entity_get_parent(AdgEntity *entity)
 283 {
 284     g_return_val_if_fail(ADG_IS_ENTITY(entity), NULL);
 285
 286     return ADG_ENTITY_GET_CLASS(entity)->get_parent(entity);
 287 }
 288
 289 /**
 290  * adg_entity_set_parent:
 291  * @entity: an #AdgEntity
 292  * @parent: an #AdgContainer
 293  *
 294  * Sets a new container of @entity.
 295  *
 296  * This function is only useful in entity implementations.
 297  */
 298 void
 299 adg_entity_set_parent(AdgEntity *entity, AdgContainer *parent)
 300 {
 301     g_return_if_fail(ADG_IS_ENTITY(entity));
 302
 303     ADG_ENTITY_GET_CLASS(entity)->set_parent(entity, parent);
 304     g_object_notify((GObject *) entity, "parent");
 305 }
 306
 307 /**
 308  * adg_entity_unparent:
 309  * @entity: an #AdgEntity
 310  *
 311  * Removes the current parent of @entity, properly handling
 312  * the references between them.
 313  *
 314  * If @entity has no parent, this function simply returns.
 315  **/
 316 void
 317 adg_entity_unparent(AdgEntity *entity)
 318 {
 319     AdgContainer *old_parent;
 320
 321     g_return_if_fail(ADG_IS_ENTITY(entity));
 322
 323     old_parent = ADG_ENTITY_GET_CLASS(entity)->get_parent(entity);
 324
 325     if (old_parent == NULL)
 326         return;
 327
 328     ADG_ENTITY_GET_CLASS(entity)->set_parent(entity, NULL);
 329     g_signal_emit(entity, signals[PARENT_SET], 0, old_parent);
 330
 331     g_object_unref(entity);
 332 }
 333
 334 /**
 335  * adg_entity_reparent:
 336  * @entity: an #AdgEntity
 337  * @parent: the new container
 338  *
 339  * Moves @entity from the old parent to @parent, handling reference
 340  * count issues to avoid destroying the object.
 341  **/
 342 void
 343 adg_entity_reparent(AdgEntity *entity, AdgContainer *parent)
 344 {
 345     AdgContainer *old_parent;
 346
 347     g_return_if_fail(ADG_IS_CONTAINER(parent));
 348
 349     old_parent = adg_entity_get_parent(entity);
 350
 351     /* Reparenting on the same container: do nothing */
 352     if (old_parent == parent)
 353         return;
 354
 355     g_return_if_fail(ADG_IS_CONTAINER(old_parent));
 356
 357     g_object_ref(entity);
 358     adg_container_remove(old_parent, entity);
 359     adg_container_add(parent, entity);
 360     g_object_unref(entity);
 361 }
 362
 363 /**
 364  * adg_entity_get_context:
 365  * @entity: an #AdgEntity instance
 366  *
 367  * Gets the context associated to @entity.
 368  * If no context was explicitely set, get the parent context.
 369  *
 370  * Return value: the requested context or %NULL on errors
 371  **/
 372 AdgContext *
 373 adg_entity_get_context(AdgEntity *entity)
 374 {
 375     g_return_val_if_fail(ADG_IS_ENTITY(entity), NULL);
 376
 377     if (entity->priv->context)
 378         return entity->priv->context;
 379
 380     if (entity->priv->parent)
 381         return adg_entity_get_context((AdgEntity *) entity->priv->parent);
 382
 383     return NULL;
 384 }
 385
 386 /**
 387  * adg_entity_set_context:
 388  * @entity: an #AdgEntity instance
 389  * @context: the new context
 390  *
 391  * Sets a new context. The old context (if any) will be unreferenced
 392  * while a new reference will be added to @context.
 393  **/
 394 void
 395 adg_entity_set_context(AdgEntity *entity, AdgContext *context)
 396 {
 397     g_return_if_fail(ADG_IS_ENTITY(entity));
 398     g_return_if_fail(ADG_IS_CONTEXT(context));
 399
 400     set_context(entity, context);
 401     g_object_notify((GObject *) entity, "context");
 402 }
 403
 404 /**
 405  * adg_entity_get_canvas:
 406  * @entity: an #AdgEntity
 407  *
 408  * Walks on the @entity hierarchy and gets the first parent of @entity that is
 409  * of #AdgCanvas derived type.
 410  *
 411  * Return value: the requested object or %NULL if there is no #AdgCanvas in
 412  *               the parent hierarchy.
 413  */
 414 AdgCanvas *
 415 adg_entity_get_canvas(AdgEntity *entity)
 416 {
 417     g_return_val_if_fail(ADG_IS_ENTITY(entity), NULL);
 418
 419     while (entity) {
 420         if (ADG_IS_CANVAS(entity))
 421             return (AdgCanvas *) entity;
 422
 423         entity = (AdgEntity *) adg_entity_get_parent(entity);
 424     }
 425
 426     return NULL;
 427 }
 428
 429 /**
 430  * adg_entity_get_model_matrix:
 431  * @entity: an #AdgEntity object
 432  *
 433  * Gets the model matrix to be used in rendering this @entity.
 434  *
 435  * Return value: the requested matrix
 436  */
 437 const AdgMatrix *
 438 adg_entity_get_model_matrix(AdgEntity *entity)
 439 {
 440     g_return_val_if_fail(ADG_IS_ENTITY(entity), NULL);
 441     return ADG_ENTITY_GET_CLASS(entity)->get_model_matrix(entity);
 442 }
 443
 444 /**
 445  * adg_entity_get_paper_matrix:
 446  * @entity: an #AdgEntity object
 447  *
 448  * Gets the paper matrix to be used in rendering this @entity.
 449  *
 450  * Return value: the requested matrix
 451  */
 452 const AdgMatrix *
 453 adg_entity_get_paper_matrix(AdgEntity *entity)
 454 {
 455     g_return_val_if_fail(ADG_IS_ENTITY(entity), NULL);
 456     return ADG_ENTITY_GET_CLASS(entity)->get_paper_matrix(entity);
 457 }
 458
 459 /**
 460  * adg_entity_scale_to_model:
 461  * @entity: an #AdgEntity object
 462  * @cr: a #cairo_t drawing context
 463  *
 464  * Sets the model matrix as current matrix on @cr. The translation
 465  * and rotation component of the previous matrix are kept: only the
 466  * scale is changed.
 467  */
 468 void
 469 adg_entity_scale_to_model(AdgEntity *entity, cairo_t *cr)
 470 {
 471     const AdgMatrix *model_matrix;
 472     cairo_matrix_t matrix;
 473
 474     g_return_if_fail(ADG_IS_ENTITY(entity));
 475
 476     model_matrix = ADG_ENTITY_GET_CLASS(entity)->get_model_matrix(entity);
 477     cairo_get_matrix(cr, &matrix);
 478
 479     matrix.xx = model_matrix->xx;
 480     matrix.yy = model_matrix->yy;
 481     cairo_set_matrix(cr, &matrix);
 482 }
 483
 484 /**
 485  * adg_entity_scale_to_paper:
 486  * @entity: an #AdgEntity object
 487  * @cr: a #cairo_t drawing context
 488  *
 489  * Sets the paper matrix as current matrix on @cr. The translation
 490  * and rotation component of the previous matrix are kept: only the
 491  * scale is changed.
 492  */
 493 void
 494 adg_entity_scale_to_paper(AdgEntity *entity, cairo_t *cr)
 495 {
 496     const AdgMatrix *paper_matrix;
 497     cairo_matrix_t matrix;
 498
 499     g_return_if_fail(ADG_IS_ENTITY(entity));
 500
 501     paper_matrix = ADG_ENTITY_GET_CLASS(entity)->get_paper_matrix(entity);
 502     cairo_get_matrix(cr, &matrix);
 503
 504     matrix.xx = paper_matrix->xx;
 505     matrix.yy = paper_matrix->yy;
 506     cairo_set_matrix(cr, &matrix);
 507 }
 508
 509 /**
 510  * adg_entity_build_paper2model:
 511  * @entity: an #AdgEntity
 512  * @matrix: the destination matrix
 513  *
 514  * Builds a matrix to translate from paper to model space and
 515  * put the result in @matrix.
 516  *
 517  * Return value: %TRUE on success, %FALSE on errors
 518  **/
 519 gboolean
 520 adg_entity_build_paper2model(AdgEntity *entity, AdgMatrix *matrix)
 521 {
 522     cairo_status_t status;
 523
 524     g_return_val_if_fail(ADG_IS_ENTITY(entity), FALSE);
 525     g_return_val_if_fail(matrix != NULL, FALSE);
 526
 527     adg_matrix_copy(matrix, adg_entity_get_model_matrix(entity));
 528     status = cairo_matrix_invert(matrix);
 529     if (status != CAIRO_STATUS_SUCCESS) {
 530         g_error("Unable to invert model matrix (cairo message: %s)",
 531                 cairo_status_to_string(status));
 532         return FALSE;
 533     }
 534
 535     cairo_matrix_multiply(matrix, matrix, adg_entity_get_paper_matrix(entity));
 536     return TRUE;
 537 }
 538
 539 /**
 540  * adg_entity_build_model2paper:
 541  * @entity: an #AdgEntity
 542  * @matrix: the destination matrix
 543  *
 544  * Builds a matrix to translate from model to paper space and
 545  * put the result in @matrix.
 546  *
 547  * Return value: %TRUE on success, %FALSE on errors
 548  **/
 549 gboolean
 550 adg_entity_build_model2paper(AdgEntity *entity, AdgMatrix *matrix)
 551 {
 552     cairo_status_t status;
 553
 554     g_return_val_if_fail(ADG_IS_ENTITY(entity), FALSE);
 555     g_return_val_if_fail(matrix != NULL, FALSE);
 556
 557     adg_matrix_copy(matrix, adg_entity_get_paper_matrix(entity));
 558     status = cairo_matrix_invert(matrix);
 559     if (status != CAIRO_STATUS_SUCCESS) {
 560         g_error("Unable to invert paper matrix (cairo message: %s)",
 561                 cairo_status_to_string(status));
 562         return FALSE;
 563     }
 564
 565     cairo_matrix_multiply(matrix, matrix, adg_entity_get_model_matrix(entity));
 566     return TRUE;
 567 }
 568
 569 /**
 570  * adg_entity_model_matrix_changed:
 571  * @entity: an #AdgEntity
 572  * @parent_matrix: the parent #AdgMatrix
 573  *
 574  * Emits the "model-matrix-changed" signal on @entity.
 575  *
 576  * This function is only useful in entity implementations.
 577  */
 578 void
 579 adg_entity_model_matrix_changed(AdgEntity *entity,
 580                                 const AdgMatrix *parent_matrix)
 581 {
 582     g_return_if_fail(ADG_IS_ENTITY(entity));
 583
 584     g_signal_emit(entity, signals[MODEL_MATRIX_CHANGED], 0, parent_matrix);
 585 }
 586
 587 /**
 588  * adg_entity_paper_matrix_changed:
 589  * @entity: an #AdgEntity
 590  * @parent_matrix: the parent #AdgMatrix
 591  *
 592  * Emits the "paper-matrix-changed" signal on @entity.
 593  *
 594  * This function is only useful in entity implementations.
 595  */
 596 void
 597 adg_entity_paper_matrix_changed(AdgEntity *entity,
 598                                 const AdgMatrix *parent_matrix)
 599 {
 600     g_return_if_fail(ADG_IS_ENTITY(entity));
 601
 602     g_signal_emit(entity, signals[PAPER_MATRIX_CHANGED], 0, parent_matrix);
 603 }
 604
 605 /**
 606  * adg_entity_get_style:
 607  * @entity: an #AdgEntity
 608  * @style_slot: the slot of the style to get
 609  *
 610  * Gets a style from this entity. If the entity has no context associated
 611  * or the style in undefined within this context, gets the style from its
 612  * parent container.
 613  *
 614  * Return value: the requested style or %NULL on errors
 615  **/
 616 AdgStyle *
 617 adg_entity_get_style(AdgEntity *entity, AdgStyleSlot style_slot)
 618 {
 619     g_return_val_if_fail(ADG_IS_ENTITY(entity), NULL);
 620
 621     if (entity->priv->context) {
 622         AdgStyle *style = adg_context_get_style(entity->priv->context,
 623                                                 style_slot);
 624         if (style)
 625             return style;
 626     }
 627
 628     if (entity->priv->parent)
 629         return adg_entity_get_style((AdgEntity *) entity->priv->parent,
 630                                     style_slot);
 631
 632     return NULL;
 633 }
 634
 635 /**
 636  * adg_entity_apply:
 637  * @entity: an #AdgEntity
 638  * @style_slot: the slot of the style to apply
 639  * @cr: a #cairo_t drawing context
 640  *
 641  * Applies the specified style to the @cr cairo context.
 642  **/
 643 void
 644 adg_entity_apply(AdgEntity *entity, AdgStyleSlot style_slot, cairo_t *cr)
 645 {
 646     AdgStyle *style = adg_entity_get_style(entity, style_slot);
 647
 648     if (style)
 649         adg_style_apply(style, cr);
 650 }
 651
 652 /**
 653  * adg_entity_point_to_pair:
 654  * @entity: an #AdgEntity
 655  * @point: the source #AdgPoint
 656  * @pair: the destination #AdgPair
 657  * @cr: a #cairo_t drawing context
 658  *
 659  * Converts @point to @pair using the model and paper matrix of @entity,
 660  * as if the current matrix is an identity matrix.
 661  **/
 662 void
 663 adg_entity_point_to_pair(AdgEntity *entity, const AdgPoint *point,
 664                          AdgPair *pair, cairo_t *cr)
 665 {
 666     AdgMatrix inverted_ctm;
 667     const AdgMatrix *model_matrix;
 668     const AdgMatrix *paper_matrix;
 669     AdgPair model_pair, paper_pair;
 670
 671     g_return_if_fail(ADG_IS_ENTITY(entity));
 672     g_return_if_fail(point != NULL);
 673     g_return_if_fail(pair != NULL);
 674
 675     cairo_get_matrix(cr, &inverted_ctm);
 676     cairo_matrix_invert(&inverted_ctm);
 677     model_matrix = ADG_ENTITY_GET_CLASS(entity)->get_model_matrix(entity);
 678     paper_matrix = ADG_ENTITY_GET_CLASS(entity)->get_paper_matrix(entity);
 679
 680     adg_pair_copy(&model_pair, &point->model);
 681     cpml_pair_transform(&model_pair, model_matrix);
 682
 683     adg_pair_copy(&paper_pair, &point->paper);
 684     cpml_pair_transform(&paper_pair, paper_matrix);
 685
 686     pair->x = model_pair.x + paper_pair.x;
 687     pair->y = model_pair.y + paper_pair.y;
 688
 689     cpml_pair_transform(pair, &inverted_ctm);
 690 }
 691
 692 /**
 693  * adg_entity_point_to_model_pair:
 694  * @entity: an #AdgEntity
 695  * @point: the source #AdgPoint
 696  * @pair: the destination #AdgPair
 697  *
 698  * Converts @point to @pair in model space.
 699  **/
 700 void
 701 adg_entity_point_to_model_pair(AdgEntity *entity,
 702                                const AdgPoint *point, AdgPair *pair)
 703 {
 704     const AdgMatrix *paper_matrix;
 705
 706     g_return_if_fail(ADG_IS_ENTITY(entity));
 707     g_return_if_fail(point != NULL);
 708     g_return_if_fail(pair != NULL);
 709
 710     paper_matrix = ADG_ENTITY_GET_CLASS(entity)->get_paper_matrix(entity);
 711     adg_pair_copy(pair, &point->paper);
 712     cpml_pair_transform(pair, paper_matrix);
 713
 714     pair->x += point->model.x;
 715     pair->y += point->model.y;
 716 }
 717
 718 /**
 719  * adg_entity_point_to_paper_pair:
 720  * @entity: an #AdgEntity
 721  * @point: the source #AdgPoint
 722  * @pair: the destination #AdgPair
 723  *
 724  * Converts @point to @pair in paper space.
 725  **/
 726 void
 727 adg_entity_point_to_paper_pair(AdgEntity *entity,
 728                                const AdgPoint *point, AdgPair *pair)
 729 {
 730     const AdgMatrix *model_matrix;
 731
 732     g_return_if_fail(ADG_IS_ENTITY(entity));
 733     g_return_if_fail(point != NULL);
 734     g_return_if_fail(pair != NULL);
 735
 736     model_matrix = ADG_ENTITY_GET_CLASS(entity)->get_model_matrix(entity);
 737     adg_pair_copy(pair, &point->model);
 738     cpml_pair_transform(pair, model_matrix);
 739
 740     pair->x += point->paper.x;
 741     pair->y += point->paper.y;
 742     g_print("Pair (%lf, %lf)\n", pair->x, pair->y);
 743 }
 744
 745 /**
 746  * adg_entity_model_matrix_applied:
 747  * @entity: an #AdgEntity
 748  *
 749  * Return value: %TRUE if the model matrix didn't change from the last render
 750  */
 751 gboolean
 752 adg_entity_model_matrix_applied(AdgEntity *entity)
 753 {
 754     g_return_val_if_fail(ADG_IS_ENTITY(entity), FALSE);
 755     return ADG_ISSET(entity->priv->flags, MODEL_MATRIX_APPLIED);
 756 }
 757
 758 /**
 759  * adg_entity_paper_matrix_applied:
 760  * @entity: an #AdgEntity
 761  *
 762  * Return value: %TRUE if the paper matrix didn't change from the last render
 763  */
 764 gboolean
 765 adg_entity_paper_matrix_applied(AdgEntity *entity)
 766 {
 767     g_return_val_if_fail(ADG_IS_ENTITY(entity), FALSE);
 768     return ADG_ISSET(entity->priv->flags, PAPER_MATRIX_APPLIED);
 769 }
 770
 771 /**
 772  * adg_entity_model_applied:
 773  * @entity: an #AdgEntity
 774  *
 775  * Return value: %TRUE if the model didn't change from the last render
 776  */
 777 gboolean
 778 adg_entity_model_applied(AdgEntity *entity)
 779 {
 780     g_return_val_if_fail(ADG_IS_ENTITY(entity), FALSE);
 781     return ADG_ISSET(entity->priv->flags, MODEL_APPLIED);
 782 }
 783
 784 /**
 785  * adg_entity_invalidate:
 786  * @entity: an #AdgEntity
 787  *
 788  * Emits the "invalidate" signal on @entity and all its children, if any,
 789  * so subsequent rendering will need a global recomputation.
 790  */
 791 void
 792 adg_entity_invalidate(AdgEntity *entity)
 793 {
 794     g_return_if_fail(ADG_IS_ENTITY(entity));
 795
 796     g_signal_emit(entity, signals[INVALIDATE], 0, NULL);
 797 }
 798
 799 /**
 800  * adg_entity_render:
 801  * @entity: an #AdgEntity
 802  * @cr: a #cairo_t drawing context
 803  *
 804  * Emits the "render" signal on @entity and all its children, if any,
 805  * causing the rendering operation the @cr cairo context.
 806  */
 807 void
 808 adg_entity_render(AdgEntity *entity, cairo_t *cr)
 809 {
 810     g_return_if_fail(ADG_IS_ENTITY(entity));
 811
 812     g_signal_emit(entity, signals[RENDER], 0, cr);
 813 }
 814
 815
 816 static AdgContainer *
 817 get_parent(AdgEntity *entity)
 818 {
 819     return entity->priv->parent;
 820 }
 821
 822 static void
 823 set_parent(AdgEntity *entity, AdgContainer *parent)
 824 {
 825     entity->priv->parent = parent;
 826 }
 827
 828 static void
 829 parent_set(AdgEntity *entity, AdgContainer *old_parent)
 830 {
 831     if (ADG_IS_CONTAINER(old_parent)) {
 832         const AdgMatrix *old_model;
 833         const AdgMatrix *old_paper;
 834
 835         old_model = adg_entity_get_model_matrix((AdgEntity *) old_parent);
 836         old_paper = adg_entity_get_paper_matrix((AdgEntity *) old_parent);
 837
 838         adg_entity_model_matrix_changed(entity, old_model);
 839         adg_entity_paper_matrix_changed(entity, old_paper);
 840     }
 841 }
 842
 843 static AdgContext *
 844 get_context(AdgEntity *entity)
 845 {
 846     AdgEntity *parent;
 847
 848     if (entity->priv->context)
 849         return entity->priv->context;
 850
 851     parent = (AdgEntity *) entity->priv->parent;
 852
 853     return parent ? ADG_ENTITY_GET_CLASS(parent)->get_context(parent) : NULL;
 854 }
 855
 856 static void
 857 set_context(AdgEntity *entity, AdgContext *context)
 858 {
 859     if (entity->priv->context)
 860         g_object_unref((GObject *) entity->priv->context);
 861
 862     g_object_ref((GObject *) context);
 863     entity->priv->context = context;
 864 }
 865
 866 static void
 867 model_matrix_changed(AdgEntity *entity, AdgMatrix *parent_matrix)
 868 {
 869     ADG_UNSET(entity->priv->flags, MODEL_MATRIX_APPLIED);
 870 }
 871
 872 static void
 873 paper_matrix_changed(AdgEntity *entity, AdgMatrix *parent_matrix)
 874 {
 875     ADG_UNSET(entity->priv->flags, PAPER_MATRIX_APPLIED);
 876 }
 877
 878 static void
 879 render(AdgEntity *entity, cairo_t *cr)
 880 {
 881     ADG_SET(entity->priv->flags,
 882             MODEL_MATRIX_APPLIED | PAPER_MATRIX_APPLIED | MODEL_APPLIED);
 883 }
 884
 885 static const AdgMatrix *
 886 get_model_matrix(AdgEntity *entity)
 887 {
 888     return adg_entity_get_model_matrix((AdgEntity *) entity->priv->parent);
 889 }
 890
 891 static const AdgMatrix *
 892 get_paper_matrix(AdgEntity *entity)
 893 {
 894     return adg_entity_get_paper_matrix((AdgEntity *) entity->priv->parent);
 895 }