adg/adg-adim.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-adim
  23  * @short_description: Angular dimensions
  24  *
  25  * The #AdgADim entity represents an angular dimension.
  26  */
  27
  28 /**
  29  * AdgADim:
  30  *
  31  * All fields are privates and should not be used directly.
  32  * Use its public methods instead.
  33  **/
  34
  35
  36 #include "adg-adim.h"
  37 #include "adg-adim-private.h"
  38 #include "adg-container.h"
  39 #include "adg-intl.h"
  40
  41
  42 enum {
  43     PROP_0,
  44     PROP_ANGLE1,
  45     PROP_ANGLE2
  46 };
  47
  48
  49 static void     finalize                (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 gchar *  default_value           (AdgDim         *dim);
  61 static void     set_angle1              (AdgADim        *adim,
  62                                          gdouble         angle);
  63 static void     set_angle2              (AdgADim        *adim,
  64                                          gdouble         angle2);
  65
  66
  67 G_DEFINE_TYPE(AdgADim, adg_adim, ADG_TYPE_DIM);
  68
  69
  70 static void
  71 adg_adim_class_init(AdgADimClass *klass)
  72 {
  73     GObjectClass *gobject_class;
  74     AdgEntityClass *entity_class;
  75     AdgDimClass *dim_class;
  76     GParamSpec *param;
  77
  78     gobject_class = (GObjectClass *) klass;
  79     entity_class = (AdgEntityClass *) klass;
  80     dim_class = (AdgDimClass *) klass;
  81
  82     g_type_class_add_private(klass, sizeof(AdgADimPrivate));
  83
  84     gobject_class->finalize = finalize;
  85     gobject_class->get_property = get_property;
  86     gobject_class->set_property = set_property;
  87
  88     entity_class->render = render;
  89
  90     dim_class->default_value = default_value;
  91
  92     param = g_param_spec_double("angle1",
  93                                 P_("Angle 1"),
  94                                 P_("Angle of the first reference line"),
  95                                 -G_MAXDOUBLE, G_MAXDOUBLE, 0,
  96                                 G_PARAM_READWRITE);
  97     g_object_class_install_property(gobject_class, PROP_ANGLE1, param);
  98
  99     param = g_param_spec_double("angle2",
 100                                 P_("Angle 2"),
 101                                 P_("Angle of the second reference line"),
 102                                 -G_MAXDOUBLE, G_MAXDOUBLE, 0,
 103                                 G_PARAM_READWRITE);
 104     g_object_class_install_property(gobject_class, PROP_ANGLE2, param);
 105 }
 106
 107 static void
 108 adg_adim_init(AdgADim *adim)
 109 {
 110     AdgADimPrivate *data = G_TYPE_INSTANCE_GET_PRIVATE(adim, ADG_TYPE_ADIM,
 111                                                        AdgADimPrivate);
 112
 113     data->extension1.status = CAIRO_STATUS_SUCCESS;
 114     data->extension1.data = NULL;
 115     data->extension1.num_data = 4;
 116
 117     data->extension2.status = CAIRO_STATUS_SUCCESS;
 118     data->extension2.data = NULL;
 119     data->extension2.num_data = 4;
 120
 121     data->arrow_path.status = CAIRO_STATUS_SUCCESS;
 122     data->arrow_path.data = NULL;
 123     data->arrow_path.num_data = 4;
 124
 125     data->baseline.status = CAIRO_STATUS_SUCCESS;
 126     data->baseline.data = NULL;
 127     data->baseline.num_data = 4;
 128
 129     adim->data = data;
 130 }
 131
 132 static void
 133 finalize(GObject *object)
 134 {
 135     AdgADimPrivate *data = ((AdgADim *) object)->data;
 136
 137     g_free(data->extension1.data);
 138     g_free(data->extension2.data);
 139     g_free(data->arrow_path.data);
 140     g_free(data->baseline.data);
 141 }
 142
 143 static void
 144 get_property(GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
 145 {
 146     AdgADimPrivate *data = ((AdgADim *) object)->data;
 147
 148     switch (prop_id) {
 149     case PROP_ANGLE1:
 150         g_value_set_double(value, data->angle1);
 151         break;
 152     case PROP_ANGLE2:
 153         g_value_set_double(value, data->angle2);
 154         break;
 155     default:
 156         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
 157         break;
 158     }
 159 }
 160
 161 static void
 162 set_property(GObject *object, guint prop_id,
 163              const GValue *value, GParamSpec *pspec)
 164 {
 165     AdgADim *adim = (AdgADim *) object;
 166
 167     switch (prop_id) {
 168     case PROP_ANGLE1:
 169         set_angle1(adim, g_value_get_double(value));
 170         break;
 171     case PROP_ANGLE2:
 172         set_angle2(adim, g_value_get_double(value));
 173         break;
 174     default:
 175         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
 176         break;
 177     }
 178 }
 179
 180 static gboolean
 181 render(AdgEntity *entity, cairo_t *cr)
 182 {
 183     /* TODO */
 184     return FALSE;
 185 }
 186
 187 static gchar *
 188 default_value(AdgDim *dim)
 189 {
 190     /* TODO */
 191     return g_strdup("TODO");
 192 }
 193
 194
 195
 196 /**
 197  * adg_adim_new:
 198  *
 199  * Creates a new - unreferenced - angular dimension. You must, at least, define
 200  * the reference points with adg_dim_set_ref() and the position reference using
 201  * adg_dim_set_pos().
 202  *
 203  * Returns: the newly created angular dimension entity
 204  **/
 205 AdgADim *
 206 adg_adim_new(void)
 207 {
 208     return g_object_new(ADG_TYPE_ADIM, NULL);
 209 }
 210
 211 /**
 212  * adg_adim_get_angle1:
 213  * @adim: an #AdgADim
 214  *
 215  * Gets the angle of the first reference line of @adim.
 216  *
 217  * Returns: an angle in radians or %0 on errors
 218  **/
 219 gdouble
 220 adg_adim_get_angle1(AdgADim *adim)
 221 {
 222     AdgADimPrivate *data;
 223
 224     g_return_val_if_fail(ADG_IS_ADIM(adim), 0);
 225
 226     data = adim->data;
 227
 228     return data->angle1;
 229 }
 230
 231 /**
 232  * adg_adim_set_angle1:
 233  * @adim: an #AdgADim
 234  * @angle: the new angle (in radians)
 235  *
 236  * Sets the angle of the first reference line of @adim to @angle.
 237  **/
 238 void
 239 adg_adim_set_angle1(AdgADim *adim, gdouble angle)
 240 {
 241     g_return_if_fail(ADG_IS_ADIM(adim));
 242
 243     set_angle1(adim, angle);
 244
 245     g_object_notify((GObject *) adim, "angle1");
 246 }
 247
 248 /**
 249  * adg_adim_get_angle2:
 250  * @adim: an #AdgADim
 251  *
 252  * Gets the angle of the second reference line of @adim.
 253  *
 254  * Returns: an angle in radians or %0 on errors
 255  **/
 256 gdouble
 257 adg_adim_get_angle2(AdgADim *adim)
 258 {
 259     AdgADimPrivate *data;
 260
 261     g_return_val_if_fail(ADG_IS_ADIM(adim), 0);
 262
 263     data = adim->data;
 264
 265     return data->angle2;
 266 }
 267
 268 /**
 269  * adg_adim_set_angle2:
 270  * @adim: an #AdgADim
 271  * @angle: the new angle (in radians)
 272  *
 273  * Sets the angle of the first reference line of @adim to @angle.
 274  **/
 275 void
 276 adg_adim_set_angle2(AdgADim *adim, gdouble angle)
 277 {
 278     g_return_if_fail(ADG_IS_ADIM(adim));
 279
 280     set_angle2(adim, angle);
 281
 282     g_object_notify((GObject *) adim, "angle2");
 283 }
 284
 285
 286 static void
 287 set_angle1(AdgADim *adim, gdouble angle)
 288 {
 289     AdgADimPrivate *data = adim->data;
 290
 291     data->angle1 = angle;
 292 }
 293
 294 static void
 295 set_angle2(AdgADim *adim, gdouble angle)
 296 {
 297     AdgADimPrivate *data = adim->data;
 298
 299     data->angle2 = angle;
 300 }