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_DIMENSION,
 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_DIMENSION;
 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_get_color_dress:
 507  * @dim_style: an #AdgDimStyle object
 508  *
 509  * Gets the @dim_style color dress to be used.
 510  *
 511  * Returns: the color dress
 512  **/
 513 AdgDress
 514 adg_dim_style_get_color_dress(AdgDimStyle *dim_style)
 515 {
 516     AdgDimStylePrivate *data;
 517
 518     g_return_val_if_fail(ADG_IS_DIM_STYLE(dim_style), ADG_DRESS_UNDEFINED);
 519
 520     data = dim_style->data;
 521
 522     return data->color_dress;
 523 }
 524
 525 /**
 526  * adg_dim_style_set_color_dress:
 527  * @dim_style: an #AdgDimStyle object
 528  * @dress: the new color dress
 529  *
 530  * Sets a new color dress on @dim_style.
 531  **/
 532 void
 533 adg_dim_style_set_color_dress(AdgDimStyle *dim_style, AdgDress dress)
 534 {
 535     AdgDimStylePrivate *data;
 536
 537     g_return_if_fail(ADG_IS_DIM_STYLE(dim_style));
 538
 539     data = dim_style->data;
 540
 541     if (adg_dress_set(&data->color_dress, dress))
 542         g_object_notify((GObject *) dim_style, "color-dress");
 543 }
 544
 545 /**
 546  * adg_dim_style_get_value_dress:
 547  * @dim_style: an #AdgDimStyle object
 548  *
 549  * Gets the @dim_style dress to be used for the basic value.
 550  *
 551  * Returns: the basic value dress
 552  **/
 553 AdgDress
 554 adg_dim_style_get_value_dress(AdgDimStyle *dim_style)
 555 {
 556     AdgDimStylePrivate *data;
 557
 558     g_return_val_if_fail(ADG_IS_DIM_STYLE(dim_style), ADG_DRESS_UNDEFINED);
 559
 560     data = dim_style->data;
 561
 562     return data->value_dress;
 563 }
 564
 565 /**
 566  * adg_dim_style_set_value_dress:
 567  * @dim_style: an #AdgDimStyle object
 568  * @dress: the new basic value font style
 569  *
 570  * Sets a new dress on @dim_style for the basic value.
 571  **/
 572 void
 573 adg_dim_style_set_value_dress(AdgDimStyle *dim_style, AdgDress dress)
 574 {
 575     AdgDimStylePrivate *data;
 576
 577     g_return_if_fail(ADG_IS_DIM_STYLE(dim_style));
 578
 579     data = dim_style->data;
 580
 581     if (adg_dress_set(&data->value_dress, dress))
 582         g_object_notify((GObject *) dim_style, "value-dress");
 583 }
 584
 585 /**
 586  * adg_dim_style_get_min_dress:
 587  * @dim_style: an #AdgDimStyle object
 588  *
 589  * Gets the @dim_style dress to be used for the lower limit.
 590  *
 591  * Returns: the lower limit dress
 592  **/
 593 AdgDress
 594 adg_dim_style_get_min_dress(AdgDimStyle *dim_style)
 595 {
 596     AdgDimStylePrivate *data;
 597
 598     g_return_val_if_fail(ADG_IS_DIM_STYLE(dim_style), ADG_DRESS_UNDEFINED);
 599
 600     data = dim_style->data;
 601
 602     return data->min_dress;
 603 }
 604
 605 /**
 606  * adg_dim_style_set_min_dress:
 607  * @dim_style: an #AdgDimStyle object
 608  * @dress: the new lower limit dress
 609  *
 610  * Sets a new dress on @dim_style for the lower limit value.
 611  **/
 612 void
 613 adg_dim_style_set_min_dress(AdgDimStyle *dim_style, AdgDress dress)
 614 {
 615     AdgDimStylePrivate *data;
 616
 617     g_return_if_fail(ADG_IS_DIM_STYLE(dim_style));
 618
 619     data = dim_style->data;
 620
 621     if (adg_dress_set(&data->min_dress, dress))
 622         g_object_notify((GObject *) dim_style, "min-dress");
 623 }
 624
 625 /**
 626  * adg_dim_style_get_max_dress:
 627  * @dim_style: an #AdgDimStyle object
 628  *
 629  * Gets the @dim_style dress to be used for the upper limit.
 630  *
 631  * Returns: the upper limit dress
 632  **/
 633 AdgDress
 634 adg_dim_style_get_max_dress(AdgDimStyle *dim_style)
 635 {
 636     AdgDimStylePrivate *data;
 637
 638     g_return_val_if_fail(ADG_IS_DIM_STYLE(dim_style), ADG_DRESS_UNDEFINED);
 639
 640     data = dim_style->data;
 641
 642     return data->max_dress;
 643 }
 644
 645 /**
 646  * adg_dim_style_set_max_dress:
 647  * @dim_style: an #AdgDimStyle object
 648  * @dress: the new upper limit dress
 649  *
 650  * Sets a new dress on @dim_style for the upper limit value.
 651  **/
 652 void
 653 adg_dim_style_set_max_dress(AdgDimStyle *dim_style, AdgDress dress)
 654 {
 655     AdgDimStylePrivate *data;
 656
 657     g_return_if_fail(ADG_IS_DIM_STYLE(dim_style));
 658
 659     data = dim_style->data;
 660
 661     if (adg_dress_set(&data->max_dress, dress))
 662         g_object_notify((GObject *) dim_style, "max-dress");
 663 }
 664
 665 /**
 666  * adg_dim_style_get_line_dress:
 667  * @dim_style: an #AdgDimStyle object
 668  *
 669  * Gets the @dim_style dress to be used for rendering the baseline and
 670  * the extension lines.
 671  *
 672  * Returns: the line dress
 673  **/
 674 AdgDress
 675 adg_dim_style_get_line_dress(AdgDimStyle *dim_style)
 676 {
 677     AdgDimStylePrivate *data;
 678
 679     g_return_val_if_fail(ADG_IS_DIM_STYLE(dim_style), ADG_DRESS_UNDEFINED);
 680
 681     data = dim_style->data;
 682
 683     return data->line_dress;
 684 }
 685
 686 /**
 687  * adg_dim_style_set_line_dress:
 688  * @dim_style: an #AdgDimStyle object
 689  * @dress: the new line dress
 690  *
 691  * Sets a new line dress on @dim_style.
 692  **/
 693 void
 694 adg_dim_style_set_line_dress(AdgDimStyle *dim_style, AdgDress dress)
 695 {
 696     AdgDimStylePrivate *data;
 697
 698     g_return_if_fail(ADG_IS_DIM_STYLE(dim_style));
 699
 700     data = dim_style->data;
 701
 702     if (adg_dress_set(&data->line_dress, dress))
 703         g_object_notify((GObject *) dim_style, "line-dress");
 704 }
 705
 706 /**
 707  * adg_dim_style_get_from_offset:
 708  * @dim_style: an #AdgDimStyle object
 709  *
 710  * Gets the distance (in global space) the extension lines must keep from the
 711  * sensed points.
 712  *
 713  * Returns: the requested distance
 714  **/
 715 gdouble
 716 adg_dim_style_get_from_offset(AdgDimStyle *dim_style)
 717 {
 718     AdgDimStylePrivate *data;
 719
 720     g_return_val_if_fail(ADG_IS_DIM_STYLE(dim_style), 0);
 721
 722     data = dim_style->data;
 723
 724     return data->from_offset;
 725 }
 726
 727 /**
 728  * adg_dim_style_set_from_offset:
 729  * @dim_style: an #AdgDimStyle object
 730  * @offset: the new offset
 731  *
 732  * Sets a new "from-offset" value.
 733  **/
 734 void
 735 adg_dim_style_set_from_offset(AdgDimStyle *dim_style, gdouble offset)
 736 {
 737     AdgDimStylePrivate *data;
 738
 739     g_return_if_fail(ADG_IS_DIM_STYLE(dim_style));
 740
 741     data = dim_style->data;
 742     data->from_offset = offset;
 743
 744     g_object_notify((GObject *) dim_style, "from-offset");
 745 }
 746
 747 /**
 748  * adg_dim_style_get_to_offset:
 749  * @dim_style: an #AdgDimStyle object
 750  *
 751  * Gets how much (in global space) the extension lines must extend after
 752  * crossing the baseline.
 753  *
 754  * Returns: the requested distance
 755  **/
 756 gdouble
 757 adg_dim_style_get_to_offset(AdgDimStyle *dim_style)
 758 {
 759     AdgDimStylePrivate *data;
 760
 761     g_return_val_if_fail(ADG_IS_DIM_STYLE(dim_style), 0);
 762
 763     data = dim_style->data;
 764
 765     return data->to_offset;
 766 }
 767
 768 /**
 769  * adg_dim_style_set_to_offset:
 770  * @dim_style: an #AdgDimStyle object
 771  * @offset: the new offset
 772  *
 773  * Sets a new "to-offset" value.
 774  **/
 775 void
 776 adg_dim_style_set_to_offset(AdgDimStyle *dim_style, gdouble offset)
 777 {
 778     AdgDimStylePrivate *data;
 779
 780     g_return_if_fail(ADG_IS_DIM_STYLE(dim_style));
 781
 782     data = dim_style->data;
 783     data->to_offset = offset;
 784
 785     g_object_notify((GObject *) dim_style, "to-offset");
 786 }
 787
 788 /**
 789  * adg_dim_style_get_beyond:
 790  * @dim_style: an #AdgDimStyle object
 791  *
 792  * Gets how much (in global space) the baseline should extend beyond
 793  * the extension lines on dimension with outside markers.
 794  *
 795  * Returns: the requested beyond length
 796  **/
 797 gdouble
 798 adg_dim_style_get_beyond(AdgDimStyle *dim_style)
 799 {
 800     AdgDimStylePrivate *data;
 801
 802     g_return_val_if_fail(ADG_IS_DIM_STYLE(dim_style), 0);
 803
 804     data = dim_style->data;
 805
 806     return data->beyond;
 807 }
 808
 809 /**
 810  * adg_dim_style_set_beyond:
 811  * @dim_style: an #AdgDimStyle object
 812  * @length: the new length
 813  *
 814  * Sets a new "beyond" value.
 815  **/
 816 void
 817 adg_dim_style_set_beyond(AdgDimStyle *dim_style, gdouble length)
 818 {
 819     AdgDimStylePrivate *data;
 820
 821     g_return_if_fail(ADG_IS_DIM_STYLE(dim_style));
 822
 823     data = dim_style->data;
 824     data->beyond = length;
 825
 826     g_object_notify((GObject *) dim_style, "beyond");
 827 }
 828
 829 /**
 830  * adg_dim_style_get_baseline_spacing:
 831  * @dim_style: an #AdgDimStyle object
 832  *
 833  * Gets the distance between two consecutive baselines
 834  * while stacking dimensions.
 835  *
 836  * Returns: the requested spacing
 837  **/
 838 gdouble
 839 adg_dim_style_get_baseline_spacing(AdgDimStyle *dim_style)
 840 {
 841     AdgDimStylePrivate *data;
 842
 843     g_return_val_if_fail(ADG_IS_DIM_STYLE(dim_style), 0);
 844
 845     data = dim_style->data;
 846
 847     return data->baseline_spacing;
 848 }
 849
 850 /**
 851  * adg_dim_style_set_baseline_spacing:
 852  * @dim_style: an #AdgDimStyle object
 853  * @spacing: the new spacing
 854  *
 855  * Sets a new "baseline-spacing" value.
 856  **/
 857 void
 858 adg_dim_style_set_baseline_spacing(AdgDimStyle *dim_style, gdouble spacing)
 859 {
 860     AdgDimStylePrivate *data;
 861
 862     g_return_if_fail(ADG_IS_DIM_STYLE(dim_style));
 863
 864     data = dim_style->data;
 865     data->baseline_spacing = spacing;
 866
 867     g_object_notify((GObject *) dim_style, "baseline-spacing");
 868 }
 869
 870 /**
 871  * adg_dim_style_get_limits_spacing:
 872  * @dim_style: an #AdgDimStyle object
 873  *
 874  * Gets the distance (in global space) between the limits/tolerances.
 875  *
 876  * Returns: the requested spacing
 877  **/
 878 gdouble
 879 adg_dim_style_get_limits_spacing(AdgDimStyle *dim_style)
 880 {
 881     AdgDimStylePrivate *data;
 882
 883     g_return_val_if_fail(ADG_IS_DIM_STYLE(dim_style), 0);
 884
 885     data = dim_style->data;
 886
 887     return data->limits_spacing;
 888 }
 889
 890 /**
 891  * adg_dim_style_set_limits_spacing:
 892  * @dim_style: an #AdgDimStyle object
 893  * @spacing: the new spacing
 894  *
 895  * Sets a new #AdgDimStyle:limits-spacing value.
 896  **/
 897 void
 898 adg_dim_style_set_limits_spacing(AdgDimStyle *dim_style, gdouble spacing)
 899 {
 900     AdgDimStylePrivate *data;
 901
 902     g_return_if_fail(ADG_IS_DIM_STYLE(dim_style));
 903
 904     data = dim_style->data;
 905     data->limits_spacing = spacing;
 906
 907     g_object_notify((GObject *) dim_style, "limits-spacing");
 908 }
 909
 910 /**
 911  * adg_dim_style_get_quote_shift:
 912  * @dim_style: an #AdgDimStyle object
 913  *
 914  * Gets the smooth displacement of the quote. The returned pointer refers
 915  * to an internal allocated struct and must not be modified or freed.
 916  *
 917  * Returns: the requested shift
 918  **/
 919 const AdgPair *
 920 adg_dim_style_get_quote_shift(AdgDimStyle *dim_style)
 921 {
 922     AdgDimStylePrivate *data;
 923
 924     g_return_val_if_fail(ADG_IS_DIM_STYLE(dim_style), NULL);
 925
 926     data = dim_style->data;
 927
 928     return &data->quote_shift;
 929 }
 930
 931 /**
 932  * adg_dim_style_set_quote_shift:
 933  * @dim_style: an #AdgDimStyle object
 934  * @shift: the new displacement
 935  *
 936  * Sets a new "quote-shift" value.
 937  **/
 938 void
 939 adg_dim_style_set_quote_shift(AdgDimStyle *dim_style, const AdgPair *shift)
 940 {
 941     AdgDimStylePrivate *data;
 942
 943     g_return_if_fail(ADG_IS_DIM_STYLE(dim_style));
 944
 945     data = dim_style->data;
 946     cpml_pair_copy(&data->quote_shift, shift);
 947
 948     g_object_notify((GObject *) dim_style, "quote-shift");
 949 }
 950
 951 /**
 952  * adg_dim_style_get_limits_shift:
 953  * @dim_style: an #AdgDimStyle object
 954  *
 955  * Gets the smooth displacement for the limits. The returned pointer
 956  * refers to an internal allocated struct and must not be modified or freed.
 957  *
 958  * Returns: the requested shift
 959  **/
 960 const AdgPair *
 961 adg_dim_style_get_limits_shift(AdgDimStyle *dim_style)
 962 {
 963     AdgDimStylePrivate *data;
 964
 965     g_return_val_if_fail(ADG_IS_DIM_STYLE(dim_style), NULL);
 966
 967     data = dim_style->data;
 968
 969     return &data->limits_shift;
 970 }
 971
 972 /**
 973  * adg_dim_style_set_limits_shift:
 974  * @dim_style: an #AdgDimStyle object
 975  * @shift: the new displacement
 976  *
 977  * Sets a new #AdgDimStyle:limits-shift value.
 978  **/
 979 void
 980 adg_dim_style_set_limits_shift(AdgDimStyle *dim_style, const AdgPair *shift)
 981 {
 982     g_return_if_fail(ADG_IS_DIM_STYLE(dim_style));
 983
 984     set_limits_shift(dim_style, shift);
 985     g_object_notify((GObject *) dim_style, "limits-shift");
 986 }
 987
 988 /**
 989  * adg_dim_style_get_number_format:
 990  * @dim_style: an #AdgDimStyle object
 991  *
 992  * Gets the number format (in printf style) of this quoting style. The
 993  * returned pointer refers to internally managed text that must not be
 994  * modified or freed.
 995  *
 996  * Returns: the requested format
 997  **/
 998 const gchar *
 999 adg_dim_style_get_number_format(AdgDimStyle *dim_style)
1000 {
1001     AdgDimStylePrivate *data;
1002
1003     g_return_val_if_fail(ADG_IS_DIM_STYLE(dim_style), NULL);
1004
1005     data = dim_style->data;
1006
1007     return data->number_format;
1008 }
1009
1010 /**
1011  * adg_dim_style_set_number_format:
1012  * @dim_style: an #AdgDimStyle object
1013  * @format: the new format to adopt
1014  *
1015  * Sets a new "number-format" value.
1016  **/
1017 void
1018 adg_dim_style_set_number_format(AdgDimStyle *dim_style, const gchar *format)
1019 {
1020     g_return_if_fail(ADG_IS_DIM_STYLE(dim_style));
1021
1022     set_number_format(dim_style, format);
1023     g_object_notify((GObject *) dim_style, "number-format");
1024 }
1025
1026 /**
1027  * adg_dim_style_get_number_tag:
1028  * @dim_style: an #AdgDimStyle object
1029  *
1030  * Gets the number tag to substitute while building the basic value. The
1031  * returned pointer refers to internally managed text that must not be
1032  * modified or freed.
1033  *
1034  * Returns: the requested tag
1035  **/
1036 const gchar *
1037 adg_dim_style_get_number_tag(AdgDimStyle *dim_style)
1038 {
1039     AdgDimStylePrivate *data;
1040
1041     g_return_val_if_fail(ADG_IS_DIM_STYLE(dim_style), NULL);
1042
1043     data = dim_style->data;
1044
1045     return data->number_tag;
1046 }
1047
1048 /**
1049  * adg_dim_style_set_number_tag:
1050  * @dim_style: an #AdgDimStyle object
1051  * @tag: the new tag
1052  *
1053  * Sets a new "number-tag" value.
1054  **/
1055 void
1056 adg_dim_style_set_number_tag(AdgDimStyle *dim_style, const gchar *tag)
1057 {
1058     g_return_if_fail(ADG_IS_DIM_STYLE(dim_style));
1059
1060     set_number_tag(dim_style, tag);
1061     g_object_notify((GObject *) dim_style, "number-tag");
1062 }
1063
1064
1065 static void
1066 apply(AdgStyle *style, AdgEntity *entity, cairo_t *cr)
1067 {
1068     AdgDimStylePrivate *data = ((AdgDimStyle *) style)->data;
1069
1070     adg_entity_apply_dress(entity, data->color_dress, cr);
1071 }
1072
1073 static void
1074 set_limits_shift(AdgDimStyle *dim_style, const AdgPair *shift)
1075 {
1076     AdgDimStylePrivate *data = dim_style->data;
1077
1078     cpml_pair_copy(&data->limits_shift, shift);
1079 }
1080
1081 static void
1082 set_number_format(AdgDimStyle *dim_style, const gchar *format)
1083 {
1084     AdgDimStylePrivate *data = dim_style->data;
1085
1086     g_free(data->number_format);
1087     data->number_format = g_strdup(format);
1088 }
1089
1090 static void
1091 set_number_tag(AdgDimStyle *dim_style, const gchar *tag)
1092 {
1093     AdgDimStylePrivate *data = dim_style->data;
1094
1095     g_free(data->number_tag);
1096     data->number_tag = g_strdup(tag);
1097 }
1098
1099 static AdgMarker *
1100 marker_new(const AdgMarkerData *marker_data)
1101 {
1102     if (marker_data->type == 0)
1103         return NULL;
1104
1105     return g_object_newv(marker_data->type,
1106                          marker_data->n_parameters,
1107                          marker_data->parameters);
1108 }
1109
1110 static void
1111 use_marker(AdgMarkerData *marker_data, AdgMarker *marker)
1112 {
1113     GObject *object;
1114     GParamSpec **specs;
1115     GParamSpec *spec;
1116     GParameter *parameter;
1117     guint n;
1118
1119     /* Free the previous marker data, if any */
1120     free_marker(marker_data);
1121
1122     if (marker == NULL)
1123         return;
1124
1125     object = (GObject *) marker;
1126     specs = g_object_class_list_properties(G_OBJECT_GET_CLASS(marker),
1127                                            &marker_data->n_parameters);
1128
1129     marker_data->type = G_TYPE_FROM_INSTANCE(marker);
1130     marker_data->parameters = g_new0(GParameter, marker_data->n_parameters);
1131
1132     for (n = 0; n < marker_data->n_parameters; ++n) {
1133         spec = specs[n];
1134         parameter = &marker_data->parameters[n];
1135
1136         /* Using intern strings because GParameter:name is const.
1137          * GObject properties are internally managed using non-static
1138          * GQuark, so g_intern_string() is the way to go */
1139         parameter->name = g_intern_string(spec->name);
1140
1141         g_value_init(&parameter->value, spec->value_type);
1142         g_object_get_property(object, spec->name, &parameter->value);
1143     }
1144
1145     g_free(specs);
1146 }
1147
1148 static void
1149 free_marker(AdgMarkerData *marker_data)
1150 {
1151     guint n;
1152
1153     for (n = 0; n < marker_data->n_parameters; ++n)
1154         g_value_unset(&marker_data->parameters[n].value);
1155
1156     marker_data->type = 0;
1157     marker_data->n_parameters = 0;
1158     marker_data->parameters = NULL;
1159 }