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