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