adg/adg-dim.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-dim
  23  * @short_description: Root abstract class for all dimension entities
  24  *
  25  * The #AdgDim class is the base stub of all the dimension entities.
  26  **/
  27
  28 /**
  29  * AdgDim:
  30  *
  31  * All fields are private and should not be used directly.
  32  * Use its public methods instead.
  33  **/
  34
  35
  36 #include "adg-dim.h"
  37 #include "adg-dim-private.h"
  38 #include "adg-dim-style.h"
  39 #include "adg-dress-builtins.h"
  40 #include "adg-toy-text.h"
  41 #include "adg-type-builtins.h"
  42 #include "adg-intl.h"
  43
  44 #define PARENT_OBJECT_CLASS  ((GObjectClass *) adg_dim_parent_class)
  45 #define PARENT_ENTITY_CLASS  ((AdgEntityClass *) adg_dim_parent_class)
  46
  47
  48 enum {
  49     PROP_0,
  50     PROP_DIM_DRESS,
  51     PROP_REF1,
  52     PROP_REF2,
  53     PROP_POS,
  54     PROP_LEVEL,
  55     PROP_OUTSIDE,
  56     PROP_VALUE,
  57     PROP_MIN,
  58     PROP_MAX
  59 };
  60
  61
  62 static void     dispose                 (GObject        *object);
  63 static void     finalize                (GObject        *object);
  64 static void     get_property            (GObject        *object,
  65                                          guint           param_id,
  66                                          GValue         *value,
  67                                          GParamSpec     *pspec);
  68 static void     set_property            (GObject        *object,
  69                                          guint           param_id,
  70                                          const GValue   *value,
  71                                          GParamSpec     *pspec);
  72 static void     global_changed          (AdgEntity      *entity);
  73 static void     local_changed           (AdgEntity      *entity);
  74 static void     invalidate              (AdgEntity      *entity);
  75 static void     arrange                 (AdgEntity      *entity);
  76 static gchar *  default_value           (AdgDim         *dim);
  77 static gdouble  quote_angle             (gdouble         angle);
  78 static gboolean set_dim_dress           (AdgDim         *dim,
  79                                          AdgDress        dress);
  80 static gboolean set_value               (AdgDim         *dim,
  81                                          const gchar    *value);
  82 static gboolean set_min                 (AdgDim         *dim,
  83                                          const gchar    *min);
  84 static gboolean set_max                 (AdgDim         *dim,
  85                                          const gchar    *max);
  86
  87
  88 G_DEFINE_ABSTRACT_TYPE(AdgDim, adg_dim, ADG_TYPE_ENTITY);
  89
  90
  91 static void
  92 adg_dim_class_init(AdgDimClass *klass)
  93 {
  94     GObjectClass *gobject_class;
  95     AdgEntityClass *entity_class;
  96     GParamSpec *param;
  97
  98     gobject_class = (GObjectClass *) klass;
  99     entity_class = (AdgEntityClass *) klass;
 100
 101     g_type_class_add_private(klass, sizeof(AdgDimPrivate));
 102
 103     gobject_class->dispose = dispose;
 104     gobject_class->finalize = finalize;
 105     gobject_class->get_property = get_property;
 106     gobject_class->set_property = set_property;
 107
 108     entity_class->global_changed = global_changed;
 109     entity_class->local_changed = local_changed;
 110     entity_class->invalidate = invalidate;
 111     entity_class->arrange = arrange;
 112
 113     klass->quote_angle = quote_angle;
 114     klass->default_value = default_value;
 115
 116     param = adg_param_spec_dress("dim-dress",
 117                                  P_("Dimension Dress"),
 118                                  P_("The dress to use for rendering this dimension"),
 119                                  ADG_DRESS_DIMENSION,
 120                                  G_PARAM_READWRITE);
 121     g_object_class_install_property(gobject_class, PROP_DIM_DRESS, param);
 122
 123     param = g_param_spec_boxed("ref1",
 124                                P_("Reference 1"),
 125                                P_("First reference point of the dimension"),
 126                                ADG_TYPE_POINT,
 127                                G_PARAM_READWRITE);
 128     g_object_class_install_property(gobject_class, PROP_REF1, param);
 129
 130     param = g_param_spec_boxed("ref2",
 131                                P_("Reference 2"),
 132                                P_("Second reference point of the dimension"),
 133                                ADG_TYPE_POINT,
 134                                G_PARAM_READWRITE);
 135     g_object_class_install_property(gobject_class, PROP_REF2, param);
 136
 137     param = g_param_spec_boxed("pos",
 138                                P_("Position"),
 139                                P_("The reference position in local space of the quote: it will be combined with \"level\" to get the real quote position"),
 140                                ADG_TYPE_POINT,
 141                                G_PARAM_READWRITE);
 142     g_object_class_install_property(gobject_class, PROP_POS, param);
 143
 144     param = g_param_spec_double("level",
 145                                 P_("Level"),
 146                                 P_("The dimension level, that is the factor to multiply the baseline spacing (defined in the dimension style) to get the offset from pos where the quote should be rendered"),
 147                                 -G_MAXDOUBLE, G_MAXDOUBLE, 1.0,
 148                                 G_PARAM_READWRITE);
 149     g_object_class_install_property(gobject_class, PROP_LEVEL, param);
 150
 151     param = g_param_spec_enum("outside",
 152                                 P_("Outside"),
 153                                 P_("Whether the arrows must be inside the extension lines (ADG_THREE_STATE_OFF), must be extended outside the extension lines (ADG_THREE_STATE_ON) or should be automatically handled depending on the available space"),
 154                                 ADG_TYPE_THREE_STATE, ADG_THREE_STATE_UNKNOWN,
 155                                 G_PARAM_READWRITE);
 156     g_object_class_install_property(gobject_class, PROP_OUTSIDE, param);
 157
 158     param = g_param_spec_string("value",
 159                                 P_("Basic Value"),
 160                                 P_("The theoretically exact value for this quote: set to NULL to automatically get the default value"),
 161                                 NULL,
 162                                 G_PARAM_READWRITE);
 163     g_object_class_install_property(gobject_class, PROP_VALUE, param);
 164
 165     param = g_param_spec_string("value-min",
 166                                 P_("Minimum Value or Low Tolerance"),
 167                                 P_("The minimum value allowed or the lowest tolerance from value (depending of the dimension style): set to NULL to suppress"),
 168                                 NULL,
 169                                 G_PARAM_READWRITE);
 170     g_object_class_install_property(gobject_class, PROP_MIN, param);
 171
 172     param = g_param_spec_string("value-max",
 173                                 P_("Maximum Value or High Tolerance"),
 174                                 P_("The maximum value allowed or the highest tolerance from value (depending of the dimension style): set to NULL to suppress"),
 175                                 NULL,
 176                                 G_PARAM_READWRITE);
 177     g_object_class_install_property(gobject_class, PROP_MAX, param);
 178 }
 179
 180 static void
 181 adg_dim_init(AdgDim *dim)
 182 {
 183     AdgDimPrivate *data = G_TYPE_INSTANCE_GET_PRIVATE(dim, ADG_TYPE_DIM,
 184                                                       AdgDimPrivate);
 185
 186     data->dim_dress = ADG_DRESS_DIMENSION;
 187     data->ref1 = NULL;
 188     data->ref2 = NULL;
 189     data->pos = NULL;
 190     data->level = 1;
 191     data->outside = ADG_THREE_STATE_UNKNOWN;
 192     data->value = NULL;
 193     data->min = NULL;
 194     data->max = NULL;
 195
 196     dim->data = data;
 197 }
 198
 199 static void
 200 dispose(GObject *object)
 201 {
 202     AdgDimPrivate *data = ((AdgDim *) object)->data;
 203
 204     if (data->quote.container != NULL) {
 205         g_object_unref(data->quote.container);
 206         data->quote.container = NULL;
 207     }
 208     if (data->ref1 != NULL) {
 209         adg_point_destroy(data->ref1);
 210         data->ref1 = NULL;
 211     }
 212     if (data->ref2 != NULL) {
 213         adg_point_destroy(data->ref2);
 214         data->ref2 = NULL;
 215     }
 216     if (data->pos != NULL) {
 217         adg_point_destroy(data->pos);
 218         data->pos = NULL;
 219     }
 220
 221     if (PARENT_OBJECT_CLASS->dispose != NULL)
 222         PARENT_OBJECT_CLASS->dispose(object);
 223 }
 224
 225 static void
 226 finalize(GObject *object)
 227 {
 228     AdgDimPrivate *data = ((AdgDim *) object)->data;
 229
 230     g_free(data->value);
 231     g_free(data->min);
 232     g_free(data->max);
 233
 234     if (PARENT_OBJECT_CLASS->finalize != NULL)
 235         PARENT_OBJECT_CLASS->finalize(object);
 236 }
 237
 238 static void
 239 get_property(GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
 240 {
 241     AdgDimPrivate *data = ((AdgDim *) object)->data;
 242
 243     switch (prop_id) {
 244     case PROP_DIM_DRESS:
 245         g_value_set_int(value, data->dim_dress);
 246         break;
 247     case PROP_REF1:
 248         g_value_set_boxed(value, data->ref1);
 249         break;
 250     case PROP_REF2:
 251         g_value_set_boxed(value, data->ref2);
 252         break;
 253     case PROP_POS:
 254         g_value_set_boxed(value, data->pos);
 255         break;
 256     case PROP_LEVEL:
 257         g_value_set_double(value, data->level);
 258         break;
 259     case PROP_OUTSIDE:
 260         g_value_set_enum(value, data->outside);
 261         break;
 262     case PROP_VALUE:
 263         g_value_set_string(value, data->value);
 264         break;
 265     case PROP_MIN:
 266         g_value_set_string(value, data->min);
 267         break;
 268     case PROP_MAX:
 269         g_value_set_string(value, data->max);
 270         break;
 271     default:
 272         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
 273         break;
 274     }
 275 }
 276
 277 static void
 278 set_property(GObject *object, guint prop_id,
 279              const GValue *value, GParamSpec *pspec)
 280 {
 281     AdgDim *dim;
 282     AdgDimPrivate *data;
 283
 284     dim = (AdgDim *) object;
 285     data = dim->data;
 286
 287     switch (prop_id) {
 288     case PROP_DIM_DRESS:
 289         set_dim_dress(dim, g_value_get_int(value));
 290         break;
 291     case PROP_REF1:
 292         if (data->ref1 != NULL)
 293             adg_point_destroy(data->ref1);
 294         data->ref1 = g_value_dup_boxed(value);
 295         break;
 296     case PROP_REF2:
 297         if (data->ref2 != NULL)
 298             adg_point_destroy(data->ref2);
 299         data->ref2 = g_value_dup_boxed(value);
 300         break;
 301     case PROP_POS:
 302         if (data->pos != NULL)
 303             adg_point_destroy(data->pos);
 304         data->pos = g_value_dup_boxed(value);
 305         break;
 306     case PROP_LEVEL:
 307         data->level = g_value_get_double(value);
 308         break;
 309     case PROP_OUTSIDE:
 310         data->outside = g_value_get_enum(value);
 311         break;
 312     case PROP_VALUE:
 313         set_value(dim, g_value_get_string(value));
 314         break;
 315     case PROP_MIN:
 316         set_min(dim, g_value_get_string(value));
 317         break;
 318     case PROP_MAX:
 319         set_max(dim, g_value_get_string(value));
 320         break;
 321     default:
 322         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
 323         break;
 324     }
 325 }
 326
 327
 328 /**
 329  * adg_dim_get_dim_dress:
 330  * @dim: an #AdgDim
 331  *
 332  * Gets the dimension dress to be used in rendering @dim.
 333  *
 334  * Returns: the current dimension dress
 335  **/
 336 AdgDress
 337 adg_dim_get_dim_dress(AdgDim *dim)
 338 {
 339     AdgDimPrivate *data;
 340
 341     g_return_val_if_fail(ADG_IS_DIM(dim), ADG_DRESS_UNDEFINED);
 342
 343     data = dim->data;
 344
 345     return data->dim_dress;
 346 }
 347
 348 /**
 349  * adg_dim_set_dim_dress:
 350  * @dim: an #AdgDim
 351  * @dress: the new #AdgDress to use
 352  *
 353  * Sets a new dimension dress to @dim. The new dress must be
 354  * related to the original dress for this property: you cannot
 355  * set a dress used for line styles to a dress managing fonts.
 356  *
 357  * The check is done by calling adg_dress_are_related() with
 358  * @dress and the previous dress as arguments. Check out its
 359  * documentation for details on what is a related dress.
 360  **/
 361 void
 362 adg_dim_set_dim_dress(AdgDim *dim, AdgDress dress)
 363 {
 364     g_return_if_fail(ADG_IS_DIM(dim));
 365
 366     if (set_dim_dress(dim, dress))
 367         g_object_notify((GObject *) dim, "dim-dress");
 368 }
 369
 370 /**
 371  * adg_dim_get_ref1:
 372  * @dim: an #AdgDim
 373  *
 374  * Gets the ref1 coordinates. The returned pair is internally owned
 375  * and must not be freed or modified.
 376  *
 377  * Returns: the ref1 coordinates
 378  **/
 379 const AdgPair *
 380 adg_dim_get_ref1(AdgDim *dim)
 381 {
 382     AdgDimPrivate *data;
 383
 384     g_return_val_if_fail(ADG_IS_DIM(dim), NULL);
 385
 386     data = dim->data;
 387
 388     return adg_point_pair(data->ref1);
 389 }
 390
 391 /**
 392  * adg_dim_get_ref2:
 393  * @dim: an #AdgDim
 394  *
 395  * Gets the ref2 coordinates. The returned pair is internally owned
 396  * and must not be freed or modified.
 397  *
 398  * Returns: the ref2 coordinates
 399  **/
 400 const AdgPair *
 401 adg_dim_get_ref2(AdgDim *dim)
 402 {
 403     AdgDimPrivate *data;
 404
 405     g_return_val_if_fail(ADG_IS_DIM(dim), NULL);
 406
 407     data = dim->data;
 408
 409     return adg_point_pair(data->ref2);
 410 }
 411
 412 /**
 413  * adg_dim_set_ref:
 414  * @dim: an #AdgDim
 415  * @ref1: the ref1 coordinates
 416  * @ref2: the ref2 coordinates
 417  *
 418  * Sets the #AdgDim:ref1 and #AdgDim:ref2 reference points
 419  * using @ref1 and @ref2 pairs.  @ref1 or @ref2 could be
 420  * %NULL (but not both), in which case only the non-null
 421  * reference point is changed.
 422  **/
 423 void
 424 adg_dim_set_ref(AdgDim *dim, const AdgPair *ref1, const AdgPair *ref2)
 425 {
 426     GObject *object;
 427     AdgDimPrivate *data;
 428
 429     g_return_if_fail(ADG_IS_DIM(dim));
 430     g_return_if_fail(ref1 != NULL || ref2 != NULL);
 431
 432     data = dim->data;
 433     object = (GObject *) dim;
 434
 435     g_object_freeze_notify(object);
 436
 437     if (ref1 != NULL) {
 438         if (data->ref1 == NULL)
 439             data->ref1 = adg_point_new();
 440
 441         adg_point_set(data->ref1, ref1);
 442
 443         g_object_notify(object, "ref1");
 444     }
 445
 446     if (ref2 != NULL) {
 447         if (data->ref2 == NULL)
 448             data->ref2 = adg_point_new();
 449
 450         adg_point_set(data->ref2, ref2);
 451
 452         g_object_notify(object, "ref2");
 453     }
 454
 455     g_object_thaw_notify(object);
 456 }
 457
 458 /**
 459  * adg_dim_set_ref_explicit:
 460  * @dim: an #AdgDim
 461  * @ref1_x: x coordinate of ref1
 462  * @ref1_y: y coordinate of ref1
 463  * @ref2_x: x coordinate of ref2
 464  * @ref2_y: y coordinate of ref2
 465  *
 466  * Works in the same way as adg_dim_set_ref() but using
 467  * explicit coordinates instead of #AdgPair args. The
 468  * notable difference is that, by using gdouble values,
 469  * you can't set only a single reference point.
 470  **/
 471 void
 472 adg_dim_set_ref_explicit(AdgDim *dim,
 473                          gdouble ref1_x, gdouble ref1_y,
 474                          gdouble ref2_x, gdouble ref2_y)
 475 {
 476     AdgPair ref1, ref2;
 477
 478     ref1.x = ref1_x;
 479     ref1.y = ref1_y;
 480     ref2.x = ref2_x;
 481     ref2.y = ref2_y;
 482
 483     adg_dim_set_ref(dim, &ref1, &ref2);
 484 }
 485
 486 /**
 487  * adg_dim_set_ref_from_model:
 488  * @dim: an #AdgDim
 489  * @model: the source #AdgModel
 490  * @ref1: name of the pair in @model to use as ref1
 491  * @ref2: name of the pair in @model to use as ref2
 492  *
 493  * Sets #AdgDim:ref1 and #AdgDim:ref2 properties by linking
 494  * them to the @ref1 and @ref2 named pairs in @model. @ref1
 495  * or @ref2 could be %NULL (but not both), in which case
 496  * only the non-null reference point is changed.
 497  *
 498  * Using this function twice you can also link the reference
 499  * points to named pairs taken from different models:
 500  *
 501  * |[
 502  * adg_dim_set_ref_from_model(dim, model1, ref1, NULL);
 503  * adg_dim_set_ref_from_model(dim, model2, NULL, ref2);
 504  * ]|
 505  **/
 506 void
 507 adg_dim_set_ref_from_model(AdgDim *dim, AdgModel *model,
 508                            const gchar *ref1, const gchar *ref2)
 509 {
 510     GObject *object;
 511     AdgDimPrivate *data;
 512
 513     g_return_if_fail(ADG_IS_DIM(dim));
 514     g_return_if_fail(ADG_IS_MODEL(model));
 515     g_return_if_fail(ref1 != NULL || ref2 != NULL);
 516
 517     object = (GObject *) dim;
 518     data = dim->data;
 519
 520     g_object_freeze_notify(object);
 521
 522     if (ref1 != NULL) {
 523         if (data->ref1 == NULL)
 524             data->ref1 = adg_point_new();
 525
 526         adg_point_set_from_model(data->ref1, model, ref1);
 527
 528         g_object_notify(object, "ref1");
 529     }
 530
 531     if (ref2 != NULL) {
 532         if (data->ref2 == NULL)
 533             data->ref2 = adg_point_new();
 534
 535         adg_point_set_from_model(data->ref2, model, ref2);
 536
 537         g_object_notify(object, "ref2");
 538     }
 539
 540     g_object_thaw_notify(object);
 541 }
 542
 543 /**
 544  * adg_dim_get_pos:
 545  * @dim: an #AdgDim
 546  *
 547  * Gets the position coordinates. The returned pair is internally owned
 548  * and must not be freed or modified.
 549  *
 550  * Returns: the pos coordinates
 551  **/
 552 const AdgPair *
 553 adg_dim_get_pos(AdgDim *dim)
 554 {
 555     AdgDimPrivate *data;
 556
 557     g_return_val_if_fail(ADG_IS_DIM(dim), NULL);
 558
 559     data = dim->data;
 560
 561     return adg_point_pair(data->pos);
 562 }
 563
 564 /**
 565  * adg_dim_set_pos:
 566  * @dim: an #AdgDim
 567  * @pos: the pos coordinates
 568  *
 569  * Sets a new #AdgDim:pos position.
 570  **/
 571 void
 572 adg_dim_set_pos(AdgDim *dim, const AdgPair *pos)
 573 {
 574     AdgDimPrivate *data;
 575
 576     g_return_if_fail(ADG_IS_DIM(dim));
 577     g_return_if_fail(pos != NULL);
 578
 579     data = dim->data;
 580
 581     if (data->pos == NULL)
 582         data->pos = adg_point_new();
 583
 584     adg_point_set(data->pos, pos);
 585
 586     g_object_notify((GObject *) dim, "pos");
 587 }
 588
 589 /**
 590  * adg_dim_set_pos_explicit:
 591  * @dim: an #AdgDim
 592  * @pos_x: x coordinate of pos
 593  * @pos_y: y coordinate of pos
 594  *
 595  * Shortcut to set #AdgDim:pos using explicit coordinates.
 596  **/
 597 void
 598 adg_dim_set_pos_explicit(AdgDim *dim, gdouble x, gdouble y)
 599 {
 600     AdgPair pos;
 601
 602     pos.x = x;
 603     pos.y = y;
 604
 605     adg_dim_set_pos(dim, &pos);
 606 }
 607
 608 /**
 609  * adg_dim_set_pos_from_model:
 610  * @dim: an #AdgDim
 611  * @model: the source #AdgModel
 612  * @ref1: name of the pair in @model to use as pos
 613  *
 614  * Sets #AdgDim:pos by linking it to the @pos named pair
 615  * in @model.
 616  **/
 617 void
 618 adg_dim_set_pos_from_model(AdgDim *dim, AdgModel *model, const gchar *pos)
 619 {
 620     AdgDimPrivate *data;
 621
 622     g_return_if_fail(ADG_IS_DIM(dim));
 623     g_return_if_fail(ADG_IS_MODEL(model));
 624     g_return_if_fail(pos != NULL);
 625
 626     data = dim->data;
 627
 628     if (data->pos == NULL)
 629         data->pos = adg_point_new();
 630
 631     adg_point_set_from_model(data->pos, model, pos);
 632
 633     g_object_notify((GObject *) dim, "pos");
 634 }
 635
 636 /**
 637  * adg_dim_get_level:
 638  * @dim: an #AdgDim
 639  *
 640  * Gets the level of this dimension.
 641  *
 642  * Returns: the level value
 643  **/
 644 gdouble
 645 adg_dim_get_level(AdgDim *dim)
 646 {
 647     AdgDimPrivate *data;
 648
 649     g_return_val_if_fail(ADG_IS_DIM(dim), 0);
 650
 651     data = dim->data;
 652
 653     return data->level;
 654 }
 655
 656 /**
 657  * adg_dim_set_level:
 658  * @dim: an #AdgDim
 659  * @level: the new level
 660  *
 661  * Sets a new level for this dimension. The level is used to
 662  * stack the quotes using a spacing value from dim_style
 663  * (specified in global space).
 664  **/
 665 void
 666 adg_dim_set_level(AdgDim *dim, gdouble level)
 667 {
 668     AdgDimPrivate *data;
 669
 670     g_return_if_fail(ADG_IS_DIM(dim));
 671
 672     data = dim->data;
 673     data->level = level;
 674
 675     g_object_notify((GObject *) dim, "level");
 676 }
 677
 678 /**
 679  * adg_dim_get_outside:
 680  * @dim: an #AdgDim
 681  *
 682  * Gets the state of the #AdgDim:outside property: check the property
 683  * documentation for further details.
 684  *
 685  * Returns: the current flag state
 686  **/
 687 AdgThreeState
 688 adg_dim_get_outside(AdgDim *dim)
 689 {
 690     AdgDimPrivate *data;
 691
 692     g_return_val_if_fail(ADG_IS_DIM(dim), ADG_THREE_STATE_UNKNOWN);
 693
 694     data = dim->data;
 695
 696     return data->outside;
 697 }
 698
 699 /**
 700  * adg_dim_set_outside:
 701  * @dim: an #AdgDim
 702  * @outside: the new outside state
 703  *
 704  * Sets a new state for the #AdgDim:outside flag: check the property
 705  * documentation for further details.
 706  **/
 707 void
 708 adg_dim_set_outside(AdgDim *dim, AdgThreeState outside)
 709 {
 710     AdgDimPrivate *data;
 711
 712     g_return_if_fail(ADG_IS_DIM(dim));
 713
 714     data = dim->data;
 715     data->outside = outside;
 716
 717     g_object_notify((GObject *) dim, "outside");
 718 }
 719
 720 /**
 721  * adg_dim_get_value:
 722  * @dim: an #AdgDim
 723  *
 724  * Gets the value text. The string is internally owned and
 725  * must not be freed or modified.
 726  *
 727  * Returns: the value text
 728  **/
 729 const gchar *
 730 adg_dim_get_value(AdgDim *dim)
 731 {
 732     AdgDimPrivate *data;
 733
 734     g_return_val_if_fail(ADG_IS_DIM(dim), NULL);
 735
 736     data = dim->data;
 737
 738     return data->value;
 739 }
 740
 741 /**
 742  * adg_dim_set_value:
 743  * @dim: an #AdgDim
 744  * @value: the value text
 745  *
 746  * Explicitely sets the text to use as value. If @value is %NULL or
 747  * was never set, an automatic text is calculated using the format
 748  * specified in the current #AdgDimStyle and getting its value by
 749  * calling the default_value() virtual method.
 750  **/
 751 void
 752 adg_dim_set_value(AdgDim *dim, const gchar *value)
 753 {
 754     g_return_if_fail(ADG_IS_DIM(dim));
 755
 756     if (set_value(dim, value))
 757         g_object_notify((GObject *) dim, "value");
 758 }
 759
 760 /**
 761  * adg_dim_get_min:
 762  * @dim: an #AdgDim
 763  *
 764  * Gets the minimum value text or %NULL on minimum value disabled.
 765  * The string is internally owned and must not be freed or modified.
 766  *
 767  * Returns: the mimimum value text
 768  **/
 769 const gchar *
 770 adg_dim_get_min(AdgDim *dim)
 771 {
 772     AdgDimPrivate *data;
 773
 774     g_return_val_if_fail(ADG_IS_DIM(dim), NULL);
 775
 776     data = dim->data;
 777
 778     return data->min;
 779 }
 780
 781 /**
 782  * adg_dim_set_min:
 783  * @dim: an #AdgDim
 784  * @min: the new minimum limit
 785  *
 786  * Sets the minimum value. Use %NULL as @min to disable it.
 787  **/
 788 void
 789 adg_dim_set_min(AdgDim *dim, const gchar *min)
 790 {
 791     g_return_if_fail(ADG_IS_DIM(dim));
 792
 793     if (set_min(dim, min))
 794         g_object_notify((GObject *) dim, "value-min");
 795 }
 796
 797 /**
 798  * adg_dim_get_max:
 799  * @dim: an #AdgDim
 800  *
 801  * Gets the maximum value text or %NULL on maximum value disabled.
 802  * The string is internally owned and must not be freed or modified.
 803  *
 804  * Returns: the maximum value text
 805  **/
 806 const gchar *
 807 adg_dim_get_max(AdgDim *dim)
 808 {
 809     AdgDimPrivate *data;
 810
 811     g_return_val_if_fail(ADG_IS_DIM(dim), NULL);
 812
 813     data = dim->data;
 814
 815     return data->max;
 816 }
 817
 818 /**
 819  * adg_dim_set_max:
 820  * @dim: an #AdgDim
 821  * @max: the new maximum value
 822  *
 823  * Sets the maximum value. Use %NULL as @max to disable it.
 824  **/
 825 void
 826 adg_dim_set_max(AdgDim *dim, const gchar *max)
 827 {
 828     g_return_if_fail(ADG_IS_DIM(dim));
 829
 830     if (set_max(dim, max))
 831         g_object_notify((GObject *) dim, "value-max");
 832 }
 833
 834 /**
 835  * adg_dim_set_limits:
 836  * @dim: an #AdgDim
 837  * @min: the new minumum value
 838  * @max: the new maximum value
 839  *
 840  * Shortcut to set both the limits at once.
 841  **/
 842 void
 843 adg_dim_set_limits(AdgDim *dim, const gchar *min, const gchar *max)
 844 {
 845     g_return_if_fail(ADG_IS_DIM(dim));
 846
 847     g_object_freeze_notify((GObject *) dim);
 848     adg_dim_set_min(dim, min);
 849     adg_dim_set_max(dim, max);
 850     g_object_thaw_notify((GObject *) dim);
 851 }
 852
 853 /**
 854  * adg_dim_get_quote:
 855  * @dim: an #AdgDim
 856  *
 857  * <note><para>
 858  * This function is only useful in new dimension implementations.
 859  * </para></note>
 860  *
 861  * Gets the quote container, if any. This function is valid only
 862  * after the #AdgDim implementation of the arrange() virtual method
 863  * has been called.
 864  *
 865  * Returns: the quote container
 866  **/
 867 AdgContainer *
 868 adg_dim_get_quote(AdgDim *dim)
 869 {
 870     AdgDimPrivate *data;
 871
 872     g_return_val_if_fail(ADG_IS_DIM(dim), NULL);
 873
 874     data = dim->data;
 875
 876     return data->quote.container;
 877 }
 878
 879 /**
 880  * adg_dim_quote_angle:
 881  * @dim: an #AdgDim
 882  * @angle: an angle (in radians)
 883  *
 884  * <note><para>
 885  * This function is only useful in new dimension implementations.
 886  * </para></note>
 887  *
 888  * Converts @angle accordling to the style of @dim. Any quote angle
 889  * should be validated by this method because every dimensioning
 890  * style has its own convention regardling the text rotation.
 891  *
 892  * Returns: the angle to use (always in radians)
 893  **/
 894 gdouble
 895 adg_dim_quote_angle(AdgDim *dim, gdouble angle)
 896 {
 897     AdgDimClass *klass;
 898
 899     g_return_val_if_fail(ADG_IS_DIM(dim), angle);
 900
 901     klass = ADG_DIM_GET_CLASS(dim);
 902
 903     if (klass->quote_angle == NULL)
 904         return angle;
 905
 906     return klass->quote_angle(angle);
 907 }
 908
 909
 910 static void
 911 arrange(AdgEntity *entity)
 912 {
 913     AdgDim *dim;
 914     AdgDimPrivate *data;
 915     AdgEntity *container_entity;
 916     AdgEntity *value_entity;
 917     AdgEntity *min_entity;
 918     AdgEntity *max_entity;
 919     gdouble width;
 920     const CpmlExtents *extents;
 921     AdgMatrix map;
 922     const AdgPair *shift;
 923
 924     dim = (AdgDim *) entity;
 925     data = dim->data;
 926
 927     /* Resolve the dim style */
 928     if (data->dim_style == NULL)
 929         data->dim_style = (AdgDimStyle *)
 930             adg_entity_style(entity, data->dim_dress);
 931
 932     if (data->quote.container == NULL)
 933         data->quote.container = g_object_new(ADG_TYPE_CONTAINER,
 934                                              "parent", dim, NULL);
 935
 936     if (data->quote.value == NULL) {
 937         AdgDress dress = adg_dim_style_get_value_dress(data->dim_style);
 938
 939         data->quote.value = g_object_new(ADG_TYPE_TOY_TEXT,
 940                                          "local-mode", ADG_TRANSFORM_BEFORE_NORMALIZED,
 941                                          "font-dress", dress, NULL);
 942
 943         adg_container_add(data->quote.container,
 944                           (AdgEntity *) data->quote.value);
 945
 946         if (data->value == NULL) {
 947             /* Automatically generate the value text */
 948             gchar *text = ADG_DIM_GET_CLASS(dim)->default_value(dim);
 949             adg_toy_text_set_label(data->quote.value, text);
 950             g_free(text);
 951         } else {
 952             adg_toy_text_set_label(data->quote.value, data->value);
 953         }
 954     }
 955
 956     if (data->quote.min == NULL && data->min != NULL) {
 957         AdgDress dress = adg_dim_style_get_min_dress(data->dim_style);
 958
 959         data->quote.min = g_object_new(ADG_TYPE_TOY_TEXT,
 960                                        "local-mode", ADG_TRANSFORM_BEFORE_NORMALIZED,
 961                                        "font-dress", dress, NULL);
 962
 963         adg_container_add(data->quote.container, (AdgEntity *) data->quote.min);
 964         adg_toy_text_set_label(data->quote.min, data->min);
 965     }
 966
 967     if (data->quote.max == NULL && data->max != NULL) {
 968         AdgDress dress = adg_dim_style_get_max_dress(data->dim_style);
 969
 970         data->quote.max = g_object_new(ADG_TYPE_TOY_TEXT,
 971                                        "local-mode", ADG_TRANSFORM_BEFORE_NORMALIZED,
 972                                        "font-dress", dress, NULL);
 973
 974         adg_container_add(data->quote.container, (AdgEntity *) data->quote.max);
 975         adg_toy_text_set_label(data->quote.max, data->max);
 976     }
 977
 978     container_entity = (AdgEntity *) data->quote.container;
 979     value_entity = (AdgEntity *) data->quote.value;
 980     min_entity = (AdgEntity *) data->quote.min;
 981     max_entity = (AdgEntity *) data->quote.max;
 982
 983     /* Propagate the arrange signal to the quote container */
 984     adg_entity_arrange(container_entity);
 985
 986     /* Basic value */
 987     extents = adg_entity_extents(value_entity);
 988     width = extents->size.x;
 989
 990     /* Limit values (min and max) */
 991     if (min_entity != NULL || max_entity != NULL) {
 992         CpmlExtents min_extents = { 0 };
 993         CpmlExtents max_extents = { 0 };
 994         gdouble spacing = 0;
 995
 996         /* Minimum limit */
 997         if (min_entity != NULL)
 998             cpml_extents_copy(&min_extents, adg_entity_extents(min_entity));
 999
1000         /* Maximum limit */
1001         if (max_entity != NULL)
1002             cpml_extents_copy(&max_extents, adg_entity_extents(max_entity));
1003
1004         shift = adg_dim_style_get_limits_shift(data->dim_style);
1005         if (min_entity != NULL && max_entity != NULL)
1006             spacing = adg_dim_style_get_limits_spacing(data->dim_style);
1007
1008         cairo_matrix_init_translate(&map, width + shift->x,
1009                                     (spacing + min_extents.size.y +
1010                                      max_extents.size.y) / 2 +
1011                                     shift->y - extents->size.y / 2);
1012
1013         if (min_entity != NULL)
1014             adg_entity_set_global_map(min_entity, &map);
1015
1016         if (max_entity != NULL) {
1017             cairo_matrix_translate(&map, 0, -min_extents.size.y - spacing);
1018             adg_entity_set_global_map(max_entity, &map);
1019         }
1020
1021         width += shift->x + MAX(min_extents.size.x, max_extents.size.x);
1022     }
1023
1024     /* Center and apply the style displacements */
1025     shift = adg_dim_style_get_quote_shift(data->dim_style);
1026     cairo_matrix_init_translate(&map, shift->x - width / 2, shift->y);
1027     adg_entity_set_global_map(container_entity, &map);
1028
1029     adg_entity_arrange(container_entity);
1030 }
1031
1032 static void
1033 global_changed(AdgEntity *entity)
1034 {
1035     AdgDimPrivate *data = ((AdgDim *) entity)->data;
1036
1037     PARENT_ENTITY_CLASS->global_changed(entity);
1038
1039     if (data->quote.container != NULL)
1040         adg_entity_global_changed((AdgEntity *) data->quote.container);
1041 }
1042
1043 static void
1044 local_changed(AdgEntity *entity)
1045 {
1046     AdgDimPrivate *data = ((AdgDim *) entity)->data;
1047
1048     PARENT_ENTITY_CLASS->local_changed(entity);
1049
1050     if (data->quote.container != NULL)
1051         adg_entity_local_changed((AdgEntity *) data->quote.container);
1052 }
1053
1054 static void
1055 invalidate(AdgEntity *entity)
1056 {
1057     AdgDimPrivate *data = ((AdgDim *) entity)->data;
1058
1059     if (data->quote.container != NULL)
1060         adg_entity_invalidate((AdgEntity *) data->quote.container);
1061
1062     adg_point_invalidate(data->ref1);
1063     adg_point_invalidate(data->ref2);
1064     adg_point_invalidate(data->pos);
1065 }
1066
1067 static gchar *
1068 default_value(AdgDim *dim)
1069 {
1070     g_warning("AdgDim::default_value not implemented for `%s'",
1071               g_type_name(G_TYPE_FROM_INSTANCE(dim)));
1072     return g_strdup("undef");
1073 }
1074
1075 static gdouble
1076 quote_angle(gdouble angle)
1077 {
1078     angle = cpml_angle(angle);
1079
1080     if (angle > G_PI_4 * 4 / 3 || angle <= -G_PI_4 * 3)
1081         angle = cpml_angle(angle + G_PI);
1082
1083     return angle;
1084 }
1085
1086 static gboolean
1087 set_dim_dress(AdgDim *dim, AdgDress dress)
1088 {
1089     AdgDimPrivate *data = dim->data;
1090
1091     if (adg_dress_set(&data->dim_dress, dress)) {
1092         data->dim_style = NULL;
1093         return TRUE;
1094     }
1095
1096     return FALSE;
1097 }
1098
1099 static gboolean
1100 set_value(AdgDim *dim, const gchar *value)
1101 {
1102     AdgDimPrivate *data;
1103
1104     data = dim->data;
1105
1106     if (adg_strcmp(value, data->value) == 0)
1107         return FALSE;
1108
1109     g_free(data->value);
1110     data->value = g_strdup(value);
1111
1112     if (data->quote.value != NULL) {
1113         g_object_unref(data->quote.value);
1114         data->quote.value = NULL;
1115     }
1116
1117     return TRUE;
1118 }
1119
1120 static gboolean
1121 set_min(AdgDim *dim, const gchar *min)
1122 {
1123     AdgDimPrivate *data = dim->data;
1124
1125     if (adg_strcmp(min, data->min) == 0)
1126         return FALSE;
1127
1128     g_free(data->min);
1129     data->min = g_strdup(min);
1130
1131     if (data->quote.min != NULL) {
1132         g_object_unref(data->quote.min);
1133         data->quote.min = NULL;
1134     }
1135
1136     return TRUE;
1137 }
1138
1139 static gboolean
1140 set_max(AdgDim *dim, const gchar *max)
1141 {
1142     AdgDimPrivate *data = dim->data;
1143
1144     if (adg_strcmp(max, data->max) == 0)
1145         return FALSE;
1146
1147     g_free(data->max);
1148     data->max = g_strdup(max);
1149
1150     if (data->quote.max != NULL) {
1151         g_object_unref(data->quote.max);
1152         data->quote.max = NULL;
1153     }
1154
1155     return TRUE;
1156 }