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_TRAIL
  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 set_trail               (AdgStroke      *stroke,
  59                                          AdgTrail       *trail);
  60 static void     unset_trail             (AdgStroke      *stroke);
  61 static gboolean render                  (AdgEntity      *entity,
  62                                          cairo_t        *cr);
  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 = g_param_spec_object("trail",
  87                                 P_("Trail"),
  88                                 P_("The trail to be stroked"),
  89                                 ADG_TYPE_TRAIL,
  90                                 G_PARAM_CONSTRUCT|G_PARAM_READWRITE);
  91     g_object_class_install_property(gobject_class, PROP_TRAIL, param);
  92 }
  93
  94 static void
  95 adg_stroke_init(AdgStroke *stroke)
  96 {
  97     AdgStrokePrivate *data = G_TYPE_INSTANCE_GET_PRIVATE(stroke,
  98                                                          ADG_TYPE_STROKE,
  99                                                          AdgStrokePrivate);
 100
 101     data->trail = NULL;
 102
 103     stroke->data = data;
 104 }
 105
 106 static void
 107 dispose(GObject *object)
 108 {
 109     adg_stroke_set_trail((AdgStroke *) object, NULL);
 110
 111     if (PARENT_OBJECT_CLASS->dispose != NULL)
 112         PARENT_OBJECT_CLASS->dispose(object);
 113 }
 114
 115 static void
 116 get_property(GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
 117 {
 118     AdgStrokePrivate *data = ((AdgStroke *) object)->data;
 119
 120     switch (prop_id) {
 121     case PROP_TRAIL:
 122         g_value_set_object(value, &data->trail);
 123         break;
 124     default:
 125         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
 126         break;
 127     }
 128 }
 129
 130 static void
 131 set_property(GObject *object, guint prop_id,
 132              const GValue *value, GParamSpec *pspec)
 133 {
 134     AdgStroke *stroke = (AdgStroke *) object;
 135
 136     switch (prop_id) {
 137     case PROP_TRAIL:
 138         set_trail(stroke, (AdgTrail *) g_value_get_object(value));
 139         break;
 140     default:
 141         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
 142         break;
 143     }
 144 }
 145
 146
 147 /**
 148  * adg_stroke_new:
 149  * @trail: the #AdgTrail to stroke
 150  *
 151  * Creates a new stroke entity.
 152  *
 153  * Returns: the newly created stroke entity
 154  **/
 155 AdgStroke *
 156 adg_stroke_new(AdgTrail *trail)
 157 {
 158     g_return_val_if_fail(ADG_IS_TRAIL(trail), NULL);
 159
 160     return g_object_new(ADG_TYPE_STROKE, "trail", trail, NULL);
 161 }
 162
 163
 164 /**
 165  * adg_stroke_get_trail:
 166  * @stroke: an #AdgStroke
 167  *
 168  * Gets the #AdgTrail binded to this @stroke entity.
 169  *
 170  * Returns: the requested #AdgTrail or %NULL on errors
 171  **/
 172 AdgTrail *
 173 adg_stroke_get_trail(AdgStroke *stroke)
 174 {
 175     AdgStrokePrivate *data;
 176
 177     g_return_val_if_fail(ADG_IS_STROKE(stroke), NULL);
 178
 179     data = stroke->data;
 180
 181     return data->trail;
 182 }
 183
 184 /**
 185  * adg_stroke_set_trail:
 186  * @stroke: an #AdgStroke
 187  * @trail: the new #AdgTrail to bind
 188  *
 189  * Sets @trail as the new trail to be stroked by @stroke.
 190  **/
 191 void
 192 adg_stroke_set_trail(AdgStroke *stroke, AdgTrail *trail)
 193 {
 194     g_return_if_fail(ADG_IS_STROKE(stroke));
 195
 196     if (set_trail(stroke, trail))
 197         g_object_notify((GObject *) stroke, "trail");
 198 }
 199
 200
 201 static gboolean
 202 set_trail(AdgStroke *stroke, AdgTrail *trail)
 203 {
 204     AdgEntity *entity;
 205     AdgStrokePrivate *data;
 206
 207     entity = (AdgEntity *) stroke;
 208     data = stroke->data;
 209
 210     if (trail == data->trail)
 211         return FALSE;
 212
 213     if (data->trail != NULL) {
 214         g_object_weak_unref((GObject *) data->trail,
 215                             (GWeakNotify) unset_trail, stroke);
 216         adg_model_remove_dependency((AdgModel *) data->trail, entity);
 217     }
 218
 219     data->trail = trail;
 220
 221     if (data->trail != NULL) {
 222         g_object_weak_ref((GObject *) data->trail,
 223                           (GWeakNotify) unset_trail, stroke);
 224         adg_model_add_dependency((AdgModel *) data->trail, entity);
 225     }
 226
 227     return TRUE;
 228 }
 229
 230 static void
 231 unset_trail(AdgStroke *stroke)
 232 {
 233     AdgStrokePrivate *data = stroke->data;
 234
 235     if (data->trail != NULL) {
 236         data->trail = NULL;
 237         adg_entity_invalidate((AdgEntity *) stroke);
 238     }
 239 }
 240
 241 static gboolean
 242 render(AdgEntity *entity, cairo_t *cr)
 243 {
 244     AdgStroke *stroke;
 245     AdgStrokePrivate *data;
 246     const cairo_path_t *cairo_path;
 247
 248     stroke = (AdgStroke *) entity;
 249     data = stroke->data;
 250     cairo_path = adg_trail_get_cairo_path(data->trail);
 251
 252     if (cairo_path != NULL) {
 253         cairo_save(cr);
 254         adg_entity_apply_local_matrix(entity, cr);
 255         cairo_append_path(cr, cairo_path);
 256         cairo_restore(cr);
 257
 258         adg_entity_apply(entity, ADG_SLOT_LINE_STYLE, cr);
 259         cairo_stroke(cr);
 260     }
 261
 262     return TRUE;
 263 }