src/adg/adg-arrow.c

   1 /* ADG - Automatic Drawing Generation
   2  * Copyright (C) 2007,2008,2009,2010,2011,2012,2013  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-arrow
  23  * @short_description: Arrow rendering related stuff
  24  *
  25  * Contains parameters on how to draw arrows, providing a way to register a
  26  * custom rendering callback.
  27  *
  28  * <note><para>
  29  * By default, the #AdgEntity:local-mix property is set to #ADG_MIX_PARENT
  30  * on #AdgArrow entities.
  31  * </para></note>
  32  *
  33  * Since: 1.0
  34  **/
  35
  36 /**
  37  * AdgArrow:
  38  *
  39  * All fields are private and should not be used directly.
  40  * Use its public methods instead.
  41  *
  42  * Since: 1.0
  43  **/
  44
  45
  46 #include "adg-internal.h"
  47 #include "adg-model.h"
  48 #include "adg-trail.h"
  49 #include "adg-path.h"
  50 #include "adg-marker.h"
  51 #include "adg-entity-private.h"
  52
  53 #include "adg-arrow.h"
  54 #include "adg-arrow-private.h"
  55
  56
  57 G_DEFINE_TYPE(AdgArrow, adg_arrow, ADG_TYPE_MARKER)
  58
  59 enum {
  60     PROP_0,
  61     PROP_ANGLE
  62 };
  63
  64
  65 static void             _adg_get_property       (GObject        *object,
  66                                                  guint           prop_id,
  67                                                  GValue         *value,
  68                                                  GParamSpec     *pspec);
  69 static void             _adg_set_property       (GObject        *object,
  70                                                  guint           prop_id,
  71                                                  const GValue   *value,
  72                                                  GParamSpec     *pspec);
  73 static void             _adg_arrange            (AdgEntity      *entity);
  74 static void             _adg_render             (AdgEntity      *entity,
  75                                                  cairo_t        *cr);
  76 static AdgModel *       _adg_create_model       (AdgMarker      *marker);
  77
  78
  79 static void
  80 adg_arrow_class_init(AdgArrowClass *klass)
  81 {
  82     GObjectClass *gobject_class;
  83     AdgEntityClass *entity_class;
  84     AdgMarkerClass *marker_class;
  85     GParamSpec *param;
  86
  87     gobject_class = (GObjectClass *) klass;
  88     entity_class = (AdgEntityClass *) klass;
  89     marker_class = (AdgMarkerClass *) klass;
  90
  91     g_type_class_add_private(klass, sizeof(AdgArrowPrivate));
  92
  93     gobject_class->set_property = _adg_set_property;
  94     gobject_class->get_property = _adg_get_property;
  95
  96     entity_class->arrange = _adg_arrange;
  97     entity_class->render = _adg_render;
  98
  99     marker_class->create_model = _adg_create_model;
 100
 101     param = g_param_spec_double("angle",
 102                                 P_("Arrow Angle"),
 103                                 P_("The opening angle of the arrow"),
 104                                 -G_PI, G_PI, G_PI / 6,
 105                                 G_PARAM_READWRITE);
 106     g_object_class_install_property(gobject_class, PROP_ANGLE, param);
 107 }
 108
 109 static void
 110 adg_arrow_init(AdgArrow *arrow)
 111 {
 112     AdgArrowPrivate *data = G_TYPE_INSTANCE_GET_PRIVATE(arrow,
 113                                                         ADG_TYPE_ARROW,
 114                                                         AdgArrowPrivate);
 115     AdgEntityPrivate *entity_data = ((AdgEntity *) arrow)->data;
 116
 117     data->angle = G_PI/6;
 118
 119     arrow->data = data;
 120
 121     /* Initialize to custom default some AdgEntity field by directly
 122      * accessing the private struct to avoid notify signal emissions
 123      */
 124     entity_data->local_mix = ADG_MIX_PARENT;
 125 }
 126
 127 static void
 128 _adg_get_property(GObject *object, guint prop_id,
 129                   GValue *value, GParamSpec *pspec)
 130 {
 131     AdgArrowPrivate *data = ((AdgArrow *) object)->data;
 132
 133     switch (prop_id) {
 134     case PROP_ANGLE:
 135         g_value_set_double(value, data->angle);
 136         break;
 137     default:
 138         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
 139         break;
 140     }
 141 }
 142
 143 static void
 144 _adg_set_property(GObject *object, guint prop_id,
 145                   const GValue *value, GParamSpec *pspec)
 146 {
 147     AdgArrowPrivate *data = ((AdgArrow *) object)->data;
 148
 149     switch (prop_id) {
 150     case PROP_ANGLE:
 151         data->angle = cpml_angle(g_value_get_double(value));
 152         break;
 153     default:
 154         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
 155         break;
 156     }
 157 }
 158
 159
 160 /**
 161  * adg_arrow_new:
 162  *
 163  * Creates a new undefined arrow entity. The position must be defined
 164  * by setting the #AdgMarker:trail and #AdgMarker:pos properties.
 165  *
 166  * Returns: the newly created arrow entity
 167  *
 168  * Since: 1.0
 169  **/
 170 AdgArrow *
 171 adg_arrow_new(void)
 172 {
 173     return g_object_new(ADG_TYPE_ARROW, NULL);
 174 }
 175
 176 /**
 177  * adg_arrow_new_with_trail:
 178  * @trail: the #AdgTrail where the arrow should be added
 179  * @pos: the position ratio on @trail
 180  *
 181  * Creates a new arrow on the first segment on @trail at position
 182  * @pos, where @pos is a ratio of the @trail length (being %0 the
 183  * start point, %1 the end point, %0.5 the middle point and so on).
 184  * By default, an arrow as #AdgEntity:local-mix set to #ADG_MIX_PARENT.
 185  *
 186  * Returns: the newly created arrow entity
 187  *
 188  * Since: 1.0
 189  **/
 190 AdgArrow *
 191 adg_arrow_new_with_trail(AdgTrail *trail, gdouble pos)
 192 {
 193     return g_object_new(ADG_TYPE_ARROW,
 194                         "local-mix", ADG_MIX_PARENT,
 195                         "trail", trail,
 196                         "n-segment", 1,
 197                         "pos", pos,
 198                         NULL);
 199 }
 200
 201 /**
 202  * adg_arrow_set_angle:
 203  * @arrow: an #AdgArrow
 204  * @angle: the new angle
 205  *
 206  * Sets a new angle: @angle will be the new opening angle of @arrow.
 207  * Changing the arrow angle will invalidate @arrow.
 208  *
 209  * Since: 1.0
 210  **/
 211 void
 212 adg_arrow_set_angle(AdgArrow *arrow, gdouble angle)
 213 {
 214     g_return_if_fail(ADG_IS_ARROW(arrow));
 215     g_object_set(arrow, "angle", angle, NULL);
 216 }
 217
 218 /**
 219  * adg_arrow_get_angle:
 220  * @arrow: an #AdgArrow
 221  *
 222  * Gets the current angle of @arrow.
 223  *
 224  * Returns: the arrow angle, in radians
 225  *
 226  * Since: 1.0
 227  **/
 228 gdouble
 229 adg_arrow_get_angle(AdgArrow *arrow)
 230 {
 231     AdgArrowPrivate *data;
 232
 233     g_return_val_if_fail(ADG_IS_ARROW(arrow), 0);
 234
 235     data = arrow->data;
 236
 237     return data->angle;
 238 }
 239
 240
 241 static void
 242 _adg_arrange(AdgEntity *entity)
 243 {
 244     AdgModel *model;
 245     const CpmlExtents *extents;
 246     CpmlExtents new_extents;
 247
 248     model = adg_marker_model((AdgMarker *) entity);
 249     if (model == NULL)
 250         return;
 251
 252     extents = adg_trail_get_extents((AdgTrail *) model);
 253     if (extents == NULL)
 254         return;
 255
 256     cpml_extents_copy(&new_extents, extents);
 257     cpml_extents_transform(&new_extents, adg_entity_get_local_matrix(entity));
 258     adg_entity_set_extents(entity, &new_extents);
 259 }
 260
 261 static void
 262 _adg_render(AdgEntity *entity, cairo_t *cr)
 263 {
 264     AdgModel *model;
 265     const cairo_path_t *cairo_path;
 266
 267     model = adg_marker_model((AdgMarker *) entity);
 268     if (model == NULL)
 269         return;
 270
 271     cairo_path = adg_trail_get_cairo_path((AdgTrail *) model);
 272
 273     if (cairo_path != NULL) {
 274         cairo_save(cr);
 275         cairo_transform(cr, adg_entity_get_global_matrix(entity));
 276         cairo_transform(cr, adg_entity_get_local_matrix(entity));
 277         cairo_append_path(cr, cairo_path);
 278         cairo_restore(cr);
 279
 280         cairo_fill(cr);
 281     }
 282 }
 283
 284 static AdgModel *
 285 _adg_create_model(AdgMarker *marker)
 286 {
 287     AdgArrowPrivate *data;
 288     AdgPath *path;
 289     CpmlPair p1, p2;
 290
 291     data = ((AdgArrow *) marker)->data;
 292     path = adg_path_new();
 293     cpml_vector_from_angle(&p1, data->angle / 2);
 294     p2.x = p1.x;
 295     p2.y = -p1.y;
 296
 297     adg_path_move_to_explicit(path, 0, 0);
 298     adg_path_line_to(path, &p1);
 299     adg_path_line_to(path, &p2);
 300     adg_path_close(path);
 301
 302     return (AdgModel *) path;
 303 }