adg/adg-entity.c

   1 /* ADG - Automatic Drawing Generation
   2  * Copyright (C) 2007-2008, 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 Library 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  * Library 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., 59 Temple Place - Suite 330,
  17  * Boston, MA  02111-1307, 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 #include <gcontainer/gcontainer.h>
  36
  37 #define PARENT_CLASS ((GInitiallyUnownedClass *) adg_entity_parent_class)
  38
  39
  40 enum {
  41     PROP_0,
  42     PROP_PARENT,
  43     PROP_CONTEXT
  44 };
  45
  46 enum {
  47     MODEL_MATRIX_CHANGED,
  48     PAPER_MATRIX_CHANGED,
  49     INVALIDATE,
  50     RENDER,
  51     LAST_SIGNAL
  52 };
  53
  54
  55 static void             childable_init          (GChildableIface*iface);
  56 static void             get_property            (GObject        *object,
  57                                                  guint           prop_id,
  58                                                  GValue         *value,
  59                                                  GParamSpec     *pspec);
  60 static void             set_property            (GObject        *object,
  61                                                  guint           prop_id,
  62                                                  const GValue   *value,
  63                                                  GParamSpec     *pspec);
  64 static GContainerable * get_parent              (GChildable     *childable);
  65 static void             set_parent              (GChildable     *childable,
  66                                                  GContainerable *parent);
  67 static void             parent_set              (GChildable     *childable,
  68                                                  GContainerable *old_parent);
  69 static void             set_context             (AdgEntity      *entity,
  70                                                  AdgContext     *context);
  71 static void             model_matrix_changed    (AdgEntity      *entity,
  72                                                  AdgMatrix      *parent_matrix);
  73 static void             paper_matrix_changed    (AdgEntity      *entity,
  74                                                  AdgMatrix      *parent_matrix);
  75 static void             render                  (AdgEntity      *entity,
  76                                                  cairo_t        *cr);
  77 static const AdgMatrix *get_model_matrix        (AdgEntity      *entity);
  78 static const AdgMatrix *get_paper_matrix        (AdgEntity      *entity);
  79
  80 static guint signals[LAST_SIGNAL] = { 0 };
  81
  82
  83 G_DEFINE_TYPE_EXTENDED(AdgEntity, adg_entity,
  84                        G_TYPE_INITIALLY_UNOWNED, G_TYPE_FLAG_ABSTRACT,
  85                        G_IMPLEMENT_INTERFACE(G_TYPE_CHILDABLE,
  86                                              childable_init));
  87
  88
  89 static void
  90 adg_entity_class_init(AdgEntityClass *klass)
  91 {
  92     GObjectClass *gobject_class;
  93     GParamSpec *param;
  94
  95     gobject_class = (GObjectClass *) klass;
  96
  97     g_type_class_add_private(klass, sizeof(AdgEntityPrivate));
  98
  99     gobject_class->get_property = get_property;
 100     gobject_class->set_property = set_property;
 101     gobject_class->dispose = g_childable_dispose;
 102
 103     klass->model_matrix_changed = model_matrix_changed;
 104     klass->paper_matrix_changed = NULL;
 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     g_object_class_override_property(gobject_class, PROP_PARENT, "parent");
 111
 112     param = g_param_spec_object("context",
 113                                 P_("Context"),
 114                                 P_("The context associated to this entity or NULL to inherit the parent context"),
 115                                 ADG_TYPE_CONTEXT, G_PARAM_READWRITE);
 116     g_object_class_install_property(gobject_class, PROP_CONTEXT, param);
 117
 118   /**
 119    * AdgEntity::invalidate:
 120    * @entity: an #AdgEntity
 121    *
 122    * Clears the cached data of @entity.
 123    */
 124     signals[INVALIDATE] =
 125         g_signal_new("invalidate",
 126                      G_OBJECT_CLASS_TYPE(gobject_class),
 127                      G_SIGNAL_RUN_FIRST,
 128                      G_STRUCT_OFFSET(AdgEntityClass, invalidate),
 129                      NULL, NULL,
 130                      g_cclosure_marshal_VOID__BOOLEAN,
 131                      G_TYPE_NONE, 0);
 132
 133   /**
 134    * AdgEntity::render:
 135    * @entity: an #AdgEntity
 136    * @cr: the destination cairo context
 137    *
 138    * Causes the rendering of @entity on @cr.
 139    */
 140     signals[RENDER] =
 141         g_signal_new("render",
 142                      G_OBJECT_CLASS_TYPE(gobject_class),
 143                      G_SIGNAL_RUN_FIRST,
 144                      G_STRUCT_OFFSET(AdgEntityClass, render),
 145                      NULL, NULL,
 146                      g_cclosure_marshal_VOID__POINTER,
 147                      G_TYPE_NONE, 1, G_TYPE_POINTER);
 148
 149   /**
 150    * AdgEntity::model-matrix-changed:
 151    * @entity: an #AdgEntity
 152    * @parent_matrix: the parent model matrix
 153    *
 154    * Emitted after the current model matrix has changed.
 155    */
 156     signals[MODEL_MATRIX_CHANGED] =
 157         g_signal_new("model-matrix-changed",
 158                      G_OBJECT_CLASS_TYPE(gobject_class),
 159                      G_SIGNAL_RUN_FIRST,
 160                      G_STRUCT_OFFSET(AdgEntityClass, model_matrix_changed),
 161                      NULL, NULL,
 162                      g_cclosure_marshal_VOID__BOXED,
 163                      G_TYPE_NONE, 1,
 164                      ADG_TYPE_MATRIX | G_SIGNAL_TYPE_STATIC_SCOPE);
 165
 166   /**
 167    * AdgEntity::paper-matrix-changed:
 168    * @entity: an #AdgEntity
 169    * @parent_matrix: the parent paper matrix
 170    *
 171    * Emitted after the current paper matrix has changed.
 172    */
 173     signals[PAPER_MATRIX_CHANGED] =
 174         g_signal_new("paper-matrix-changed",
 175                      G_OBJECT_CLASS_TYPE(gobject_class),
 176                      G_SIGNAL_RUN_FIRST,
 177                      G_STRUCT_OFFSET(AdgEntityClass, paper_matrix_changed),
 178                      NULL, NULL,
 179                      g_cclosure_marshal_VOID__BOXED,
 180                      G_TYPE_NONE, 1,
 181                      ADG_TYPE_MATRIX | G_SIGNAL_TYPE_STATIC_SCOPE);
 182 }
 183
 184 static void
 185 childable_init(GChildableIface *iface)
 186 {
 187     iface->get_parent = get_parent;
 188     iface->set_parent = set_parent;
 189     iface->parent_set = parent_set;
 190 }
 191
 192 static void
 193 adg_entity_init(AdgEntity *entity)
 194 {
 195     AdgEntityPrivate *priv =
 196         G_TYPE_INSTANCE_GET_PRIVATE(entity, ADG_TYPE_ENTITY,
 197                                     AdgEntityPrivate);
 198
 199     priv->parent = NULL;
 200     priv->flags = 0;
 201     priv->context = NULL;
 202
 203     entity->priv = priv;
 204 }
 205
 206 static void
 207 get_property(GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
 208 {
 209     AdgEntity *entity = (AdgEntity *) object;
 210
 211     switch (prop_id) {
 212     case PROP_PARENT:
 213         g_value_set_object(value, entity->priv->parent);
 214         break;
 215     case PROP_CONTEXT:
 216         g_value_set_object(value, entity->priv->context);
 217         break;
 218     default:
 219         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
 220         break;
 221     }
 222 }
 223
 224 static void
 225 set_property(GObject *object,
 226              guint prop_id, const GValue *value, GParamSpec *pspec)
 227 {
 228     AdgEntity *entity = (AdgEntity *) object;
 229
 230     switch (prop_id) {
 231     case PROP_PARENT:
 232         entity->priv->parent = (AdgEntity *) g_value_get_object(value);
 233         break;
 234     case PROP_CONTEXT:
 235         set_context(entity, g_value_get_object(value));
 236         break;
 237     default:
 238         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
 239         break;
 240     }
 241 }
 242
 243
 244 /**
 245  * adg_entity_get_context:
 246  * @entity: an #AdgEntity instance
 247  *
 248  * Gets the context associated to @entity.
 249  * If no context was explicitely set, get the parent context.
 250  *
 251  * Return value: the requested context or %NULL on errors
 252  **/
 253 AdgContext *
 254 adg_entity_get_context(AdgEntity *entity)
 255 {
 256     g_return_val_if_fail(ADG_IS_ENTITY(entity), NULL);
 257
 258     if (entity->priv->context)
 259         return entity->priv->context;
 260
 261     if (entity->priv->parent)
 262         return adg_entity_get_context(entity->priv->parent);
 263
 264     return NULL;
 265 }
 266
 267 /**
 268  * adg_entity_set_context:
 269  * @entity: an #AdgEntity instance
 270  * @context: the new context
 271  *
 272  * Sets a new context. The old context (if any) will be unreferenced
 273  * while a new reference will be added to @context.
 274  **/
 275 void
 276 adg_entity_set_context(AdgEntity *entity, AdgContext *context)
 277 {
 278     g_return_if_fail(ADG_IS_ENTITY(entity));
 279     g_return_if_fail(ADG_IS_CONTEXT(context));
 280
 281     set_context(entity, context);
 282     g_object_notify((GObject *) entity, "context");
 283 }
 284
 285 /**
 286  * adg_entity_get_canvas:
 287  * @entity: an #AdgEntity
 288  *
 289  * Walks on the @entity hierarchy and gets the first parent of @entity that is
 290  * of #AdgCanvas derived type.
 291  *
 292  * Return value: the requested object or %NULL if there is no #AdgCanvas in
 293  *               the parent hierarchy.
 294  */
 295 AdgCanvas *
 296 adg_entity_get_canvas(AdgEntity *entity)
 297 {
 298     g_return_val_if_fail(ADG_IS_ENTITY(entity), NULL);
 299
 300     while (entity) {
 301         if (ADG_IS_CANVAS(entity))
 302             return (AdgCanvas *) entity;
 303
 304         entity =
 305             (AdgEntity *) g_childable_get_parent((GChildable *) entity);
 306     }
 307
 308     return NULL;
 309 }
 310
 311 /**
 312  * adg_entity_get_model_matrix:
 313  * @entity: an #AdgEntity object
 314  *
 315  * Gets the model matrix to be used in rendering this @entity.
 316  *
 317  * Return value: the requested matrix
 318  */
 319 const AdgMatrix *
 320 adg_entity_get_model_matrix(AdgEntity *entity)
 321 {
 322     g_return_val_if_fail(ADG_IS_ENTITY(entity), NULL);
 323     return ADG_ENTITY_GET_CLASS(entity)->get_model_matrix(entity);
 324 }
 325
 326 /**
 327  * adg_entity_get_paper_matrix:
 328  * @entity: an #AdgEntity object
 329  *
 330  * Gets the paper matrix to be used in rendering this @entity.
 331  *
 332  * Return value: the requested matrix
 333  */
 334 const AdgMatrix *
 335 adg_entity_get_paper_matrix(AdgEntity *entity)
 336 {
 337     g_return_val_if_fail(ADG_IS_ENTITY(entity), NULL);
 338     return ADG_ENTITY_GET_CLASS(entity)->get_paper_matrix(entity);
 339 }
 340
 341 /**
 342  * adg_entity_scale_to_model:
 343  * @entity: an #AdgEntity object
 344  *
 345  * Sets the model matrix as current matrix on @cr. The translation
 346  * and rotation component of the previous matrix are kept: only the
 347  * scale is changed.
 348  */
 349 void
 350 adg_entity_scale_to_model(AdgEntity *entity, cairo_t *cr)
 351 {
 352     const AdgMatrix *model_matrix;
 353     cairo_matrix_t matrix;
 354
 355     g_return_if_fail(ADG_IS_ENTITY(entity));
 356
 357     model_matrix = ADG_ENTITY_GET_CLASS(entity)->get_model_matrix(entity);
 358     cairo_get_matrix(cr, &matrix);
 359
 360     matrix.xx = model_matrix->xx;
 361     matrix.yy = model_matrix->yy;
 362     cairo_set_matrix(cr, &matrix);
 363 }
 364
 365 /**
 366  * adg_entity_scale_to_paper:
 367  * @entity: an #AdgEntity object
 368  *
 369  * Sets the paper matrix as current matrix on @cr. The translation
 370  * and rotation component of the previous matrix are kept: only the
 371  * scale is changed.
 372  */
 373 void
 374 adg_entity_scale_to_paper(AdgEntity *entity, cairo_t *cr)
 375 {
 376     const AdgMatrix *paper_matrix;
 377     cairo_matrix_t matrix;
 378
 379     g_return_if_fail(ADG_IS_ENTITY(entity));
 380
 381     paper_matrix = ADG_ENTITY_GET_CLASS(entity)->get_paper_matrix(entity);
 382     cairo_get_matrix(cr, &matrix);
 383
 384     matrix.xx = paper_matrix->xx;
 385     matrix.yy = paper_matrix->yy;
 386     cairo_set_matrix(cr, &matrix);
 387 }
 388
 389 /**
 390  * adg_entity_model_matrix_changed:
 391  * @entity: an #AdgEntity
 392  * @parent_matrix: the parent #AdgMatrix
 393  *
 394  * Emits the "model-matrix-changed" signal on @entity.
 395  *
 396  * This function is only useful in entity implementations.
 397  */
 398 void
 399 adg_entity_model_matrix_changed(AdgEntity *entity,
 400                                 const AdgMatrix *parent_matrix)
 401 {
 402     g_return_if_fail(ADG_IS_ENTITY(entity));
 403
 404     g_signal_emit(entity, signals[MODEL_MATRIX_CHANGED], 0, parent_matrix);
 405 }
 406
 407 /**
 408  * adg_entity_paper_matrix_changed:
 409  * @entity: an #AdgEntity
 410  * @parent_matrix: the parent #AdgMatrix
 411  *
 412  * Emits the "paper-matrix-changed" signal on @entity.
 413  *
 414  * This function is only useful in entity implementations.
 415  */
 416 void
 417 adg_entity_paper_matrix_changed(AdgEntity *entity,
 418                                 const AdgMatrix *parent_matrix)
 419 {
 420     g_return_if_fail(ADG_IS_ENTITY(entity));
 421
 422     g_signal_emit(entity, signals[PAPER_MATRIX_CHANGED], 0, parent_matrix);
 423 }
 424
 425 /**
 426  * adg_entity_get_style:
 427  * @entity: an #AdgEntity
 428  * @style_slot: the slot of the style to get
 429  *
 430  * Gets a style from this entity. If the entity has no context associated
 431  * or the style in undefined within this context, gets the style from its
 432  * parent container.
 433  *
 434  * Return value: the requested style
 435  **/
 436 AdgStyle *
 437 adg_entity_get_style(AdgEntity *entity, AdgStyleSlot style_slot)
 438 {
 439     g_return_if_fail(ADG_IS_ENTITY(entity));
 440
 441     if (entity->priv->context) {
 442         AdgStyle *style = adg_context_get_style(entity->priv->context,
 443                                                 style_slot);
 444         if (style)
 445             return style;
 446     }
 447
 448     if (entity->priv->parent)
 449         return adg_entity_get_style(entity->priv->parent, style_slot);
 450
 451     return NULL;
 452 }
 453
 454 /**
 455  * adg_entity_apply:
 456  * @entity: an #AdgEntity
 457  * @style_slot: the slot of the style to apply
 458  * @cr: a cairo context
 459  *
 460  * Applies the specified style to the @cr cairo context.
 461  **/
 462 void
 463 adg_entity_apply(AdgEntity *entity, AdgStyleSlot style_slot, cairo_t *cr)
 464 {
 465     AdgStyle *style = adg_entity_get_style(entity, style_slot);
 466
 467     if (style)
 468         adg_style_apply(style, cr);
 469 }
 470
 471 /**
 472  * adg_entity_model_matrix_applied:
 473  * @entity: an #AdgEntity
 474  *
 475  * Return value: %TRUE if the model matrix didn't change from the last render
 476  */
 477 gboolean
 478 adg_entity_model_matrix_applied(AdgEntity *entity)
 479 {
 480     g_return_val_if_fail(ADG_IS_ENTITY(entity), FALSE);
 481     return ADG_ISSET(entity->priv->flags, MODEL_MATRIX_APPLIED);
 482 }
 483
 484 /**
 485  * adg_entity_paper_matrix_applied:
 486  * @entity: an #AdgEntity
 487  *
 488  * Return value: %TRUE if the paper matrix didn't change from the last render
 489  */
 490 gboolean
 491 adg_entity_paper_matrix_applied(AdgEntity *entity)
 492 {
 493     g_return_val_if_fail(ADG_IS_ENTITY(entity), FALSE);
 494     return ADG_ISSET(entity->priv->flags, PAPER_MATRIX_APPLIED);
 495 }
 496
 497 /**
 498  * adg_entity_model_applied:
 499  * @entity: an #AdgEntity
 500  *
 501  * Return value: %TRUE if the model didn't change from the last render
 502  */
 503 gboolean
 504 adg_entity_model_applied(AdgEntity *entity)
 505 {
 506     g_return_val_if_fail(ADG_IS_ENTITY(entity), FALSE);
 507     return ADG_ISSET(entity->priv->flags, MODEL_APPLIED);
 508 }
 509
 510 /**
 511  * adg_entity_invalidate:
 512  * @entity: an #AdgEntity
 513  *
 514  * Emits the "invalidate" signal on @entity and all its children, if any,
 515  * so subsequent rendering will need a global recomputation.
 516  */
 517 void
 518 adg_entity_invalidate(AdgEntity *entity)
 519 {
 520     g_return_if_fail(ADG_IS_ENTITY(entity));
 521
 522     g_signal_emit(entity, signals[INVALIDATE], 0, NULL);
 523 }
 524
 525 /**
 526  * adg_entity_render:
 527  * @entity: an #AdgEntity
 528  * @cr: a #cairo_t drawing context
 529  *
 530  * Emits the "render" signal on @entity and all its children, if any,
 531  * causing the rendering operation the @cr cairo context.
 532  */
 533 void
 534 adg_entity_render(AdgEntity *entity, cairo_t *cr)
 535 {
 536     g_return_if_fail(ADG_IS_ENTITY(entity));
 537
 538     g_signal_emit(entity, signals[RENDER], 0, cr);
 539 }
 540
 541
 542 static GContainerable *
 543 get_parent(GChildable *childable)
 544 {
 545     return (GContainerable *) ((AdgEntity *) childable)->priv->parent;
 546 }
 547
 548 static void
 549 set_parent(GChildable *childable, GContainerable *parent)
 550 {
 551     ((AdgEntity *) childable)->priv->parent = (AdgEntity *) parent;
 552     g_object_notify((GObject *) childable, "parent");
 553 }
 554
 555 static void
 556 parent_set(GChildable *childable, GContainerable *old_parent)
 557 {
 558     if (ADG_IS_CONTAINER(old_parent)) {
 559         AdgEntity *entity;
 560         const AdgMatrix *old_model;
 561         const AdgMatrix *old_paper;
 562
 563         entity = (AdgEntity *) childable;
 564         old_model = adg_entity_get_model_matrix((AdgEntity *) old_parent);
 565         old_paper = adg_entity_get_paper_matrix((AdgEntity *) old_parent);
 566
 567         adg_entity_model_matrix_changed(entity, old_model);
 568         adg_entity_paper_matrix_changed(entity, old_paper);
 569     }
 570 }
 571
 572 static void
 573 set_context(AdgEntity *entity, AdgContext *context)
 574 {
 575     if (entity->priv->context)
 576         g_object_unref((GObject *) entity->priv->context);
 577
 578     g_object_ref((GObject *) context);
 579     entity->priv->context = context;
 580 }
 581
 582 static void
 583 model_matrix_changed(AdgEntity *entity, AdgMatrix *parent_matrix)
 584 {
 585     ADG_UNSET(entity->priv->flags, MODEL_MATRIX_APPLIED);
 586 }
 587
 588 static void
 589 paper_matrix_changed(AdgEntity *entity, AdgMatrix *parent_matrix)
 590 {
 591     ADG_UNSET(entity->priv->flags, PAPER_MATRIX_APPLIED);
 592 }
 593
 594 static void
 595 render(AdgEntity *entity, cairo_t *cr)
 596 {
 597     ADG_SET(entity->priv->flags,
 598             MODEL_MATRIX_APPLIED | PAPER_MATRIX_APPLIED | MODEL_APPLIED);
 599 }
 600
 601 static const AdgMatrix *
 602 get_model_matrix(AdgEntity *entity)
 603 {
 604     return adg_entity_get_model_matrix((AdgEntity *) entity->priv->parent);
 605 }
 606
 607 static const AdgMatrix *
 608 get_paper_matrix(AdgEntity *entity)
 609 {
 610     return adg_entity_get_paper_matrix((AdgEntity *) entity->priv->parent);
 611 }