adg/adg-dim-style.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-style
  23  * @short_description: Dimension style related stuff
  24  *
  25  * Contains parameters on how to build dimensions such as the different font
  26  * styles (for value and limits), line style, offsets of the various
  27  * dimension components etc...
  28  */
  29
  30 /**
  31  * AdgDimStyle:
  32  *
  33  * All fields are private and should not be used directly.
  34  * Use its public methods instead.
  35  **/
  36
  37
  38 #include "adg-dim-style.h"
  39 #include "adg-dim-style-private.h"
  40 #include "adg-dress-builtins.h"
  41 #include "adg-font-style.h"
  42 #include "adg-line-style.h"
  43 #include "adg-intl.h"
  44 #include "adg-util.h"
  45
  46
  47 enum {
  48     PROP_0,
  49     PROP_MARKER1,
  50     PROP_MARKER2,
  51     PROP_COLOR_DRESS,
  52     PROP_VALUE_DRESS,
  53     PROP_MIN_DRESS,
  54     PROP_MAX_DRESS,
  55     PROP_LINE_DRESS,
  56     PROP_FROM_OFFSET,
  57     PROP_TO_OFFSET,
  58     PROP_BEYOND,
  59     PROP_BASELINE_SPACING,
  60     PROP_LIMITS_SPACING,
  61     PROP_QUOTE_SHIFT,
  62     PROP_LIMITS_SHIFT,
  63     PROP_NUMBER_FORMAT,
  64     PROP_NUMBER_TAG
  65 };
  66
  67
  68 static void             finalize                (GObject        *object);
  69 static void             get_property            (GObject        *object,
  70                                                  guint           prop_id,
  71                                                  GValue         *value,
  72                                                  GParamSpec     *pspec);
  73 static void             set_property            (GObject        *object,
  74                                                  guint           prop_id,
  75                                                  const GValue   *value,
  76                                                  GParamSpec     *pspec);
  77 static void             apply                   (AdgStyle       *style,
  78                                                  AdgEntity      *entity,
  79                                                  cairo_t        *cr);
  80 static void             set_limits_shift        (AdgDimStyle    *dim_style,
  81                                                  const AdgPair  *shift);
  82 static void             set_number_format       (AdgDimStyle    *dim_style,
  83                                                  const gchar    *format);
  84 static void             set_number_tag          (AdgDimStyle    *dim_style,
  85                                                  const gchar    *tag);
  86 static AdgMarker *      marker_new              (const AdgMarkerData
  87                                                                 *marker_data);
  88 static void             use_marker              (AdgMarkerData  *marker_data,
  89                                                  AdgMarker      *marker);
  90 static void             free_marker             (AdgMarkerData  *marker_data);
  91
  92
  93 G_DEFINE_TYPE(AdgDimStyle, adg_dim_style, ADG_TYPE_STYLE);
  94
  95
  96 static void
  97 adg_dim_style_class_init(AdgDimStyleClass *klass)
  98 {
  99     GObjectClass *gobject_class;
 100     AdgStyleClass *style_class;
 101     GParamSpec *param;
 102
 103     gobject_class = (GObjectClass *) klass;
 104     style_class = (AdgStyleClass *) klass;
 105
 106     g_type_class_add_private(klass, sizeof(AdgDimStylePrivate));
 107
 108     gobject_class->finalize = finalize;
 109     gobject_class->get_property = get_property;
 110     gobject_class->set_property = set_property;
 111
 112     style_class->apply = apply;
 113
 114     param = g_param_spec_object("marker1",
 115                                 P_("First Marker"),
 116                                 P_("The template entity to use as first marker"),
 117                                 ADG_TYPE_MARKER,
 118                                 G_PARAM_WRITABLE);
 119     g_object_class_install_property(gobject_class, PROP_MARKER1, param);
 120
 121     param = g_param_spec_object("marker2",
 122                                 P_("Second Marker"),
 123                                 P_("The template entity to use as second marker"),
 124                                 ADG_TYPE_MARKER,
 125                                 G_PARAM_WRITABLE);
 126     g_object_class_install_property(gobject_class, PROP_MARKER2, param);
 127
 128     param = adg_param_spec_dress("color-dress",
 129                                   P_("Color Dress"),
 130                                   P_("Color dress for the whole dimension"),
 131                                   ADG_DRESS_COLOR_DIMENSION,
 132                                   G_PARAM_READWRITE);
 133     g_object_class_install_property(gobject_class, PROP_COLOR_DRESS, param);
 134
 135     param = adg_param_spec_dress("value-dress",
 136                                   P_("Value Dress"),
 137                                   P_("Font dress for the nominal value of the dimension"),
 138                                   ADG_DRESS_TEXT_VALUE,
 139                                   G_PARAM_READWRITE);
 140     g_object_class_install_property(gobject_class, PROP_VALUE_DRESS, param);
 141
 142     param = adg_param_spec_dress("min-dress",
 143                                   P_("Minimum Limit Dress"),
 144                                   P_("Font dress for the lower limit value"),
 145                                   ADG_DRESS_TEXT_LIMIT,
 146                                   G_PARAM_READWRITE);
 147     g_object_class_install_property(gobject_class, PROP_MIN_DRESS, param);
 148
 149     param = adg_param_spec_dress("max-dress",
 150                                   P_("Maximum Limit Dress"),
 151                                   P_("Font dress for the upper limit value"),
 152                                   ADG_DRESS_TEXT_LIMIT,
 153                                   G_PARAM_READWRITE);
 154     g_object_class_install_property(gobject_class, PROP_MAX_DRESS, param);
 155
 156     param = adg_param_spec_dress("line-dress",
 157                                   P_("Line Dress"),
 158                                   P_("Line dress for the baseline and the extension lines"),
 159                                   ADG_DRESS_LINE_THINNER,
 160                                   G_PARAM_READWRITE);
 161     g_object_class_install_property(gobject_class, PROP_LINE_DRESS, param);
 162
 163     param = g_param_spec_double("from-offset",
 164                                 P_("From Offset"),
 165                                 P_("Offset (in global space) of the extension lines from the path to the quote"),
 166                                 0, G_MAXDOUBLE, 5,
 167                                 G_PARAM_READWRITE);
 168     g_object_class_install_property(gobject_class, PROP_FROM_OFFSET, param);
 169
 170     param = g_param_spec_double("to-offset",
 171                                 P_("To Offset"),
 172                                 P_("How many extend (in global space) the extension lines after hitting the baseline"),
 173                                 0, G_MAXDOUBLE, 5,
 174                                 G_PARAM_READWRITE);
 175     g_object_class_install_property(gobject_class, PROP_TO_OFFSET, param);
 176
 177     param = g_param_spec_double("beyond",
 178                                 P_("Beyond Length"),
 179                                 P_("How much the baseline should be extended (in global space) beyond the extension lines on dimensions with outside markers"),
 180                                 0, G_MAXDOUBLE, 20,
 181                                 G_PARAM_READWRITE);
 182     g_object_class_install_property(gobject_class, PROP_BEYOND, param);
 183
 184     param = g_param_spec_double("baseline-spacing",
 185                                 P_("Baseline Spacing"),
 186                                 P_("Distance between two consecutive baselines while stacking dimensions"),
 187                                 0, G_MAXDOUBLE, 30,
 188                                 G_PARAM_READWRITE);
 189     g_object_class_install_property(gobject_class, PROP_BASELINE_SPACING, param);
 190
 191     param = g_param_spec_double("limits-spacing",
 192                                 P_("Limits Spacing"),
 193                                 P_("Distance between limits/tolerances"),
 194                                 0, G_MAXDOUBLE, 2,
 195                                 G_PARAM_READWRITE);
 196     g_object_class_install_property(gobject_class, PROP_LIMITS_SPACING, param);
 197
 198     param = g_param_spec_boxed("quote-shift",
 199                                P_("Quote Shift"),
 200                                P_("Used to specify a smooth displacement (in global space) of the quote by taking as reference the perfect compact position (the middle of the baseline on common linear dimension, for instance)"),
 201                                ADG_TYPE_PAIR, G_PARAM_READWRITE);
 202     g_object_class_install_property(gobject_class, PROP_QUOTE_SHIFT, param);
 203
 204     param = g_param_spec_boxed("limits-shift",
 205                                P_("Limits Shift"),
 206                                P_("Used to specify a smooth displacement (in global space) for the limits/tolerances by taking as reference the perfect compact position"),
 207                                ADG_TYPE_PAIR, G_PARAM_READWRITE);
 208     g_object_class_install_property(gobject_class, PROP_LIMITS_SHIFT,
 209                                     param);
 210
 211     param = g_param_spec_string("number-format",
 212                                 P_("Number Format"),
 213                                 P_("The format (in printf style) of the numeric component of the basic value"),
 214                                 "%-.7g", G_PARAM_READWRITE);
 215     g_object_class_install_property(gobject_class, PROP_NUMBER_FORMAT,
 216                                     param);
 217
 218     param = g_param_spec_string("number-tag",
 219                                 P_("Number Tag"),
 220                                 P_("The tag to substitute inside the basic value pattern"),
 221                                 "<>", G_PARAM_READWRITE);
 222     g_object_class_install_property(gobject_class, PROP_NUMBER_TAG, param);
 223 }
 224
 225 static void
 226 adg_dim_style_init(AdgDimStyle *dim_style)
 227 {
 228     AdgDimStylePrivate *data = G_TYPE_INSTANCE_GET_PRIVATE(dim_style,
 229                                                            ADG_TYPE_DIM_STYLE,
 230                                                            AdgDimStylePrivate);
 231
 232     data->marker1.type = 0;
 233     data->marker1.n_parameters = 0;
 234     data->marker1.parameters = NULL;
 235     data->marker2.type = 0;
 236     data->marker2.n_parameters = 0;
 237     data->marker2.parameters = NULL;
 238     data->color_dress = ADG_DRESS_COLOR_DIMENSION;
 239     data->value_dress = ADG_DRESS_TEXT_VALUE;
 240     data->min_dress = ADG_DRESS_TEXT_LIMIT;
 241     data->max_dress = ADG_DRESS_TEXT_LIMIT;
 242     data->line_dress = ADG_DRESS_LINE_THINNER;
 243     data->marker_dress = ADG_DRESS_UNDEFINED;
 244     data->from_offset = 6;
 245     data->to_offset = 6;
 246     data->beyond = 20;
 247     data->baseline_spacing = 30;
 248     data->limits_spacing = 1;
 249     data->quote_shift.x = 0;
 250     data->quote_shift.y = -4;
 251     data->limits_shift.x = +2;
 252     data->limits_shift.y = -2;
 253     data->number_format = g_strdup("%-.7g");
 254     data->number_tag = g_strdup("<>");
 255
 256     dim_style->data = data;
 257 }
 258
 259 static void
 260 finalize(GObject *object)
 261 {
 262     AdgDimStylePrivate *data = ((AdgDimStyle *) object)->data;
 263
 264     free_marker(&data->marker1);
 265     free_marker(&data->marker2);
 266
 267     g_free(data->number_format);
 268     data->number_format = NULL;
 269
 270     g_free(data->number_tag);
 271     data->number_tag = NULL;
 272 }
 273
 274 static void
 275 get_property(GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
 276 {
 277     AdgDimStylePrivate *data = ((AdgDimStyle *) object)->data;
 278
 279     switch (prop_id) {
 280     case PROP_COLOR_DRESS:
 281         g_value_set_int(value, data->color_dress);
 282         break;
 283     case PROP_VALUE_DRESS:
 284         g_value_set_int(value, data->value_dress);
 285         break;
 286     case PROP_MIN_DRESS:
 287         g_value_set_int(value, data->min_dress);
 288         break;
 289     case PROP_MAX_DRESS:
 290         g_value_set_int(value, data->max_dress);
 291         break;
 292     case PROP_LINE_DRESS:
 293         g_value_set_int(value, data->line_dress);
 294         break;
 295     case PROP_FROM_OFFSET:
 296         g_value_set_double(value, data->from_offset);
 297         break;
 298     case PROP_TO_OFFSET:
 299         g_value_set_double(value, data->to_offset);
 300         break;
 301     case PROP_BEYOND:
 302         g_value_set_double(value, data->beyond);
 303         break;
 304     case PROP_BASELINE_SPACING:
 305         g_value_set_double(value, data->baseline_spacing);
 306         break;
 307     case PROP_LIMITS_SPACING:
 308         g_value_set_double(value, data->limits_spacing);
 309         break;
 310     case PROP_QUOTE_SHIFT:
 311         g_value_set_boxed(value, &data->quote_shift);
 312         break;
 313     case PROP_LIMITS_SHIFT:
 314         g_value_set_boxed(value, &data->limits_shift);
 315         break;
 316     case PROP_NUMBER_FORMAT:
 317         g_value_set_string(value, data->number_format);
 318         break;
 319     case PROP_NUMBER_TAG:
 320         g_value_set_string(value, data->number_tag);
 321         break;
 322     default:
 323         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
 324         break;
 325     }
 326 }
 327
 328 static void
 329 set_property(GObject *object,
 330              guint prop_id, const GValue *value, GParamSpec *pspec)
 331 {
 332     AdgDimStyle *dim_style;
 333     AdgDimStylePrivate *data;
 334
 335     dim_style = (AdgDimStyle *) object;
 336     data = dim_style->data;
 337
 338     switch (prop_id) {
 339     case PROP_MARKER1:
 340         use_marker(&data->marker1, g_value_get_object(value));
 341         break;
 342     case PROP_MARKER2:
 343         use_marker(&data->marker2, g_value_get_object(value));
 344         break;
 345     case PROP_COLOR_DRESS:
 346         adg_dress_set(&data->color_dress, g_value_get_int(value));
 347         break;
 348     case PROP_VALUE_DRESS:
 349         adg_dress_set(&data->value_dress, g_value_get_int(value));
 350         break;
 351     case PROP_MIN_DRESS:
 352         adg_dress_set(&data->min_dress, g_value_get_int(value));
 353         break;
 354     case PROP_MAX_DRESS:
 355         adg_dress_set(&data->max_dress, g_value_get_int(value));
 356         break;
 357     case PROP_LINE_DRESS:
 358         adg_dress_set(&data->line_dress, g_value_get_int(value));
 359         break;
 360     case PROP_FROM_OFFSET:
 361         data->from_offset = g_value_get_double(value);
 362         break;
 363     case PROP_TO_OFFSET:
 364         data->to_offset = g_value_get_double(value);
 365         break;
 366     case PROP_BEYOND:
 367         data->beyond = g_value_get_double(value);
 368         break;
 369     case PROP_BASELINE_SPACING:
 370         data->baseline_spacing = g_value_get_double(value);
 371         break;
 372     case PROP_LIMITS_SPACING:
 373         data->limits_spacing = g_value_get_double(value);
 374         break;
 375     case PROP_QUOTE_SHIFT:
 376         cpml_pair_copy(&data->quote_shift, g_value_get_boxed(value));
 377         break;
 378     case PROP_LIMITS_SHIFT:
 379         set_limits_shift(dim_style, g_value_get_boxed(value));
 380         break;
 381     case PROP_NUMBER_FORMAT:
 382         set_number_format(dim_style, g_value_get_string(value));
 383         break;
 384     case PROP_NUMBER_TAG:
 385         set_number_tag(dim_style, g_value_get_string(value));
 386         break;
 387     default:
 388         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
 389         break;
 390     }
 391 }
 392
 393
 394 /**
 395  * adg_dim_style_new:
 396  *
 397  * Constructs a new dimension style initialized with default params.
 398  *
 399  * Returns: a new dimension style
 400  **/
 401 AdgStyle *
 402 adg_dim_style_new(void)
 403 {
 404     return g_object_new(ADG_TYPE_DIM_STYLE, NULL);
 405 }
 406
 407 /**
 408  * adg_dim_style_marker1_new:
 409  * @dim_style: an #AdgDimStyle
 410  *
 411  * Creates a new #AdgMarker entity accordling to the template marker
 412  * stored with the #AdgDimStyle:marker1 property of @dim_style.
 413  *
 414  * Returns: a newly created #AdgMarker derived entity or %NULL if
 415  *          @dim_style has the #AdgDimStyle:marker1 property unset
 416  **/
 417 AdgMarker *
 418 adg_dim_style_marker1_new(AdgDimStyle *dim_style)
 419 {
 420     AdgDimStylePrivate *data;
 421
 422     g_return_val_if_fail(ADG_IS_DIM_STYLE(dim_style), NULL);
 423
 424     data = dim_style->data;
 425
 426     return marker_new(&data->marker1);
 427 }
 428
 429 /**
 430  * adg_dim_style_marker2_new:
 431  * @dim_style: an #AdgDimStyle
 432  *
 433  * Creates a new #AdgMarker entity accordling to the template marker
 434  * stored with the #AdgDimStyle:marker2 property of @dim_style.
 435  *
 436  * Returns: a newly created #AdgMarker derived entity or %NULL if
 437  *          @dim_style has the #AdgDimStyle:marker2 property unset
 438  **/
 439 AdgMarker *
 440 adg_dim_style_marker2_new(AdgDimStyle *dim_style)
 441 {
 442     AdgDimStylePrivate *data;
 443
 444     g_return_val_if_fail(ADG_IS_DIM_STYLE(dim_style), NULL);
 445
 446     data = dim_style->data;
 447
 448     return marker_new(&data->marker2);
 449 }
 450
 451 /**
 452  * adg_dim_style_use_marker1:
 453  * @dim_style: an #AdgStyle
 454  * @marker: an #AdgMarker derived entity
 455  *
 456  * Uses @marker as entity template to generate a new marker entity
 457  * when a call to adg_dim_style_marker1_new() is made.
 458  *
 459  * This method duplicates internally the property values of @marker,
 460  * so any further change to @marker does not affect @dim_style anymore.
 461  * This also means @marker could be destroyed because @dim_style only
 462  * uses its property values and does not add any references to @marker.
 463  **/
 464 void
 465 adg_dim_style_use_marker1(AdgDimStyle *dim_style, AdgMarker *marker)
 466 {
 467     AdgDimStylePrivate *data;
 468
 469     g_return_if_fail(ADG_IS_DIM_STYLE(dim_style));
 470     g_return_if_fail(marker == NULL || ADG_IS_MARKER(marker));
 471
 472     data = dim_style->data;
 473
 474     use_marker(&data->marker1, marker);
 475     g_object_notify((GObject *) dim_style, "marker1");
 476 }
 477
 478 /**
 479  * adg_dim_style_use_marker2:
 480  * @dim_style: an #AdgStyle
 481  * @marker: an #AdgMarker derived entity
 482  *
 483  * Uses @marker as entity template to generate a new marker entity
 484  * when a call to adg_dim_style_marker2_new() is made.
 485  *
 486  * This method duplicates internally the property values of @marker,
 487  * so any further change to @marker does not affect @dim_style anymore.
 488  * This also means @marker could be destroyed because @dim_style only
 489  * uses its property values and does not add any references to @marker.
 490  **/
 491 void
 492 adg_dim_style_use_marker2(AdgDimStyle *dim_style, AdgMarker *marker)
 493 {
 494     AdgDimStylePrivate *data;
 495
 496     g_return_if_fail(ADG_IS_DIM_STYLE(dim_style));
 497     g_return_if_fail(marker == NULL || ADG_IS_MARKER(marker));
 498
 499     data = dim_style->data;
 500
 501     use_marker(&data->marker2, marker);
 502     g_object_notify((GObject *) dim_style, "marker2");
 503 }
 504
 505 /**
 506  * adg_dim_style_set_color_dress:
 507  * @dim_style: an #AdgDimStyle object
 508  * @dress: the new color dress
 509  *
 510  * Sets a new color dress on @dim_style.
 511  **/
 512 void
 513 adg_dim_style_set_color_dress(AdgDimStyle *dim_style, AdgDress dress)
 514 {
 515     AdgDimStylePrivate *data;
 516
 517     g_return_if_fail(ADG_IS_DIM_STYLE(dim_style));
 518
 519     data = dim_style->data;
 520
 521     if (adg_dress_set(&data->color_dress, dress))
 522         g_object_notify((GObject *) dim_style, "color-dress");
 523 }
 524
 525 /**
 526  * adg_dim_style_get_color_dress:
 527  * @dim_style: an #AdgDimStyle object
 528  *
 529  * Gets the @dim_style color dress to be used. This dress should be
 530  * intended as a fallback color as it could be overriden by more
 531  * specific dresses, such as a color explicitely specified on the
 532  * #AdgDimStyle:value-dress.
 533  *
 534  * Returns: the color dress
 535  **/
 536 AdgDress
 537 adg_dim_style_get_color_dress(AdgDimStyle *dim_style)
 538 {
 539     AdgDimStylePrivate *data;
 540
 541     g_return_val_if_fail(ADG_IS_DIM_STYLE(dim_style), ADG_DRESS_UNDEFINED);
 542
 543     data = dim_style->data;
 544
 545     return data->color_dress;
 546 }
 547
 548 /**
 549  * adg_dim_style_set_value_dress:
 550  * @dim_style: an #AdgDimStyle object
 551  * @dress: the new basic value font style
 552  *
 553  * Sets a new dress on @dim_style for the basic value.
 554  **/
 555 void
 556 adg_dim_style_set_value_dress(AdgDimStyle *dim_style, AdgDress dress)
 557 {
 558     AdgDimStylePrivate *data;
 559
 560     g_return_if_fail(ADG_IS_DIM_STYLE(dim_style));
 561
 562     data = dim_style->data;
 563
 564     if (adg_dress_set(&data->value_dress, dress))
 565         g_object_notify((GObject *) dim_style, "value-dress");
 566 }
 567
 568 /**
 569  * adg_dim_style_get_value_dress:
 570  * @dim_style: an #AdgDimStyle object
 571  *
 572  * Gets the font dress to be used for the basic value of dimensions
 573  * with @dim_style.
 574  *
 575  * Returns: the font dress
 576  **/
 577 AdgDress
 578 adg_dim_style_get_value_dress(AdgDimStyle *dim_style)
 579 {
 580     AdgDimStylePrivate *data;
 581
 582     g_return_val_if_fail(ADG_IS_DIM_STYLE(dim_style), ADG_DRESS_UNDEFINED);
 583
 584     data = dim_style->data;
 585
 586     return data->value_dress;
 587 }
 588
 589 /**
 590  * adg_dim_style_set_min_dress:
 591  * @dim_style: an #AdgDimStyle object
 592  * @dress: the new lower limit dress
 593  *
 594  * Sets a new dress on @dim_style for the lower limit value.
 595  **/
 596 void
 597 adg_dim_style_set_min_dress(AdgDimStyle *dim_style, AdgDress dress)
 598 {
 599     AdgDimStylePrivate *data;
 600
 601     g_return_if_fail(ADG_IS_DIM_STYLE(dim_style));
 602
 603     data = dim_style->data;
 604
 605     if (adg_dress_set(&data->min_dress, dress))
 606         g_object_notify((GObject *) dim_style, "min-dress");
 607 }
 608
 609 /**
 610  * adg_dim_style_get_min_dress:
 611  * @dim_style: an #AdgDimStyle object
 612  *
 613  * Gets the @dim_style dress to be used for the lower limit.
 614  *
 615  * Returns: the lower limit dress
 616  **/
 617 AdgDress
 618 adg_dim_style_get_min_dress(AdgDimStyle *dim_style)
 619 {
 620     AdgDimStylePrivate *data;
 621
 622     g_return_val_if_fail(ADG_IS_DIM_STYLE(dim_style), ADG_DRESS_UNDEFINED);
 623
 624     data = dim_style->data;
 625
 626     return data->min_dress;
 627 }
 628
 629 /**
 630  * adg_dim_style_set_max_dress:
 631  * @dim_style: an #AdgDimStyle object
 632  * @dress: the new upper limit dress
 633  *
 634  * Sets a new dress on @dim_style for the upper limit value.
 635  **/
 636 void
 637 adg_dim_style_set_max_dress(AdgDimStyle *dim_style, AdgDress dress)
 638 {
 639     AdgDimStylePrivate *data;
 640
 641     g_return_if_fail(ADG_IS_DIM_STYLE(dim_style));
 642
 643     data = dim_style->data;
 644
 645     if (adg_dress_set(&data->max_dress, dress))
 646         g_object_notify((GObject *) dim_style, "max-dress");
 647 }
 648
 649 /**
 650  * adg_dim_style_get_max_dress:
 651  * @dim_style: an #AdgDimStyle object
 652  *
 653  * Gets the @dim_style dress to be used for the upper limit.
 654  *
 655  * Returns: the upper limit dress
 656  **/
 657 AdgDress
 658 adg_dim_style_get_max_dress(AdgDimStyle *dim_style)
 659 {
 660     AdgDimStylePrivate *data;
 661
 662     g_return_val_if_fail(ADG_IS_DIM_STYLE(dim_style), ADG_DRESS_UNDEFINED);
 663
 664     data = dim_style->data;
 665
 666     return data->max_dress;
 667 }
 668
 669 /**
 670  * adg_dim_style_set_line_dress:
 671  * @dim_style: an #AdgDimStyle object
 672  * @dress: the new line dress
 673  *
 674  * Sets a new line dress on @dim_style.
 675  **/
 676 void
 677 adg_dim_style_set_line_dress(AdgDimStyle *dim_style, AdgDress dress)
 678 {
 679     AdgDimStylePrivate *data;
 680
 681     g_return_if_fail(ADG_IS_DIM_STYLE(dim_style));
 682
 683     data = dim_style->data;
 684
 685     if (adg_dress_set(&data->line_dress, dress))
 686         g_object_notify((GObject *) dim_style, "line-dress");
 687 }
 688
 689 /**
 690  * adg_dim_style_get_line_dress:
 691  * @dim_style: an #AdgDimStyle object
 692  *
 693  * Gets the line dress to be used for rendering the base and
 694  * the extension lines with @dim_style.
 695  *
 696  * Returns: the line dress
 697  **/
 698 AdgDress
 699 adg_dim_style_get_line_dress(AdgDimStyle *dim_style)
 700 {
 701     AdgDimStylePrivate *data;
 702
 703     g_return_val_if_fail(ADG_IS_DIM_STYLE(dim_style), ADG_DRESS_UNDEFINED);
 704
 705     data = dim_style->data;
 706
 707     return data->line_dress;
 708 }
 709
 710 /**
 711  * adg_dim_style_set_from_offset:
 712  * @dim_style: an #AdgDimStyle object
 713  * @offset: the new offset
 714  *
 715  * Sets a new "from-offset" value.
 716  **/
 717 void
 718 adg_dim_style_set_from_offset(AdgDimStyle *dim_style, gdouble offset)
 719 {
 720     AdgDimStylePrivate *data;
 721
 722     g_return_if_fail(ADG_IS_DIM_STYLE(dim_style));
 723
 724     data = dim_style->data;
 725     data->from_offset = offset;
 726
 727     g_object_notify((GObject *) dim_style, "from-offset");
 728 }
 729
 730 /**
 731  * adg_dim_style_get_from_offset:
 732  * @dim_style: an #AdgDimStyle object
 733  *
 734  * Gets the distance (in global space) the extension lines must keep from the
 735  * sensed points.
 736  *
 737  * Returns: the requested distance
 738  **/
 739 gdouble
 740 adg_dim_style_get_from_offset(AdgDimStyle *dim_style)
 741 {
 742     AdgDimStylePrivate *data;
 743
 744     g_return_val_if_fail(ADG_IS_DIM_STYLE(dim_style), 0);
 745
 746     data = dim_style->data;
 747
 748     return data->from_offset;
 749 }
 750
 751 /**
 752  * adg_dim_style_set_to_offset:
 753  * @dim_style: an #AdgDimStyle object
 754  * @offset: the new offset
 755  *
 756  * Sets a new "to-offset" value.
 757  **/
 758 void
 759 adg_dim_style_set_to_offset(AdgDimStyle *dim_style, gdouble offset)
 760 {
 761     AdgDimStylePrivate *data;
 762
 763     g_return_if_fail(ADG_IS_DIM_STYLE(dim_style));
 764
 765     data = dim_style->data;
 766     data->to_offset = offset;
 767
 768     g_object_notify((GObject *) dim_style, "to-offset");
 769 }
 770
 771 /**
 772  * adg_dim_style_get_to_offset:
 773  * @dim_style: an #AdgDimStyle object
 774  *
 775  * Gets how much (in global space) the extension lines must extend after
 776  * crossing the baseline.
 777  *
 778  * Returns: the requested distance
 779  **/
 780 gdouble
 781 adg_dim_style_get_to_offset(AdgDimStyle *dim_style)
 782 {
 783     AdgDimStylePrivate *data;
 784
 785     g_return_val_if_fail(ADG_IS_DIM_STYLE(dim_style), 0);
 786
 787     data = dim_style->data;
 788
 789     return data->to_offset;
 790 }
 791
 792 /**
 793  * adg_dim_style_set_beyond:
 794  * @dim_style: an #AdgDimStyle object
 795  * @length: the new length
 796  *
 797  * Sets a new "beyond" value.
 798  **/
 799 void
 800 adg_dim_style_set_beyond(AdgDimStyle *dim_style, gdouble length)
 801 {
 802     AdgDimStylePrivate *data;
 803
 804     g_return_if_fail(ADG_IS_DIM_STYLE(dim_style));
 805
 806     data = dim_style->data;
 807     data->beyond = length;
 808
 809     g_object_notify((GObject *) dim_style, "beyond");
 810 }
 811
 812 /**
 813  * adg_dim_style_get_beyond:
 814  * @dim_style: an #AdgDimStyle object
 815  *
 816  * Gets how much (in global space) the baseline should extend beyond
 817  * the extension lines on dimension with outside markers.
 818  *
 819  * Returns: the requested beyond length
 820  **/
 821 gdouble
 822 adg_dim_style_get_beyond(AdgDimStyle *dim_style)
 823 {
 824     AdgDimStylePrivate *data;
 825
 826     g_return_val_if_fail(ADG_IS_DIM_STYLE(dim_style), 0);
 827
 828     data = dim_style->data;
 829
 830     return data->beyond;
 831 }
 832
 833 /**
 834  * adg_dim_style_set_baseline_spacing:
 835  * @dim_style: an #AdgDimStyle object
 836  * @spacing: the new spacing
 837  *
 838  * Sets a new "baseline-spacing" value.
 839  **/
 840 void
 841 adg_dim_style_set_baseline_spacing(AdgDimStyle *dim_style, gdouble spacing)
 842 {
 843     AdgDimStylePrivate *data;
 844
 845     g_return_if_fail(ADG_IS_DIM_STYLE(dim_style));
 846
 847     data = dim_style->data;
 848     data->baseline_spacing = spacing;
 849
 850     g_object_notify((GObject *) dim_style, "baseline-spacing");
 851 }
 852
 853 /**
 854  * adg_dim_style_get_baseline_spacing:
 855  * @dim_style: an #AdgDimStyle object
 856  *
 857  * Gets the distance between two consecutive baselines
 858  * while stacking dimensions.
 859  *
 860  * Returns: the requested spacing
 861  **/
 862 gdouble
 863 adg_dim_style_get_baseline_spacing(AdgDimStyle *dim_style)
 864 {
 865     AdgDimStylePrivate *data;
 866
 867     g_return_val_if_fail(ADG_IS_DIM_STYLE(dim_style), 0);
 868
 869     data = dim_style->data;
 870
 871     return data->baseline_spacing;
 872 }
 873
 874 /**
 875  * adg_dim_style_set_limits_spacing:
 876  * @dim_style: an #AdgDimStyle object
 877  * @spacing: the new spacing
 878  *
 879  * Sets a new #AdgDimStyle:limits-spacing value.
 880  **/
 881 void
 882 adg_dim_style_set_limits_spacing(AdgDimStyle *dim_style, gdouble spacing)
 883 {
 884     AdgDimStylePrivate *data;
 885
 886     g_return_if_fail(ADG_IS_DIM_STYLE(dim_style));
 887
 888     data = dim_style->data;
 889     data->limits_spacing = spacing;
 890
 891     g_object_notify((GObject *) dim_style, "limits-spacing");
 892 }
 893
 894 /**
 895  * adg_dim_style_get_limits_spacing:
 896  * @dim_style: an #AdgDimStyle object
 897  *
 898  * Gets the distance (in global space) between the limits/tolerances.
 899  *
 900  * Returns: the requested spacing
 901  **/
 902 gdouble
 903 adg_dim_style_get_limits_spacing(AdgDimStyle *dim_style)
 904 {
 905     AdgDimStylePrivate *data;
 906
 907     g_return_val_if_fail(ADG_IS_DIM_STYLE(dim_style), 0);
 908
 909     data = dim_style->data;
 910
 911     return data->limits_spacing;
 912 }
 913
 914 /**
 915  * adg_dim_style_set_quote_shift:
 916  * @dim_style: an #AdgDimStyle object
 917  * @shift: the new displacement
 918  *
 919  * Sets a new #AdgDimStyle:quote-shift value.
 920  **/
 921 void
 922 adg_dim_style_set_quote_shift(AdgDimStyle *dim_style, const AdgPair *shift)
 923 {
 924     AdgDimStylePrivate *data;
 925
 926     g_return_if_fail(ADG_IS_DIM_STYLE(dim_style));
 927     g_return_if_fail(shift != NULL);
 928
 929     data = dim_style->data;
 930     cpml_pair_copy(&data->quote_shift, shift);
 931
 932     g_object_notify((GObject *) dim_style, "quote-shift");
 933 }
 934
 935 /**
 936  * adg_dim_style_get_quote_shift:
 937  * @dim_style: an #AdgDimStyle object
 938  *
 939  * Gets the smooth displacement of the quote. The returned pointer refers
 940  * to an internal allocated struct and must not be modified or freed.
 941  *
 942  * Returns: the requested shift
 943  **/
 944 const AdgPair *
 945 adg_dim_style_get_quote_shift(AdgDimStyle *dim_style)
 946 {
 947     AdgDimStylePrivate *data;
 948
 949     g_return_val_if_fail(ADG_IS_DIM_STYLE(dim_style), NULL);
 950
 951     data = dim_style->data;
 952
 953     return &data->quote_shift;
 954 }
 955
 956 /**
 957  * adg_dim_style_set_limits_shift:
 958  * @dim_style: an #AdgDimStyle object
 959  * @shift: the new displacement
 960  *
 961  * Sets a new #AdgDimStyle:limits-shift value.
 962  **/
 963 void
 964 adg_dim_style_set_limits_shift(AdgDimStyle *dim_style, const AdgPair *shift)
 965 {
 966     g_return_if_fail(ADG_IS_DIM_STYLE(dim_style));
 967
 968     set_limits_shift(dim_style, shift);
 969     g_object_notify((GObject *) dim_style, "limits-shift");
 970 }
 971
 972 /**
 973  * adg_dim_style_get_limits_shift:
 974  * @dim_style: an #AdgDimStyle object
 975  *
 976  * Gets the smooth displacement for the limits. The returned pointer
 977  * refers to an internal allocated struct and must not be modified or freed.
 978  *
 979  * Returns: the requested shift
 980  **/
 981 const AdgPair *
 982 adg_dim_style_get_limits_shift(AdgDimStyle *dim_style)
 983 {
 984     AdgDimStylePrivate *data;
 985
 986     g_return_val_if_fail(ADG_IS_DIM_STYLE(dim_style), NULL);
 987
 988     data = dim_style->data;
 989
 990     return &data->limits_shift;
 991 }
 992
 993 /**
 994  * adg_dim_style_set_number_format:
 995  * @dim_style: an #AdgDimStyle object
 996  * @format: the new format to adopt
 997  *
 998  * Sets a new "number-format" value.
 999  **/
1000 void
1001 adg_dim_style_set_number_format(AdgDimStyle *dim_style, const gchar *format)
1002 {
1003     g_return_if_fail(ADG_IS_DIM_STYLE(dim_style));
1004
1005     set_number_format(dim_style, format);
1006     g_object_notify((GObject *) dim_style, "number-format");
1007 }
1008
1009 /**
1010  * adg_dim_style_get_number_format:
1011  * @dim_style: an #AdgDimStyle object
1012  *
1013  * Gets the number format (in printf style) of this quoting style. The
1014  * returned pointer refers to internally managed text that must not be
1015  * modified or freed.
1016  *
1017  * Returns: the requested format
1018  **/
1019 const gchar *
1020 adg_dim_style_get_number_format(AdgDimStyle *dim_style)
1021 {
1022     AdgDimStylePrivate *data;
1023
1024     g_return_val_if_fail(ADG_IS_DIM_STYLE(dim_style), NULL);
1025
1026     data = dim_style->data;
1027
1028     return data->number_format;
1029 }
1030
1031 /**
1032  * adg_dim_style_set_number_tag:
1033  * @dim_style: an #AdgDimStyle object
1034  * @tag: the new tag
1035  *
1036  * Sets a new "number-tag" value.
1037  **/
1038 void
1039 adg_dim_style_set_number_tag(AdgDimStyle *dim_style, const gchar *tag)
1040 {
1041     g_return_if_fail(ADG_IS_DIM_STYLE(dim_style));
1042
1043     set_number_tag(dim_style, tag);
1044     g_object_notify((GObject *) dim_style, "number-tag");
1045 }
1046
1047 /**
1048  * adg_dim_style_get_number_tag:
1049  * @dim_style: an #AdgDimStyle object
1050  *
1051  * Gets the number tag to substitute while building the basic value. The
1052  * returned pointer refers to internally managed text that must not be
1053  * modified or freed.
1054  *
1055  * Returns: the requested tag
1056  **/
1057 const gchar *
1058 adg_dim_style_get_number_tag(AdgDimStyle *dim_style)
1059 {
1060     AdgDimStylePrivate *data;
1061
1062     g_return_val_if_fail(ADG_IS_DIM_STYLE(dim_style), NULL);
1063
1064     data = dim_style->data;
1065
1066     return data->number_tag;
1067 }
1068
1069
1070 static void
1071 apply(AdgStyle *style, AdgEntity *entity, cairo_t *cr)
1072 {
1073     AdgDimStylePrivate *data = ((AdgDimStyle *) style)->data;
1074
1075     adg_entity_apply_dress(entity, data->color_dress, cr);
1076 }
1077
1078 static void
1079 set_limits_shift(AdgDimStyle *dim_style, const AdgPair *shift)
1080 {
1081     AdgDimStylePrivate *data = dim_style->data;
1082
1083     cpml_pair_copy(&data->limits_shift, shift);
1084 }
1085
1086 static void
1087 set_number_format(AdgDimStyle *dim_style, const gchar *format)
1088 {
1089     AdgDimStylePrivate *data = dim_style->data;
1090
1091     g_free(data->number_format);
1092     data->number_format = g_strdup(format);
1093 }
1094
1095 static void
1096 set_number_tag(AdgDimStyle *dim_style, const gchar *tag)
1097 {
1098     AdgDimStylePrivate *data = dim_style->data;
1099
1100     g_free(data->number_tag);
1101     data->number_tag = g_strdup(tag);
1102 }
1103
1104 static AdgMarker *
1105 marker_new(const AdgMarkerData *marker_data)
1106 {
1107     if (marker_data->type == 0)
1108         return NULL;
1109
1110     return g_object_newv(marker_data->type,
1111                          marker_data->n_parameters,
1112                          marker_data->parameters);
1113 }
1114
1115 static void
1116 use_marker(AdgMarkerData *marker_data, AdgMarker *marker)
1117 {
1118     GObject *object;
1119     GParamSpec **specs;
1120     GParamSpec *spec;
1121     GParameter *parameter;
1122     guint n;
1123
1124     /* Free the previous marker data, if any */
1125     free_marker(marker_data);
1126
1127     if (marker == NULL)
1128         return;
1129
1130     object = (GObject *) marker;
1131     specs = g_object_class_list_properties(G_OBJECT_GET_CLASS(marker),
1132                                            &marker_data->n_parameters);
1133
1134     marker_data->type = G_TYPE_FROM_INSTANCE(marker);
1135     marker_data->parameters = g_new0(GParameter, marker_data->n_parameters);
1136
1137     for (n = 0; n < marker_data->n_parameters; ++n) {
1138         spec = specs[n];
1139         parameter = &marker_data->parameters[n];
1140
1141         /* Using intern strings because GParameter:name is const.
1142          * GObject properties are internally managed using non-static
1143          * GQuark, so g_intern_string() is the way to go */
1144         parameter->name = g_intern_string(spec->name);
1145
1146         g_value_init(&parameter->value, spec->value_type);
1147         g_object_get_property(object, spec->name, &parameter->value);
1148     }
1149
1150     g_free(specs);
1151 }
1152
1153 static void
1154 free_marker(AdgMarkerData *marker_data)
1155 {
1156     guint n;
1157
1158     for (n = 0; n < marker_data->n_parameters; ++n)
1159         g_value_unset(&marker_data->parameters[n].value);
1160
1161     marker_data->type = 0;
1162     marker_data->n_parameters = 0;
1163     marker_data->parameters = NULL;
1164 }