src/adg/adg-line-style.c

   1 /* ADG - Automatic Drawing Generation
   2  * Copyright (C) 2007,2008,2009,2010,2011,2012,2013  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-line-style
  23  * @short_description: Line style related stuff
  24  *
  25  * Contains parameters on how to draw lines such as width, cap mode, join mode
  26  * and dash composition, if used.
  27  *
  28  * Since: 1.0
  29  **/
  30
  31 /**
  32  * AdgLineStyle:
  33  *
  34  * All fields are private and should not be used directly.
  35  * Use its public methods instead.
  36  *
  37  * Since: 1.0
  38  **/
  39
  40
  41 #include "adg-internal.h"
  42 #include "adg-dress.h"
  43 #include "adg-style.h"
  44 #include "adg-dash.h"
  45
  46 #include "adg-line-style.h"
  47 #include "adg-line-style-private.h"
  48
  49
  50 G_DEFINE_TYPE(AdgLineStyle, adg_line_style, ADG_TYPE_STYLE)
  51
  52 enum {
  53     PROP_0,
  54     PROP_COLOR_DRESS,
  55     PROP_WIDTH,
  56     PROP_CAP,
  57     PROP_JOIN,
  58     PROP_MITER_LIMIT,
  59     PROP_ANTIALIAS,
  60     PROP_DASH
  61 };
  62
  63
  64 static void             _adg_get_property       (GObject        *object,
  65                                                  guint           prop_id,
  66                                                  GValue         *value,
  67                                                  GParamSpec     *pspec);
  68 static void             _adg_set_property       (GObject        *object,
  69                                                  guint           prop_id,
  70                                                  const GValue   *value,
  71                                                  GParamSpec     *pspec);
  72 static gboolean         _adg_change_dash        (AdgLineStyle   *style,
  73                                                  const AdgDash  *dash);
  74 static void             _adg_apply              (AdgStyle       *style,
  75                                                  AdgEntity      *entity,
  76                                                  cairo_t        *cr);
  77
  78
  79 static void
  80 adg_line_style_class_init(AdgLineStyleClass *klass)
  81 {
  82     GObjectClass *gobject_class;
  83     AdgStyleClass *style_class;
  84     GParamSpec *param;
  85
  86     gobject_class = (GObjectClass *) klass;
  87     style_class = (AdgStyleClass *) klass;
  88
  89     g_type_class_add_private(klass, sizeof(AdgLineStylePrivate));
  90
  91     gobject_class->get_property = _adg_get_property;
  92     gobject_class->set_property = _adg_set_property;
  93
  94     style_class->apply = _adg_apply;
  95
  96     param = adg_param_spec_dress("color-dress",
  97                                  P_("Color Dress"),
  98                                  P_("The color dress to bind to this line style"),
  99                                  ADG_DRESS_COLOR,
 100                                  G_PARAM_READWRITE);
 101     g_object_class_install_property(gobject_class, PROP_COLOR_DRESS, param);
 102
 103     param = g_param_spec_double("width",
 104                                 P_("Line Width"),
 105                                 P_("The line thickness in device unit"),
 106                                 0., G_MAXDOUBLE, 2., G_PARAM_READWRITE);
 107     g_object_class_install_property(gobject_class, PROP_WIDTH, param);
 108
 109     param = g_param_spec_int("cap",
 110                              P_("Line Cap"),
 111                              P_("The line cap mode"),
 112                              G_MININT, G_MAXINT, CAIRO_LINE_CAP_ROUND,
 113                              G_PARAM_READWRITE);
 114     g_object_class_install_property(gobject_class, PROP_CAP, param);
 115
 116     param = g_param_spec_int("join",
 117                              P_("Line Join"),
 118                              P_("The line join mode"),
 119                              G_MININT, G_MAXINT, CAIRO_LINE_JOIN_MITER,
 120                              G_PARAM_READWRITE);
 121     g_object_class_install_property(gobject_class, PROP_JOIN, param);
 122
 123     param = g_param_spec_double("miter-limit",
 124                                 P_("Miter Limit"),
 125                                 P_("Whether the lines should be joined with a bevel instead of a miter"),
 126                                 0., G_MAXDOUBLE, 10., G_PARAM_READWRITE);
 127     g_object_class_install_property(gobject_class, PROP_MITER_LIMIT,
 128                                     param);
 129
 130     param = g_param_spec_int("antialias",
 131                              P_("Antialiasing Mode"),
 132                              P_("Type of antialiasing to do when rendering lines"),
 133                              G_MININT, G_MAXINT, CAIRO_ANTIALIAS_DEFAULT,
 134                              G_PARAM_READWRITE);
 135     g_object_class_install_property(gobject_class, PROP_ANTIALIAS, param);
 136
 137     param = g_param_spec_boxed("dash",
 138                                P_("Dash Pattern"),
 139                                P_("The dash pattern to be used while stroking a path"),
 140                                ADG_TYPE_DASH, G_PARAM_READWRITE);
 141     g_object_class_install_property(gobject_class, PROP_DASH, param);
 142 }
 143
 144 static void
 145 adg_line_style_init(AdgLineStyle *line_style)
 146 {
 147     AdgLineStylePrivate *data = G_TYPE_INSTANCE_GET_PRIVATE(line_style,
 148                                                             ADG_TYPE_LINE_STYLE,
 149                                                             AdgLineStylePrivate);
 150
 151     data->color_dress = ADG_DRESS_COLOR;
 152     data->width = 2.;
 153     data->cap = CAIRO_LINE_CAP_ROUND;
 154     data->join = CAIRO_LINE_JOIN_MITER;
 155     data->miter_limit = 10.;
 156     data->antialias = CAIRO_ANTIALIAS_DEFAULT;
 157     data->dash = NULL;
 158
 159     line_style->data = data;
 160 }
 161
 162 static void
 163 _adg_get_property(GObject *object, guint prop_id,
 164                   GValue *value, GParamSpec *pspec)
 165 {
 166     AdgLineStylePrivate *data = ((AdgLineStyle *) object)->data;
 167
 168     switch (prop_id) {
 169     case PROP_COLOR_DRESS:
 170         g_value_set_enum(value, data->color_dress);
 171         break;
 172     case PROP_WIDTH:
 173         g_value_set_double(value, data->width);
 174         break;
 175     case PROP_CAP:
 176         g_value_set_int(value, data->cap);
 177         break;
 178     case PROP_JOIN:
 179         g_value_set_int(value, data->join);
 180         break;
 181     case PROP_MITER_LIMIT:
 182         g_value_set_double(value, data->miter_limit);
 183         break;
 184     case PROP_ANTIALIAS:
 185         g_value_set_int(value, data->antialias);
 186         break;
 187     case PROP_DASH:
 188         g_value_set_boxed(value, data->dash);
 189         break;
 190     default:
 191         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
 192         break;
 193     }
 194 }
 195
 196 static void
 197 _adg_set_property(GObject *object, guint prop_id,
 198                   const GValue *value, GParamSpec *pspec)
 199 {
 200     AdgLineStyle *line_style;
 201     AdgLineStylePrivate *data;
 202
 203     line_style = (AdgLineStyle *) object;
 204     data = line_style->data;
 205
 206     switch (prop_id) {
 207     case PROP_COLOR_DRESS:
 208         data->color_dress = g_value_get_enum(value);
 209         break;
 210     case PROP_WIDTH:
 211         data->width = g_value_get_double(value);
 212         break;
 213     case PROP_CAP:
 214         data->cap = g_value_get_int(value);
 215         break;
 216     case PROP_JOIN:
 217         data->join = g_value_get_int(value);
 218         break;
 219     case PROP_MITER_LIMIT:
 220         data->miter_limit = g_value_get_double(value);
 221         break;
 222     case PROP_ANTIALIAS:
 223         data->antialias = g_value_get_int(value);
 224         break;
 225     case PROP_DASH:
 226         _adg_change_dash(line_style, g_value_get_boxed(value));
 227         break;
 228     default:
 229         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
 230         break;
 231     }
 232 }
 233
 234
 235 /**
 236  * adg_line_style_new:
 237  *
 238  * Constructs a new line style initialized with default params.
 239  *
 240  * Returns: (transfer full): a new line style.
 241  *
 242  * Since: 1.0
 243  **/
 244 AdgLineStyle *
 245 adg_line_style_new(void)
 246 {
 247     return g_object_new(ADG_TYPE_LINE_STYLE, NULL);
 248 }
 249
 250 /**
 251  * adg_line_style_set_color_dress:
 252  * @line_style: an #AdgLineStyle
 253  * @dress: the new color dress to use
 254  *
 255  * Sets a new color dress on @line_style. The new dress
 256  * should be related to the original dress: you cannot
 257  * set a dress used for line styles to a dress managing
 258  * fonts.
 259  *
 260  * The validation of the new dress is done by calling
 261  * adg_dress_are_related() with @dress and the previous
 262  * dress as arguments: check out its documentation for
 263  * details on what is a related dress.
 264  *
 265  * Since: 1.0
 266  **/
 267 void
 268 adg_line_style_set_color_dress(AdgLineStyle *line_style, AdgDress dress)
 269 {
 270     g_return_if_fail(ADG_IS_LINE_STYLE(line_style));
 271     g_object_set(line_style, "color-dress", dress, NULL);
 272 }
 273
 274 /**
 275  * adg_line_style_get_color_dress:
 276  * @line_style: an #AdgLineStyle
 277  *
 278  * Gets the color dress used by @line_style.
 279  *
 280  * Returns: (transfer none): the current color dress.
 281  *
 282  * Since: 1.0
 283  **/
 284 AdgDress
 285 adg_line_style_get_color_dress(AdgLineStyle *line_style)
 286 {
 287     AdgLineStylePrivate *data;
 288
 289     g_return_val_if_fail(ADG_IS_LINE_STYLE(line_style), ADG_DRESS_UNDEFINED);
 290
 291     data = line_style->data;
 292
 293     return data->color_dress;
 294 }
 295
 296 /**
 297  * adg_line_style_set_width:
 298  * @line_style: an #AdgLineStyle object
 299  * @width: the new width
 300  *
 301  * Sets a new line thickness value.
 302  *
 303  * Since: 1.0
 304  **/
 305 void
 306 adg_line_style_set_width(AdgLineStyle *line_style, gdouble width)
 307 {
 308     g_return_if_fail(ADG_IS_LINE_STYLE(line_style));
 309     g_object_set(line_style, "width", width, NULL);
 310 }
 311
 312 /**
 313  * adg_line_style_get_width:
 314  * @line_style: an #AdgLineStyle object
 315  *
 316  * Gets the line thickness value (in global space).
 317  *
 318  * Returns: the requested width.
 319  *
 320  * Since: 1.0
 321  **/
 322 gdouble
 323 adg_line_style_get_width(AdgLineStyle *line_style)
 324 {
 325     AdgLineStylePrivate *data;
 326
 327     g_return_val_if_fail(ADG_IS_LINE_STYLE(line_style), 0.);
 328
 329     data = line_style->data;
 330
 331     return data->width;
 332 }
 333
 334 /**
 335  * adg_line_style_set_cap:
 336  * @line_style: an #AdgLineStyle object
 337  * @cap: (type gint): the new cap mode
 338  *
 339  * Sets a new line cap mode.
 340  *
 341  * Since: 1.0
 342  **/
 343 void
 344 adg_line_style_set_cap(AdgLineStyle *line_style, cairo_line_cap_t cap)
 345 {
 346     AdgLineStylePrivate *data;
 347
 348     g_return_if_fail(ADG_IS_LINE_STYLE(line_style));
 349
 350     data = line_style->data;
 351     data->cap = cap;
 352
 353     g_object_notify((GObject *) line_style, "cap");
 354 }
 355
 356 /**
 357  * adg_line_style_get_cap:
 358  * @line_style: an #AdgLineStyle object
 359  *
 360  * Gets the line cap mode.
 361  *
 362  * Returns: (type gint) (transfer none): the requested line cap mode.
 363  *
 364  * Since: 1.0
 365  **/
 366 cairo_line_cap_t
 367 adg_line_style_get_cap(AdgLineStyle *line_style)
 368 {
 369     AdgLineStylePrivate *data;
 370
 371     g_return_val_if_fail(ADG_IS_LINE_STYLE(line_style),
 372                          CAIRO_LINE_CAP_BUTT);
 373
 374     data = line_style->data;
 375
 376     return data->cap;
 377 }
 378
 379 /**
 380  * adg_line_style_set_join:
 381  * @line_style: an #AdgLineStyle object
 382  * @join: (type gint): the new join mode
 383  *
 384  * Sets a new line join mode.
 385  *
 386  * Since: 1.0
 387  **/
 388 void
 389 adg_line_style_set_join(AdgLineStyle *line_style, cairo_line_join_t join)
 390 {
 391     AdgLineStylePrivate *data;
 392
 393     g_return_if_fail(ADG_IS_LINE_STYLE(line_style));
 394
 395     data = line_style->data;
 396     data->join = join;
 397
 398     g_object_notify((GObject *) line_style, "join");
 399 }
 400
 401 /**
 402  * adg_line_style_get_join:
 403  * @line_style: an #AdgLineStyle object
 404  *
 405  * Gets the line join mode.
 406  *
 407  * Returns: (type gint) (transfer none): the requested line join mode.
 408  *
 409  * Since: 1.0
 410  **/
 411 cairo_line_join_t
 412 adg_line_style_get_join(AdgLineStyle *line_style)
 413 {
 414     AdgLineStylePrivate *data;
 415
 416     g_return_val_if_fail(ADG_IS_LINE_STYLE(line_style),
 417                          CAIRO_LINE_JOIN_MITER);
 418
 419     data = line_style->data;
 420
 421     return data->join;
 422 }
 423
 424 /**
 425  * adg_line_style_set_miter_limit:
 426  * @line_style: an #AdgLineStyle object
 427  * @miter_limit: the new miter limit
 428  *
 429  * Sets a new miter limit value.
 430  *
 431  * Since: 1.0
 432  **/
 433 void
 434 adg_line_style_set_miter_limit(AdgLineStyle *line_style, gdouble miter_limit)
 435 {
 436     g_return_if_fail(ADG_IS_LINE_STYLE(line_style));
 437     g_object_set(line_style, "miter-limit", miter_limit, NULL);
 438 }
 439
 440 /**
 441  * adg_line_style_get_miter_limit:
 442  * @line_style: an #AdgLineStyle object
 443  *
 444  * Gets the line miter limit value. The miter limit is used to determine
 445  * whether the lines should be joined with a bevel instead of a miter.
 446  *
 447  * Returns: the requested miter limit
 448  *
 449  * Since: 1.0
 450  **/
 451 gdouble
 452 adg_line_style_get_miter_limit(AdgLineStyle *line_style)
 453 {
 454     AdgLineStylePrivate *data;
 455
 456     g_return_val_if_fail(ADG_IS_LINE_STYLE(line_style), 0.);
 457
 458     data = line_style->data;
 459
 460     return data->miter_limit;
 461 }
 462
 463 /**
 464  * adg_line_style_set_antialias:
 465  * @line_style: an #AdgLineStyle object
 466  * @antialias: (type gint): the new antialias mode
 467  *
 468  * Sets a new antialias mode.
 469  *
 470  * Since: 1.0
 471  **/
 472 void
 473 adg_line_style_set_antialias(AdgLineStyle *line_style,
 474                              cairo_antialias_t antialias)
 475 {
 476     AdgLineStylePrivate *data;
 477
 478     g_return_if_fail(ADG_IS_LINE_STYLE(line_style));
 479
 480     data = line_style->data;
 481     data->antialias = antialias;
 482
 483     g_object_notify((GObject *) line_style, "antialias");
 484 }
 485
 486 /**
 487  * adg_line_style_get_antialias:
 488  * @line_style: an #AdgLineStyle object
 489  *
 490  * Gets the antialias mode used.
 491  *
 492  * Returns: (type gint) (transfer none): the requested antialias mode.
 493  *
 494  * Since: 1.0
 495  **/
 496 cairo_antialias_t
 497 adg_line_style_get_antialias(AdgLineStyle *line_style)
 498 {
 499     AdgLineStylePrivate *data;
 500
 501     g_return_val_if_fail(ADG_IS_LINE_STYLE(line_style),
 502                          CAIRO_ANTIALIAS_DEFAULT);
 503
 504     data = line_style->data;
 505
 506     return data->antialias;
 507 }
 508
 509 /**
 510  * adg_line_style_set_dash:
 511  * @line_style: an #AdgLineStyle object
 512  * @dash: the new #AdgDash pattern
 513  *
 514  * Sets the dash pattern of @line_style to @dash: all future rendering with
 515  * this line style will use this pattern.
 516  *
 517  * @line_style will embed a copy of @dash: this means that after this call,
 518  * @dash can be freed (with adg_dash_destroy()) if no more needed.
 519  *
 520  * Since: 1.0
 521  **/
 522 void
 523 adg_line_style_set_dash(AdgLineStyle *line_style, const AdgDash *dash)
 524 {
 525     g_return_if_fail(ADG_IS_LINE_STYLE(line_style));
 526
 527     if (_adg_change_dash(line_style, dash))
 528         g_object_notify((GObject *) line_style, "dash");
 529 }
 530
 531 /**
 532  * adg_line_style_get_dash:
 533  * @line_style: an #AdgLineStyle object
 534  *
 535  * Gets the dash pattern currently active on @line_style. A %NULL value is
 536  * returned when no dash pattern is active.
 537  *
 538  * The returned pattern is owned by @line_style: you are not allowed to modify
 539  * or free it. If something needs to be changed, work on a duplicate and reset
 540  * the new pattern, such as:
 541  *
 542  * |[
 543  * AdgDash *dash, *new_dash;
 544  *
 545  * dash = adg_line_style_get_dash(line_style);
 546  * if (dash == NULL)
 547  *     new_dash = adg_dash_new();
 548  * else
 549  *     new_dash = adg_dash_dup(dash);
 550  *
 551  * // ...modify new_dash as needed...
 552  *
 553  * adg_line_style_set_dash(line_style, new_dash);
 554  * adg_dash_destroy(new_dash);
 555  * ]|
 556  *
 557  * <note><para>
 558  * Getting #AdgLineStyle:dash via the #GObject property mechanism returns
 559  * a duplicate instead, so you must free it when done.
 560  * </para></note>
 561  *
 562  * |[
 563  * g_object_get(line_style, "dash", &dash, NULL);
 564  * // Here dash is a duplicate: modifying it will not affect line_style
 565  * adg_dash_destroy(dash);
 566  * ]|
 567  *
 568  * Returns: the current dash pattern or %NULL on errors.
 569  *
 570  * Since: 1.0
 571  **/
 572 const AdgDash *
 573 adg_line_style_get_dash(AdgLineStyle *line_style)
 574 {
 575     AdgLineStylePrivate *data;
 576
 577     g_return_val_if_fail(ADG_IS_LINE_STYLE(line_style), NULL);
 578
 579     data = line_style->data;
 580     return data->dash;
 581 }
 582
 583
 584 static gboolean
 585 _adg_change_dash(AdgLineStyle *line_style, const AdgDash *dash)
 586 {
 587     AdgLineStylePrivate *data = line_style->data;
 588
 589     if (data->dash == dash)
 590         return FALSE;
 591
 592     if (data->dash != NULL) {
 593         adg_dash_destroy(data->dash);
 594         data->dash = NULL;
 595     }
 596
 597     if (dash != NULL) {
 598         data->dash = adg_dash_dup(dash);
 599     }
 600
 601     return TRUE;
 602 }
 603
 604 static void
 605 _adg_apply(AdgStyle *style, AdgEntity *entity, cairo_t *cr)
 606 {
 607     AdgLineStylePrivate *data = ((AdgLineStyle *) style)->data;
 608
 609     adg_entity_apply_dress(entity, data->color_dress, cr);
 610     cairo_set_line_width(cr, data->width);
 611     cairo_set_line_cap(cr, data->cap);
 612     cairo_set_line_join(cr, data->join);
 613     cairo_set_miter_limit(cr, data->miter_limit);
 614     cairo_set_antialias(cr, data->antialias);
 615
 616     if (data->dash != NULL) {
 617         cairo_set_dash(cr,
 618                        adg_dash_get_dashes(data->dash),
 619                        adg_dash_get_num_dashes(data->dash),
 620                        adg_dash_get_offset(data->dash));
 621     }
 622 }