src/adg/adg-dim-style.c

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