adg/adg-marker.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-marker
  23  * @short_description: Base entity for markers
  24  *
  25  * A marker is an entity to be applied at the start or end of a segment.
  26  * Typical examples include arrows, ticks, dots and so on.
  27  **/
  28
  29 /**
  30  * AdgMarker:
  31  *
  32  * All fields are privates and should not be used directly.
  33  * Use its public methods instead.
  34  **/
  35
  36
  37 #include "adg-marker.h"
  38 #include "adg-marker-private.h"
  39 #include "adg-intl.h"
  40
  41
  42 enum {
  43     PROP_0,
  44     PROP_SIZE,
  45     PROP_ANGLE,
  46     PROP_MARGIN
  47 };
  48
  49
  50 static void     get_property            (GObject        *object,
  51                                          guint           prop_id,
  52                                          GValue         *value,
  53                                          GParamSpec     *pspec);
  54 static void     set_property            (GObject        *object,
  55                                          guint           prop_id,
  56                                          const GValue   *value,
  57                                          GParamSpec     *pspec);
  58 static gboolean set_size                (AdgMarker      *marker,
  59                                          gdouble         size);
  60 static gboolean set_angle               (AdgMarker      *marker,
  61                                          gdouble         angle);
  62 static gboolean set_margin              (AdgMarker      *marker,
  63                                          gdouble         margin);
  64
  65
  66 G_DEFINE_ABSTRACT_TYPE(AdgMarker, adg_marker, ADG_TYPE_ENTITY);
  67
  68
  69 static void
  70 adg_marker_class_init(AdgMarkerClass *klass)
  71 {
  72     GObjectClass *gobject_class;
  73     GParamSpec *param;
  74
  75     gobject_class = (GObjectClass *) klass;
  76
  77     g_type_class_add_private(klass, sizeof(AdgMarkerPrivate));
  78
  79     gobject_class->set_property = set_property;
  80     gobject_class->get_property = get_property;
  81
  82     param = g_param_spec_double("size",
  83                                 P_("Marker Size"),
  84                                 P_("The size (in global space) of the marker"),
  85                                 0, G_MAXDOUBLE, 12,
  86                                 G_PARAM_READWRITE);
  87     g_object_class_install_property(gobject_class, PROP_SIZE, param);
  88
  89     param = g_param_spec_double("angle",
  90                                 P_("Marker Angle"),
  91                                 P_("The tip or rotation angle of the marker"),
  92                                 -G_MAXDOUBLE, G_MAXDOUBLE, 0,
  93                                 G_PARAM_READWRITE);
  94     g_object_class_install_property(gobject_class, PROP_ANGLE, param);
  95
  96     param = g_param_spec_double("margin",
  97                                 P_("Margin"),
  98                                 P_("The margin around the marker, in global space: left to 0 means to use the default value (implementation dependent)"),
  99                                 -G_MAXDOUBLE, G_MAXDOUBLE, 0,
 100                                 G_PARAM_READWRITE);
 101     g_object_class_install_property(gobject_class, PROP_MARGIN, param);
 102 }
 103
 104 static void
 105 adg_marker_init(AdgMarker *marker)
 106 {
 107     AdgMarkerPrivate *data = G_TYPE_INSTANCE_GET_PRIVATE(marker,
 108                                                          ADG_TYPE_MARKER,
 109                                                          AdgMarkerPrivate);
 110     data->size = 10;
 111     data->angle = 0;
 112     data->margin = 0;
 113
 114     marker->data = data;
 115 }
 116
 117
 118 static void
 119 get_property(GObject *object,
 120              guint prop_id, GValue *value, GParamSpec *pspec)
 121 {
 122     AdgMarkerPrivate *data = ((AdgMarker *) object)->data;
 123
 124     switch (prop_id) {
 125     case PROP_SIZE:
 126         g_value_set_double(value, data->size);
 127         break;
 128     case PROP_ANGLE:
 129         g_value_set_double(value, data->angle);
 130         break;
 131     case PROP_MARGIN:
 132         g_value_set_double(value, data->margin);
 133         break;
 134     default:
 135         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
 136         break;
 137     }
 138 }
 139
 140 static void
 141 set_property(GObject *object,
 142              guint prop_id, const GValue *value, GParamSpec *pspec)
 143 {
 144     AdgMarker *marker = (AdgMarker *) object;
 145
 146     switch (prop_id) {
 147     case PROP_SIZE:
 148         set_size(marker, g_value_get_double(value));
 149         break;
 150     case PROP_ANGLE:
 151         set_angle(marker, g_value_get_double(value));
 152         break;
 153     case PROP_MARGIN:
 154         set_margin(marker, g_value_get_double(value));
 155         break;
 156     default:
 157         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
 158         break;
 159     }
 160 }
 161
 162
 163 /**
 164  * adg_marker_get_size:
 165  * @marker: an #AdgMarker
 166  *
 167  * Gets the current size of @marker.
 168  *
 169  * Returns: the marker size, in global space
 170  **/
 171 gdouble
 172 adg_marker_get_size(AdgMarker *marker)
 173 {
 174     AdgMarkerPrivate *data;
 175
 176     g_return_val_if_fail(ADG_IS_MARKER(marker), 0);
 177
 178     data = marker->data;
 179
 180     return data->size;
 181 }
 182
 183 /**
 184  * adg_marker_set_size:
 185  * @marker: an #AdgMarker
 186  * @size: the new size
 187  *
 188  * Sets a new size on @marker. The @size is an implementation-dependent
 189  * property: it has meaning only when used by an #AdgMarker derived type.
 190  **/
 191 void
 192 adg_marker_set_size(AdgMarker *marker, gdouble size)
 193 {
 194     g_return_if_fail(ADG_IS_MARKER(marker));
 195
 196     if (set_size(marker, size))
 197         g_object_notify((GObject *) marker, "size");
 198 }
 199
 200 /**
 201  * adg_marker_get_angle:
 202  * @marker: an #AdgMarker
 203  *
 204  * Gets the current angle of @marker.
 205  *
 206  * Returns: the marker angle, in radians
 207  **/
 208 gdouble
 209 adg_marker_get_angle(AdgMarker *marker)
 210 {
 211     AdgMarkerPrivate *data;
 212
 213     g_return_val_if_fail(ADG_IS_MARKER(marker), 0);
 214
 215     data = marker->data;
 216
 217     return data->angle;
 218 }
 219
 220 /**
 221  * adg_marker_set_angle:
 222  * @marker: an #AdgMarker
 223  * @angle: the new angle
 224  *
 225  * Sets a new angle on @marker. The @angle is an implementation-dependent
 226  * property: it has meaning only when used by an #AdgMarker derived type.
 227  **/
 228 void
 229 adg_marker_set_angle(AdgMarker *marker, gdouble angle)
 230 {
 231     g_return_if_fail(ADG_IS_MARKER(marker));
 232
 233     if (set_angle(marker, angle))
 234         g_object_notify((GObject *) marker, "angle");
 235 }
 236
 237 /**
 238  * adg_marker_get_margin:
 239  * @marker: an #AdgMarker
 240  *
 241  * Gets the current margin of @marker.
 242  *
 243  * Returns: the marker margin, in global space
 244  **/
 245 gdouble
 246 adg_marker_get_margin(AdgMarker *marker)
 247 {
 248     AdgMarkerPrivate *data;
 249
 250     g_return_val_if_fail(ADG_IS_MARKER(marker), 0);
 251
 252     data = marker->data;
 253
 254     return data->margin;
 255 }
 256
 257 /**
 258  * adg_marker_set_margin:
 259  * @marker: an #AdgMarker
 260  * @margin: the new margin
 261  *
 262  * Sets a new margin on @marker. The @margin is an implementation-dependent
 263  * property: it has meaning only when used by an #AdgMarker derived type.
 264  **/
 265 void
 266 adg_marker_set_margin(AdgMarker *marker, gdouble margin)
 267 {
 268     g_return_if_fail(ADG_IS_MARKER(marker));
 269
 270     if (set_margin(marker, margin))
 271         g_object_notify((GObject *) marker, "margin");
 272 }
 273
 274
 275 static gboolean
 276 set_size(AdgMarker *marker, gdouble size)
 277 {
 278     AdgMarkerPrivate *data = marker->data;
 279
 280     if (size == data->size)
 281         return FALSE;
 282
 283     data->size = size;
 284
 285     return TRUE;
 286 }
 287
 288 static gboolean
 289 set_angle(AdgMarker *marker, gdouble angle)
 290 {
 291     AdgMarkerPrivate *data = marker->data;
 292
 293     if (angle == data->angle)
 294         return FALSE;
 295
 296     data->angle = angle;
 297
 298     return TRUE;
 299 }
 300
 301 static gboolean
 302 set_margin(AdgMarker *marker, gdouble margin)
 303 {
 304     AdgMarkerPrivate *data = marker->data;
 305
 306     if (margin == data->margin)
 307         return FALSE;
 308
 309     data->margin = margin;
 310
 311     return TRUE;
 312 }