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