adg/adg-line-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-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
  29 /**
  30  * AdgLineStyle:
  31  *
  32  * All fields are private and should not be used directly.
  33  * Use its public methods instead.
  34  **/
  35
  36
  37 #include "adg-line-style.h"
  38 #include "adg-line-style-private.h"
  39 #include "adg-intl.h"
  40
  41 #define PARENT_STYLE_CLASS  ((AdgStyleClass *) adg_line_style_parent_class)
  42
  43
  44 enum {
  45     PROP_0,
  46     PROP_WIDTH,
  47     PROP_CAP,
  48     PROP_JOIN,
  49     PROP_MITER_LIMIT,
  50     PROP_ANTIALIAS,
  51     PROP_DASH
  52 };
  53
  54
  55 static void             get_property    (GObject        *object,
  56                                          guint           prop_id,
  57                                          GValue         *value,
  58                                          GParamSpec     *pspec);
  59 static void             set_property    (GObject        *object,
  60                                          guint           prop_id,
  61                                          const GValue   *value,
  62                                          GParamSpec     *pspec);
  63 static void             apply           (AdgStyle       *style,
  64                                          cairo_t        *cr);
  65
  66
  67 G_DEFINE_TYPE(AdgLineStyle, adg_line_style, ADG_TYPE_STYLE);
  68
  69
  70 static void
  71 adg_line_style_class_init(AdgLineStyleClass *klass)
  72 {
  73     GObjectClass *gobject_class;
  74     AdgStyleClass *style_class;
  75     GParamSpec *param;
  76
  77     gobject_class = (GObjectClass *) klass;
  78     style_class = (AdgStyleClass *) klass;
  79
  80     g_type_class_add_private(klass, sizeof(AdgLineStylePrivate));
  81
  82     gobject_class->get_property = get_property;
  83     gobject_class->set_property = set_property;
  84
  85     style_class->apply = apply;
  86
  87     param = g_param_spec_double("width",
  88                                 P_("Line Width"),
  89                                 P_("The line thickness in device unit"),
  90                                 0., G_MAXDOUBLE, 2., G_PARAM_READWRITE);
  91     g_object_class_install_property(gobject_class, PROP_WIDTH, param);
  92
  93     param = g_param_spec_int("cap",
  94                              P_("Line Cap"),
  95                              P_("The line cap mode"),
  96                              G_MININT, G_MAXINT, CAIRO_LINE_CAP_ROUND,
  97                              G_PARAM_READWRITE);
  98     g_object_class_install_property(gobject_class, PROP_CAP, param);
  99
 100     param = g_param_spec_int("join",
 101                              P_("Line Join"),
 102                              P_("The line join mode"),
 103                              G_MININT, G_MAXINT, CAIRO_LINE_JOIN_MITER,
 104                              G_PARAM_READWRITE);
 105     g_object_class_install_property(gobject_class, PROP_JOIN, param);
 106
 107     param = g_param_spec_double("miter-limit",
 108                                 P_("Miter Limit"),
 109                                 P_("Whether the lines should be joined with a bevel instead of a miter"),
 110                                 0., G_MAXDOUBLE, 10., G_PARAM_READWRITE);
 111     g_object_class_install_property(gobject_class, PROP_MITER_LIMIT,
 112                                     param);
 113
 114     param = g_param_spec_int("antialias",
 115                              P_("Antialiasing Mode"),
 116                              P_("Type of antialiasing to do when rendering lines"),
 117                              G_MININT, G_MAXINT, CAIRO_ANTIALIAS_DEFAULT,
 118                              G_PARAM_READWRITE);
 119     g_object_class_install_property(gobject_class, PROP_ANTIALIAS, param);
 120
 121     /* TODO: PROP_DASH (PROP_DASHES, PROP_NUM_DASHES, PROP_DASH_OFFSET) */
 122 }
 123
 124 static void
 125 adg_line_style_init(AdgLineStyle *line_style)
 126 {
 127     AdgLineStylePrivate *data = G_TYPE_INSTANCE_GET_PRIVATE(line_style,
 128                                                             ADG_TYPE_LINE_STYLE,
 129                                                             AdgLineStylePrivate);
 130
 131     data->width = 2.;
 132     data->cap = CAIRO_LINE_CAP_ROUND;
 133     data->join = CAIRO_LINE_JOIN_MITER;
 134     data->miter_limit = 10.;
 135     data->antialias = CAIRO_ANTIALIAS_DEFAULT;
 136     data->dashes = NULL;
 137     data->num_dashes = 0;
 138     data->dash_offset = 0.;
 139
 140     line_style->data = data;
 141 }
 142
 143 static void
 144 get_property(GObject *object,
 145              guint prop_id, GValue *value, GParamSpec *pspec)
 146 {
 147     AdgLineStylePrivate *data = ((AdgLineStyle *) object)->data;
 148
 149     switch (prop_id) {
 150     case PROP_WIDTH:
 151         g_value_set_double(value, data->width);
 152         break;
 153     case PROP_CAP:
 154         g_value_set_int(value, data->cap);
 155         break;
 156     case PROP_JOIN:
 157         g_value_set_int(value, data->join);
 158         break;
 159     case PROP_MITER_LIMIT:
 160         g_value_set_double(value, data->miter_limit);
 161         break;
 162     case PROP_ANTIALIAS:
 163         g_value_set_int(value, data->antialias);
 164         break;
 165     case PROP_DASH:
 166         /* TODO */
 167         break;
 168     default:
 169         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
 170         break;
 171     }
 172 }
 173
 174 static void
 175 set_property(GObject *object,
 176              guint prop_id, const GValue *value, GParamSpec *pspec)
 177 {
 178     AdgLineStylePrivate *data = ((AdgLineStyle *) object)->data;
 179
 180     switch (prop_id) {
 181     case PROP_WIDTH:
 182         data->width = g_value_get_double(value);
 183         break;
 184     case PROP_CAP:
 185         data->cap = g_value_get_int(value);
 186         break;
 187     case PROP_JOIN:
 188         data->join = g_value_get_int(value);
 189         break;
 190     case PROP_MITER_LIMIT:
 191         data->miter_limit = g_value_get_double(value);
 192         break;
 193     case PROP_ANTIALIAS:
 194         data->antialias = g_value_get_int(value);
 195         break;
 196     case PROP_DASH:
 197         /* TODO */
 198         break;
 199     default:
 200         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
 201         break;
 202     }
 203 }
 204
 205
 206 /**
 207  * adg_line_style_new:
 208  *
 209  * Constructs a new line style initialized with default params.
 210  *
 211  * Returns: a new line style
 212  **/
 213 AdgLineStyle *
 214 adg_line_style_new(void)
 215 {
 216     return g_object_new(ADG_TYPE_LINE_STYLE, NULL);
 217 }
 218
 219 /**
 220  * adg_line_style_get_width:
 221  * @line_style: an #AdgLineStyle object
 222  *
 223  * Gets the line thickness value (in global space).
 224  *
 225  * Returns: the requested width
 226  **/
 227 gdouble
 228 adg_line_style_get_width(AdgLineStyle *line_style)
 229 {
 230     AdgLineStylePrivate *data;
 231
 232     g_return_val_if_fail(ADG_IS_LINE_STYLE(line_style), 0.);
 233
 234     data = line_style->data;
 235
 236     return data->width;
 237 }
 238
 239 /**
 240  * adg_line_style_set_width:
 241  * @line_style: an #AdgLineStyle object
 242  * @width: the new width
 243  *
 244  * Sets a new line thickness value.
 245  **/
 246 void
 247 adg_line_style_set_width(AdgLineStyle *line_style, gdouble width)
 248 {
 249     AdgLineStylePrivate *data;
 250
 251     g_return_if_fail(ADG_IS_LINE_STYLE(line_style));
 252
 253     data = line_style->data;
 254     data->width = width;
 255
 256     g_object_notify((GObject *) line_style, "width");
 257 }
 258
 259 /**
 260  * adg_line_style_get_cap:
 261  * @line_style: an #AdgLineStyle object
 262  *
 263  * Gets the line cap mode.
 264  *
 265  * Returns: the requested line cap mode
 266  **/
 267 cairo_line_cap_t
 268 adg_line_style_get_cap(AdgLineStyle *line_style)
 269 {
 270     AdgLineStylePrivate *data;
 271
 272     g_return_val_if_fail(ADG_IS_LINE_STYLE(line_style),
 273                          CAIRO_LINE_CAP_BUTT);
 274
 275     data = line_style->data;
 276
 277     return data->cap;
 278 }
 279
 280 /**
 281  * adg_line_style_set_cap:
 282  * @line_style: an #AdgLineStyle object
 283  * @cap: the new cap mode
 284  *
 285  * Sets a new line cap mode.
 286  **/
 287 void
 288 adg_line_style_set_cap(AdgLineStyle *line_style, cairo_line_cap_t cap)
 289 {
 290     AdgLineStylePrivate *data;
 291
 292     g_return_if_fail(ADG_IS_LINE_STYLE(line_style));
 293
 294     data = line_style->data;
 295     data->cap = cap;
 296
 297     g_object_notify((GObject *) line_style, "cap");
 298 }
 299
 300 /**
 301  * adg_line_style_get_join:
 302  * @line_style: an #AdgLineStyle object
 303  *
 304  * Gets the line join mode.
 305  *
 306  * Returns: the requested line join mode
 307  **/
 308 cairo_line_join_t
 309 adg_line_style_get_join(AdgLineStyle *line_style)
 310 {
 311     AdgLineStylePrivate *data;
 312
 313     g_return_val_if_fail(ADG_IS_LINE_STYLE(line_style),
 314                          CAIRO_LINE_JOIN_MITER);
 315
 316     data = line_style->data;
 317
 318     return data->join;
 319 }
 320
 321 /**
 322  * adg_line_style_set_join:
 323  * @line_style: an #AdgLineStyle object
 324  * @join: the new join mode
 325  *
 326  * Sets a new line join mode.
 327  **/
 328 void
 329 adg_line_style_set_join(AdgLineStyle *line_style, cairo_line_join_t join)
 330 {
 331     AdgLineStylePrivate *data;
 332
 333     g_return_if_fail(ADG_IS_LINE_STYLE(line_style));
 334
 335     data->join = join;
 336     data = line_style->data;
 337
 338     g_object_notify((GObject *) line_style, "join");
 339 }
 340
 341 /**
 342  * adg_line_style_get_miter_limit:
 343  * @line_style: an #AdgLineStyle object
 344  *
 345  * Gets the line miter limit value. The miter limit is used to determine
 346  * whether the lines should be joined with a bevel instead of a miter.
 347  *
 348  * Returns: the requested miter limit
 349  **/
 350 gdouble
 351 adg_line_style_get_miter_limit(AdgLineStyle *line_style)
 352 {
 353     AdgLineStylePrivate *data;
 354
 355     g_return_val_if_fail(ADG_IS_LINE_STYLE(line_style), 0.);
 356
 357     data = line_style->data;
 358
 359     return data->miter_limit;
 360 }
 361
 362 /**
 363  * adg_line_style_set_miter_limit:
 364  * @line_style: an #AdgLineStyle object
 365  * @miter_limit: the new miter limit
 366  *
 367  * Sets a new miter limit value.
 368  **/
 369 void
 370 adg_line_style_set_miter_limit(AdgLineStyle *line_style,
 371                                gdouble miter_limit)
 372 {
 373     AdgLineStylePrivate *data;
 374
 375     g_return_if_fail(ADG_IS_LINE_STYLE(line_style));
 376
 377     data = line_style->data;
 378     data->miter_limit = miter_limit;
 379
 380     g_object_notify((GObject *) line_style, "miter-limit");
 381 }
 382
 383 /**
 384  * adg_line_style_get_antialias:
 385  * @line_style: an #AdgLineStyle object
 386  *
 387  * Gets the antialias mode used.
 388  *
 389  * Returns: the requested antialias mode
 390  **/
 391 cairo_antialias_t
 392 adg_line_style_get_antialias(AdgLineStyle *line_style)
 393 {
 394     AdgLineStylePrivate *data;
 395
 396     g_return_val_if_fail(ADG_IS_LINE_STYLE(line_style),
 397                          CAIRO_ANTIALIAS_DEFAULT);
 398
 399     data = line_style->data;
 400
 401     return data->antialias;
 402 }
 403
 404 /**
 405  * adg_line_style_set_antialias:
 406  * @line_style: an #AdgLineStyle object
 407  * @antialias: the new antialias mode
 408  *
 409  * Sets a new antialias mode.
 410  **/
 411 void
 412 adg_line_style_set_antialias(AdgLineStyle *line_style,
 413                              cairo_antialias_t antialias)
 414 {
 415     AdgLineStylePrivate *data;
 416
 417     g_return_if_fail(ADG_IS_LINE_STYLE(line_style));
 418
 419     data = line_style->data;
 420     data->antialias = antialias;
 421
 422     g_object_notify((GObject *) line_style, "antialias");
 423 }
 424
 425 static void
 426 apply(AdgStyle *style, cairo_t *cr)
 427 {
 428     AdgLineStylePrivate *data = ((AdgLineStyle *) style)->data;
 429
 430     cairo_set_line_width(cr, data->width);
 431     cairo_set_line_cap(cr, data->cap);
 432     cairo_set_line_join(cr, data->join);
 433     cairo_set_miter_limit(cr, data->miter_limit);
 434     cairo_set_antialias(cr, data->antialias);
 435
 436     if (data->num_dashes > 0) {
 437         g_return_if_fail(data->dashes != NULL);
 438
 439         cairo_set_dash(cr, data->dashes, data->num_dashes, data->dash_offset);
 440     }
 441 }