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