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