adg/adg-ruled-fill.c

   1 /* ADG - Automatic Drawing Generation
   2  * Copyright (C) 2007,2008,2009,2010  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-ruled-fill
  23  * @short_description: A style composed of evenly spaced lines.
  24  *
  25  * The spacing between the lines could be changed using the
  26  * adg_ruled_fill_set_spacing() method. The angle of the lines should
  27  * be changed with adg_ruled_fill_set_angle().
  28  **/
  29
  30 /**
  31  * AdgRuledFill:
  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-ruled-fill.h"
  40 #include "adg-ruled-fill-private.h"
  41 #include "adg-dress-builtins.h"
  42 #include <math.h>
  43
  44 #define PARENT_STYLE_CLASS      ((AdgStyleClass *) adg_ruled_fill_parent_class)
  45 #define PARENT_FILL_STYLE_CLASS ((AdgFillStyleClass *) adg_ruled_fill_parent_class)
  46
  47
  48 enum {
  49     PROP_0,
  50     PROP_LINE_DRESS,
  51     PROP_SPACING,
  52     PROP_ANGLE
  53 };
  54
  55
  56 static void             get_property    (GObject        *object,
  57                                          guint           prop_id,
  58                                          GValue         *value,
  59                                          GParamSpec     *pspec);
  60 static void             set_property    (GObject        *object,
  61                                          guint           prop_id,
  62                                          const GValue   *value,
  63                                          GParamSpec     *pspec);
  64 static void             apply           (AdgStyle       *style,
  65                                          AdgEntity      *entity,
  66                                          cairo_t        *cr);
  67 static void             set_extents     (AdgFillStyle   *fill_style,
  68                                          const CpmlExtents *extents);
  69 static gboolean         set_spacing     (AdgRuledFill   *ruled_fill,
  70                                          gdouble         spacing);
  71 static gboolean         set_angle       (AdgRuledFill   *ruled_fill,
  72                                          gdouble         angle);
  73 static cairo_pattern_t *create_pattern  (AdgRuledFill   *ruled_fill,
  74                                          AdgEntity      *entity,
  75                                          cairo_t        *cr);
  76 static void             draw_lines      (const CpmlPair *spacing,
  77                                          const CpmlPair *size,
  78                                          cairo_t        *cr);
  79
  80
  81 G_DEFINE_TYPE(AdgRuledFill, adg_ruled_fill, ADG_TYPE_FILL_STYLE);
  82
  83
  84 static void
  85 adg_ruled_fill_class_init(AdgRuledFillClass *klass)
  86 {
  87     GObjectClass *gobject_class;
  88     AdgStyleClass *style_class;
  89     AdgFillStyleClass *fill_style_class;
  90     GParamSpec *param;
  91
  92     gobject_class = (GObjectClass *) klass;
  93     style_class = (AdgStyleClass *) klass;
  94     fill_style_class = (AdgFillStyleClass *) klass;
  95
  96     g_type_class_add_private(klass, sizeof(AdgRuledFillPrivate));
  97
  98     gobject_class->get_property = get_property;
  99     gobject_class->set_property = set_property;
 100
 101     style_class->apply = apply;
 102
 103     fill_style_class->set_extents = set_extents;
 104
 105     param = adg_param_spec_dress("line-dress",
 106                                   P_("Line Dress"),
 107                                   P_("Dress to be used for rendering the lines"),
 108                                   ADG_DRESS_LINE_HATCH,
 109                                   G_PARAM_READWRITE);
 110     g_object_class_install_property(gobject_class, PROP_LINE_DRESS, param);
 111
 112     param = g_param_spec_double("spacing",
 113                                P_("Spacing"),
 114                                P_("The spacing in global spaces between the lines"),
 115                                0, G_MAXDOUBLE, 16,
 116                                G_PARAM_READWRITE);
 117     g_object_class_install_property(gobject_class, PROP_SPACING, param);
 118
 119     param = g_param_spec_double("angle",
 120                                P_("Angle"),
 121                                P_("The angle (in radians) of the lines"),
 122                                0, G_PI, G_PI_4,
 123                                G_PARAM_READWRITE);
 124     g_object_class_install_property(gobject_class, PROP_ANGLE, param);
 125 }
 126
 127 static void
 128 adg_ruled_fill_init(AdgRuledFill *ruled_fill)
 129 {
 130     AdgRuledFillPrivate *data = G_TYPE_INSTANCE_GET_PRIVATE(ruled_fill,
 131                                                             ADG_TYPE_RULED_FILL,
 132                                                             AdgRuledFillPrivate);
 133
 134     data->line_dress = ADG_DRESS_LINE_HATCH;
 135     data->angle = G_PI_4;
 136     data->spacing = 16;
 137
 138     ruled_fill->data = data;
 139 }
 140
 141 static void
 142 get_property(GObject *object,
 143              guint prop_id, GValue *value, GParamSpec *pspec)
 144 {
 145     AdgRuledFillPrivate *data = ((AdgRuledFill *) object)->data;
 146
 147     switch (prop_id) {
 148     case PROP_LINE_DRESS:
 149         g_value_set_int(value, data->line_dress);
 150         break;
 151     case PROP_SPACING:
 152         g_value_set_double(value, data->spacing);
 153         break;
 154     case PROP_ANGLE:
 155         g_value_set_double(value, data->angle);
 156         break;
 157     default:
 158         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
 159         break;
 160     }
 161 }
 162
 163 static void
 164 set_property(GObject *object,
 165              guint prop_id, const GValue *value, GParamSpec *pspec)
 166 {
 167     AdgRuledFill *ruled_fill;
 168     AdgRuledFillPrivate *data;
 169
 170     ruled_fill = (AdgRuledFill *) object;
 171     data = ruled_fill->data;
 172
 173     switch (prop_id) {
 174     case PROP_LINE_DRESS:
 175         adg_dress_set(&data->line_dress, g_value_get_int(value));
 176         break;
 177     case PROP_SPACING:
 178         set_spacing(ruled_fill, g_value_get_double(value));
 179         break;
 180     case PROP_ANGLE:
 181         set_angle(ruled_fill, g_value_get_double(value));
 182         break;
 183     default:
 184         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
 185         break;
 186     }
 187 }
 188
 189
 190 /**
 191  * adg_ruled_fill_set_line_dress:
 192  * @ruled_fill: an #AdgRuledFill object
 193  * @dress: the new line dress
 194  *
 195  * Sets a new line dress on @ruled_fill.
 196  **/
 197 void
 198 adg_ruled_fill_set_line_dress(AdgRuledFill *ruled_fill, AdgDress dress)
 199 {
 200     AdgRuledFillPrivate *data;
 201
 202     g_return_if_fail(ADG_IS_RULED_FILL(ruled_fill));
 203
 204     data = ruled_fill->data;
 205
 206     if (adg_dress_set(&data->line_dress, dress))
 207         g_object_notify((GObject *) ruled_fill, "line-dress");
 208 }
 209
 210 /**
 211  * adg_ruled_fill_get_line_dress:
 212  * @ruled_fill: an #AdgRuledFill object
 213  *
 214  * Gets the @ruled_fill dress to be used for rendering the lines.
 215  *
 216  * Returns: the line dress
 217  **/
 218 AdgDress
 219 adg_ruled_fill_get_line_dress(AdgRuledFill *ruled_fill)
 220 {
 221     AdgRuledFillPrivate *data;
 222
 223     g_return_val_if_fail(ADG_IS_RULED_FILL(ruled_fill), ADG_DRESS_UNDEFINED);
 224
 225     data = ruled_fill->data;
 226
 227     return data->line_dress;
 228 }
 229
 230 /**
 231  * adg_ruled_fill_set_spacing:
 232  * @ruled_fill: an #AdgRuledFill
 233  * @spacing: the new spacing
 234  *
 235  * Sets a new spacing on @ruled_fill.
 236  **/
 237 void
 238 adg_ruled_fill_set_spacing(AdgRuledFill *ruled_fill, gdouble spacing)
 239 {
 240     g_return_if_fail(ADG_IS_RULED_FILL(ruled_fill));
 241
 242     if (set_spacing(ruled_fill, spacing))
 243         g_object_notify((GObject *) ruled_fill, "spacing");
 244 }
 245
 246 /**
 247  * adg_ruled_fill_get_spacing:
 248  * @ruled_fill: an #AdgRuledFill
 249  *
 250  * Gets the current spacing of @ruled_fill.
 251  *
 252  * Returns: the spacing (in global space)
 253  **/
 254 gdouble
 255 adg_ruled_fill_get_spacing(AdgRuledFill *ruled_fill)
 256 {
 257     AdgRuledFillPrivate *data;
 258
 259     g_return_val_if_fail(ADG_IS_RULED_FILL(ruled_fill), 0);
 260
 261     data = ruled_fill->data;
 262
 263     return data->spacing;
 264 }
 265
 266 /**
 267  * adg_ruled_fill_set_angle:
 268  * @ruled_fill: an #AdgRuledFill
 269  * @angle: the new angle
 270  *
 271  * Sets a new angle on @ruled_fill.
 272  **/
 273 void
 274 adg_ruled_fill_set_angle(AdgRuledFill *ruled_fill, gdouble angle)
 275 {
 276     g_return_if_fail(ADG_IS_RULED_FILL(ruled_fill));
 277
 278     if (set_angle(ruled_fill, angle))
 279         g_object_notify((GObject *) ruled_fill, "angle");
 280 }
 281
 282 /**
 283  * adg_ruled_fill_get_angle:
 284  * @ruled_fill: an #AdgRuledFill
 285  *
 286  * Gets the current angle of @ruled_fill.
 287  *
 288  * Returns: the angle (in radians)
 289  **/
 290 gdouble
 291 adg_ruled_fill_get_angle(AdgRuledFill *ruled_fill)
 292 {
 293     AdgRuledFillPrivate *data;
 294
 295     g_return_val_if_fail(ADG_IS_RULED_FILL(ruled_fill), 0);
 296
 297     data = ruled_fill->data;
 298
 299     return data->angle;
 300 }
 301
 302
 303 static void
 304 apply(AdgStyle *style, AdgEntity *entity, cairo_t *cr)
 305 {
 306     AdgFillStyle *fill_style;
 307     AdgPattern *pattern;
 308     const CpmlExtents *extents;
 309     cairo_matrix_t matrix;
 310
 311     fill_style = (AdgFillStyle *) style;
 312     pattern = adg_fill_style_get_pattern(fill_style);
 313     extents = adg_fill_style_get_extents(fill_style);
 314
 315     if (pattern == NULL) {
 316         pattern = create_pattern((AdgRuledFill *) style, entity, cr);
 317         if (pattern == NULL)
 318             return;
 319
 320         adg_fill_style_set_pattern(fill_style, pattern);
 321         cairo_pattern_destroy(pattern);
 322     }
 323
 324     cairo_matrix_init_translate(&matrix, -extents->org.x, -extents->org.y);
 325     cairo_pattern_set_matrix(pattern, &matrix);
 326
 327     if (PARENT_STYLE_CLASS->apply)
 328         PARENT_STYLE_CLASS->apply(style, entity, cr);
 329 }
 330
 331 static void
 332 set_extents(AdgFillStyle *fill_style, const CpmlExtents *extents)
 333 {
 334     CpmlExtents old, new;
 335
 336     cpml_extents_copy(&old, adg_fill_style_get_extents(fill_style));
 337
 338     /* The pattern is invalidated (and thus regenerated) only
 339      * when the new extents are wider than the old ones */
 340     if (old.size.x >= extents->size.x && old.size.y >= extents->size.y) {
 341         new.org = extents->org;
 342         new.size = old.size;
 343     } else {
 344         cpml_extents_copy(&new, extents);
 345         adg_fill_style_set_pattern(fill_style, NULL);
 346     }
 347
 348     if (PARENT_FILL_STYLE_CLASS->set_extents)
 349         PARENT_FILL_STYLE_CLASS->set_extents(fill_style, &new);
 350 }
 351
 352 static gboolean
 353 set_spacing(AdgRuledFill *ruled_fill, gdouble spacing)
 354 {
 355     AdgRuledFillPrivate *data = ruled_fill->data;
 356
 357     if (spacing == data->spacing)
 358         return FALSE;
 359
 360     data->spacing = spacing;
 361     adg_fill_style_set_pattern((AdgFillStyle *) ruled_fill, NULL);
 362
 363     return TRUE;
 364 }
 365
 366 static gboolean
 367 set_angle(AdgRuledFill *ruled_fill, gdouble angle)
 368 {
 369     AdgRuledFillPrivate *data = ruled_fill->data;
 370
 371     if (angle == data->angle)
 372         return FALSE;
 373
 374     data->angle = angle;
 375     adg_fill_style_set_pattern((AdgFillStyle *) ruled_fill, NULL);
 376
 377     return TRUE;
 378 }
 379
 380 static cairo_pattern_t *
 381 create_pattern(AdgRuledFill *ruled_fill, AdgEntity *entity, cairo_t *cr)
 382 {
 383     AdgFillStyle *fill_style;
 384     const CpmlExtents *extents;
 385     AdgRuledFillPrivate *data;
 386     AdgStyle *line_style;
 387     cairo_pattern_t *pattern;
 388     cairo_surface_t *surface;
 389     CpmlPair spacing;
 390     cairo_t *context;
 391
 392     fill_style = (AdgFillStyle *) ruled_fill;
 393     extents = adg_fill_style_get_extents(fill_style);
 394
 395     /* Check for valid extents */
 396     if (!extents->is_defined)
 397         return NULL;
 398
 399     data = ruled_fill->data;
 400     line_style = adg_entity_style(entity, data->line_dress);
 401     surface = cairo_surface_create_similar(cairo_get_target(cr),
 402                                            CAIRO_CONTENT_COLOR_ALPHA,
 403                                            extents->size.x, extents->size.y);
 404     pattern = cairo_pattern_create_for_surface(surface);
 405
 406     /* The pattern holds a reference to the surface, so the
 407      * surface should be unreferenced once */
 408     cairo_surface_destroy(surface);
 409
 410     spacing.x = cos(data->angle) * data->spacing;
 411     spacing.y = sin(data->angle) * data->spacing;
 412
 413     context = cairo_create(surface);
 414     adg_style_apply(line_style, entity, context);
 415     draw_lines(&spacing, &extents->size, context);
 416     cairo_destroy(context);
 417
 418     return pattern;
 419 }
 420
 421 static void
 422 draw_lines(const CpmlPair *spacing, const CpmlPair *size, cairo_t *cr)
 423 {
 424     CpmlPair step, step1, step2;
 425     CpmlPair p1, p2;
 426
 427     /* There should be some sort of spacing and a destination area */
 428     if ((spacing->x == 0 && spacing->y == 0) ||
 429         (size->x <= 0 && size->y <= 0))
 430         return;
 431
 432     /* Revert spacings if needed to inspect only the x >= 0 cases */
 433     cpml_pair_copy(&step, spacing);
 434     if (spacing->x < 0 || (spacing->x == 0 && spacing->y < 0)) {
 435         step.x = -step.x;
 436         step.y = -step.y;
 437     }
 438
 439     p1.x = step.x / 2;
 440     p2.y = step.y / 2;
 441     p1.y = step.y == 0 ? p2.y : 0;
 442     p2.x = step.x == 0 ? p1.x : 0;
 443     if (step.y < 0) {
 444         p1.y += size->y;
 445         p2.y += size->y;
 446     }
 447
 448     step2.x = 0;
 449     step2.y = step.y;
 450
 451     if (step.x != 0) {
 452         step1.x = step.x;
 453         step1.y = 0;
 454
 455         while (p1.x < size->x) {
 456             if (p2.y <= 0 || p2.y >= size->y) {
 457                 step2.x = step.x;
 458                 step2.y = 0;
 459             }
 460             cairo_move_to(cr, p1.x, p1.y);
 461             cairo_line_to(cr, p2.x, p2.y);
 462             p1.x += step1.x;
 463             p1.y += step1.y;
 464             p2.x += step2.x;
 465             p2.y += step2.y;
 466         }
 467     }
 468
 469     if (step.y != 0) {
 470         step1.x = 0;
 471         step1.y = step.y;
 472
 473         while (p1.y >= 0 && p1.y <= size->y) {
 474             if (p2.y <= 0 || p2.y >= size->y) {
 475                 step2.x = step.x;
 476                 step2.y = 0;
 477             }
 478             cairo_move_to(cr, p1.x, p1.y);
 479             cairo_line_to(cr, p2.x, p2.y);
 480             p1.x += step1.x;
 481             p1.y += step1.y;
 482             p2.x += step2.x;
 483             p2.y += step2.y;
 484         }
 485     }
 486
 487     cairo_stroke(cr);
 488 }