src/adg/adg-stroke.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-stroke
  23  * @short_description: A stroked entity
  24  *
  25  * The #AdgStroke object is a stroked representation of an #AdgTrail model.
  26  **/
  27
  28 /**
  29  * AdgStroke:
  30  *
  31  * All fields are private and should not be used directly.
  32  * Use its public methods instead.
  33  **/
  34
  35
  36 #include "adg-internal.h"
  37 #include "adg-stroke.h"
  38 #include "adg-stroke-private.h"
  39 #include "adg-dress-builtins.h"
  40 #include "adg-line-style.h"
  41
  42 #define PARENT_OBJECT_CLASS  ((GObjectClass *) adg_stroke_parent_class)
  43 #define PARENT_ENTITY_CLASS  ((AdgEntityClass *) adg_stroke_parent_class)
  44
  45
  46 enum {
  47     PROP_0,
  48     PROP_LINE_DRESS,
  49     PROP_TRAIL
  50 };
  51
  52 static void             dispose                 (GObject        *object);
  53 static void             get_property            (GObject        *object,
  54                                                  guint           param_id,
  55                                                  GValue         *value,
  56                                                  GParamSpec     *pspec);
  57 static void             set_property            (GObject        *object,
  58                                                  guint           param_id,
  59                                                  const GValue   *value,
  60                                                  GParamSpec     *pspec);
  61 static void             global_changed          (AdgEntity      *entity);
  62 static void             local_changed           (AdgEntity      *entity);
  63 static void             arrange                 (AdgEntity      *entity);
  64 static void             render                  (AdgEntity      *entity,
  65                                                  cairo_t        *cr);
  66 static gboolean         set_trail               (AdgStroke      *stroke,
  67                                                  AdgTrail       *trail);
  68 static void             unset_trail             (AdgStroke      *stroke);
  69
  70
  71 G_DEFINE_TYPE(AdgStroke, adg_stroke, ADG_TYPE_ENTITY);
  72
  73
  74 static void
  75 adg_stroke_class_init(AdgStrokeClass *klass)
  76 {
  77     GObjectClass *gobject_class;
  78     AdgEntityClass *entity_class;
  79     GParamSpec *param;
  80
  81     gobject_class = (GObjectClass *) klass;
  82     entity_class = (AdgEntityClass *) klass;
  83
  84     g_type_class_add_private(klass, sizeof(AdgStrokePrivate));
  85
  86     gobject_class->dispose = dispose;
  87     gobject_class->get_property = get_property;
  88     gobject_class->set_property = set_property;
  89
  90     entity_class->global_changed = global_changed;
  91     entity_class->local_changed = local_changed;
  92     entity_class->arrange = arrange;
  93     entity_class->render = render;
  94
  95     param = adg_param_spec_dress("line-dress",
  96                                  P_("Line Dress"),
  97                                  P_("The dress to use for stroking this entity"),
  98                                  ADG_DRESS_LINE_STROKE,
  99                                  G_PARAM_READWRITE);
 100     g_object_class_install_property(gobject_class, PROP_LINE_DRESS, param);
 101
 102     param = g_param_spec_object("trail",
 103                                 P_("Trail"),
 104                                 P_("The trail to be stroked"),
 105                                 ADG_TYPE_TRAIL,
 106                                 G_PARAM_READWRITE | G_PARAM_CONSTRUCT);
 107     g_object_class_install_property(gobject_class, PROP_TRAIL, param);
 108 }
 109
 110 static void
 111 adg_stroke_init(AdgStroke *stroke)
 112 {
 113     AdgStrokePrivate *data = G_TYPE_INSTANCE_GET_PRIVATE(stroke,
 114                                                          ADG_TYPE_STROKE,
 115                                                          AdgStrokePrivate);
 116
 117     data->line_dress = ADG_DRESS_LINE_STROKE;
 118     data->trail = NULL;
 119
 120     stroke->data = data;
 121 }
 122
 123 static void
 124 dispose(GObject *object)
 125 {
 126     AdgStroke *stroke = (AdgStroke *) object;
 127
 128     adg_stroke_set_trail(stroke, NULL);
 129
 130     if (PARENT_OBJECT_CLASS->dispose)
 131         PARENT_OBJECT_CLASS->dispose(object);
 132 }
 133
 134 static void
 135 get_property(GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
 136 {
 137     AdgStrokePrivate *data = ((AdgStroke *) object)->data;
 138
 139     switch (prop_id) {
 140     case PROP_LINE_DRESS:
 141         g_value_set_int(value, data->line_dress);
 142         break;
 143     case PROP_TRAIL:
 144         g_value_set_object(value, data->trail);
 145         break;
 146     default:
 147         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
 148         break;
 149     }
 150 }
 151
 152 static void
 153 set_property(GObject *object, guint prop_id,
 154              const GValue *value, GParamSpec *pspec)
 155 {
 156     AdgStroke *stroke;
 157     AdgStrokePrivate *data;
 158
 159     stroke = (AdgStroke *) object;
 160     data = stroke->data;
 161
 162     switch (prop_id) {
 163     case PROP_LINE_DRESS:
 164         adg_dress_set(&data->line_dress, g_value_get_int(value));
 165         break;
 166     case PROP_TRAIL:
 167         set_trail(stroke, (AdgTrail *) g_value_get_object(value));
 168         break;
 169     default:
 170         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
 171         break;
 172     }
 173 }
 174
 175
 176 /**
 177  * adg_stroke_new:
 178  * @trail: the #AdgTrail to stroke
 179  *
 180  * Creates a new stroke entity based on the @trail model.
 181  * @trail can be %NULL, in which case an empty stroke is created.
 182  *
 183  * Returns: the newly created stroke entity
 184  **/
 185 AdgStroke *
 186 adg_stroke_new(AdgTrail *trail)
 187 {
 188     return g_object_new(ADG_TYPE_STROKE, "trail", trail, NULL);
 189 }
 190
 191 /**
 192  * adg_stroke_set_line_dress:
 193  * @stroke: an #AdgStroke
 194  * @dress: the new #AdgDress to use
 195  *
 196  * Sets a new line dress for rendering @stroke. The new dress
 197  * must be related to the original dress for this property:
 198  * you cannot set a dress used for line styles to a dress
 199  * managing fonts.
 200  *
 201  * The check is done by calling adg_dress_are_related() with
 202  * @dress and the previous dress as arguments. Check out its
 203  * documentation for details on what is a related dress.
 204  **/
 205 void
 206 adg_stroke_set_line_dress(AdgStroke *stroke, AdgDress dress)
 207 {
 208     AdgStrokePrivate *data;
 209
 210     g_return_if_fail(ADG_IS_STROKE(stroke));
 211
 212     data = stroke->data;
 213
 214     if (adg_dress_set(&data->line_dress, dress))
 215         g_object_notify((GObject *) stroke, "line-dress");
 216 }
 217
 218 /**
 219  * adg_stroke_get_line_dress:
 220  * @stroke: an #AdgStroke
 221  *
 222  * Gets the line dress to be used in rendering @stroke.
 223  *
 224  * Returns: the current line dress
 225  **/
 226 AdgDress
 227 adg_stroke_get_line_dress(AdgStroke *stroke)
 228 {
 229     AdgStrokePrivate *data;
 230
 231     g_return_val_if_fail(ADG_IS_STROKE(stroke), ADG_DRESS_UNDEFINED);
 232
 233     data = stroke->data;
 234
 235     return data->line_dress;
 236 }
 237
 238 /**
 239  * adg_stroke_set_trail:
 240  * @stroke: an #AdgStroke
 241  * @trail: the new #AdgTrail to bind
 242  *
 243  * Sets @trail as the new trail to be stroked by @stroke.
 244  **/
 245 void
 246 adg_stroke_set_trail(AdgStroke *stroke, AdgTrail *trail)
 247 {
 248     g_return_if_fail(ADG_IS_STROKE(stroke));
 249
 250     if (set_trail(stroke, trail))
 251         g_object_notify((GObject *) stroke, "trail");
 252 }
 253
 254 /**
 255  * adg_stroke_get_trail:
 256  * @stroke: an #AdgStroke
 257  *
 258  * Gets the #AdgTrail bound to this @stroke entity.
 259  *
 260  * Returns: the requested #AdgTrail or %NULL on errors
 261  **/
 262 AdgTrail *
 263 adg_stroke_get_trail(AdgStroke *stroke)
 264 {
 265     AdgStrokePrivate *data;
 266
 267     g_return_val_if_fail(ADG_IS_STROKE(stroke), NULL);
 268
 269     data = stroke->data;
 270
 271     return data->trail;
 272 }
 273
 274
 275 static void
 276 global_changed(AdgEntity *entity)
 277 {
 278     if (PARENT_ENTITY_CLASS->global_changed)
 279         PARENT_ENTITY_CLASS->global_changed(entity);
 280
 281     adg_entity_invalidate(entity);
 282 }
 283
 284 static void
 285 local_changed(AdgEntity *entity)
 286 {
 287     if (PARENT_ENTITY_CLASS->local_changed)
 288         PARENT_ENTITY_CLASS->local_changed(entity);
 289
 290     adg_entity_invalidate(entity);
 291 }
 292
 293 static void
 294 arrange(AdgEntity *entity)
 295 {
 296     AdgStroke *stroke;
 297     AdgStrokePrivate *data;
 298     CpmlExtents extents;
 299
 300     /* Check for cached result */
 301     if (adg_entity_get_extents(entity)->is_defined)
 302         return;
 303
 304     stroke = (AdgStroke *) entity;
 305     data = stroke->data;
 306
 307     cpml_extents_copy(&extents, adg_trail_get_extents(data->trail));
 308     cpml_extents_transform(&extents, adg_entity_get_local_matrix(entity));
 309     cpml_extents_transform(&extents, adg_entity_get_global_matrix(entity));
 310
 311     adg_entity_set_extents(entity, &extents);
 312 }
 313
 314 static void
 315 render(AdgEntity *entity, cairo_t *cr)
 316 {
 317     AdgStroke *stroke;
 318     AdgStrokePrivate *data;
 319     const cairo_path_t *cairo_path;
 320
 321     stroke = (AdgStroke *) entity;
 322     data = stroke->data;
 323     cairo_path = adg_trail_get_cairo_path(data->trail);
 324
 325     if (cairo_path != NULL) {
 326         cairo_save(cr);
 327         cairo_transform(cr, adg_entity_get_local_matrix(entity));
 328         cairo_append_path(cr, cairo_path);
 329         cairo_restore(cr);
 330
 331         adg_entity_apply_dress(entity, data->line_dress, cr);
 332         cairo_stroke(cr);
 333     }
 334 }
 335
 336 static gboolean
 337 set_trail(AdgStroke *stroke, AdgTrail *trail)
 338 {
 339     AdgEntity *entity;
 340     AdgStrokePrivate *data;
 341
 342     g_return_val_if_fail(trail == NULL || ADG_IS_TRAIL(trail), FALSE);
 343
 344     entity = (AdgEntity *) stroke;
 345     data = stroke->data;
 346
 347     if (trail == data->trail)
 348         return FALSE;
 349
 350     if (data->trail != NULL) {
 351         g_object_weak_unref((GObject *) data->trail,
 352                             (GWeakNotify) unset_trail, stroke);
 353         adg_model_remove_dependency((AdgModel *) data->trail, entity);
 354     }
 355
 356     data->trail = trail;
 357
 358     if (data->trail != NULL) {
 359         g_object_weak_ref((GObject *) data->trail,
 360                           (GWeakNotify) unset_trail, stroke);
 361         adg_model_add_dependency((AdgModel *) data->trail, entity);
 362     }
 363
 364     return TRUE;
 365 }
 366
 367 static void
 368 unset_trail(AdgStroke *stroke)
 369 {
 370     AdgStrokePrivate *data = stroke->data;
 371
 372     if (data->trail != NULL)
 373         set_trail(stroke, NULL);
 374 }