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