adg/adg-ldim.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-ldim
  23  * @short_description: Linear dimensions
  24  *
  25  * The #AdgLDim entity represents a linear dimension.
  26  */
  27
  28 /**
  29  * AdgLDim:
  30  *
  31  * All fields are private and should not be used directly.
  32  * Use its public methods instead.
  33  **/
  34
  35
  36 #include "adg-ldim.h"
  37 #include "adg-ldim-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_DIRECTION
  46 };
  47
  48
  49 static void     get_property            (GObject        *object,
  50                                          guint           param_id,
  51                                          GValue         *value,
  52                                          GParamSpec     *pspec);
  53 static void     set_property            (GObject        *object,
  54                                          guint           param_id,
  55                                          const GValue   *value,
  56                                          GParamSpec     *pspec);
  57 static gboolean invalidate              (AdgEntity      *entity);
  58 static gboolean render                  (AdgEntity      *entity,
  59                                          cairo_t        *cr);
  60 static gchar *  default_quote           (AdgDim         *dim);
  61 static void     update                  (AdgLDim        *ldim);
  62 static void     clear                   (AdgLDim        *ldim);
  63
  64
  65 G_DEFINE_TYPE(AdgLDim, adg_ldim, ADG_TYPE_DIM);
  66
  67
  68 static void
  69 adg_ldim_class_init(AdgLDimClass *klass)
  70 {
  71     GObjectClass *gobject_class;
  72     AdgEntityClass *entity_class;
  73     AdgDimClass *dim_class;
  74     GParamSpec *param;
  75
  76     gobject_class = (GObjectClass *) klass;
  77     entity_class = (AdgEntityClass *) klass;
  78     dim_class = (AdgDimClass *) klass;
  79
  80     g_type_class_add_private(klass, sizeof(AdgLDimPrivate));
  81
  82     gobject_class->get_property = get_property;
  83     gobject_class->set_property = set_property;
  84
  85     entity_class->invalidate = invalidate;
  86     entity_class->render = render;
  87
  88     dim_class->default_quote = default_quote;
  89
  90     param = g_param_spec_double("direction",
  91                                 P_("Direction"),
  92                                 P_("The inclination angle of the extension lines"),
  93                                 -G_MAXDOUBLE, G_MAXDOUBLE, ADG_DIR_RIGHT,
  94                                 G_PARAM_READWRITE | G_PARAM_CONSTRUCT);
  95     g_object_class_install_property(gobject_class, PROP_DIRECTION, param);
  96 }
  97
  98 static void
  99 adg_ldim_init(AdgLDim *ldim)
 100 {
 101     AdgLDimPrivate *data = G_TYPE_INSTANCE_GET_PRIVATE(ldim, ADG_TYPE_LDIM,
 102                                                        AdgLDimPrivate);
 103
 104     data->direction = ADG_DIR_RIGHT;
 105
 106     data->path.status = CAIRO_STATUS_INVALID_PATH_DATA;
 107     data->path.data = data->path_data;
 108     data->path.num_data = 12;
 109
 110     data->path_data[0].header.type = CAIRO_PATH_MOVE_TO;
 111     data->path_data[0].header.length = 2;
 112     data->path_data[2].header.type = CAIRO_PATH_LINE_TO;
 113     data->path_data[2].header.length = 2;
 114     data->path_data[4].header.type = CAIRO_PATH_MOVE_TO;
 115     data->path_data[4].header.length = 2;
 116     data->path_data[6].header.type = CAIRO_PATH_LINE_TO;
 117     data->path_data[6].header.length = 2;
 118     data->path_data[8].header.type = CAIRO_PATH_MOVE_TO;
 119     data->path_data[8].header.length = 2;
 120     data->path_data[10].header.type = CAIRO_PATH_LINE_TO;
 121     data->path_data[10].header.length = 2;
 122
 123     data->director.data = data->director_data;
 124     data->director.num_data = 4;
 125     data->director.path = NULL;
 126
 127     data->director_data[0].header.type = CAIRO_PATH_MOVE_TO;
 128     data->director_data[0].header.length = 2;
 129     data->director_data[2].header.type = CAIRO_PATH_LINE_TO;
 130     data->director_data[2].header.length = 2;
 131
 132     ldim->data = data;
 133 }
 134
 135 static void
 136 get_property(GObject *object,
 137              guint prop_id, GValue *value, GParamSpec *pspec)
 138 {
 139     AdgLDimPrivate *data = ((AdgLDim *) object)->data;
 140
 141     switch (prop_id) {
 142     case PROP_DIRECTION:
 143         g_value_set_double(value, data->direction);
 144         break;
 145     default:
 146         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
 147         break;
 148     }
 149 }
 150
 151 static void
 152 set_property(GObject *object,
 153              guint prop_id, const GValue *value, GParamSpec *pspec)
 154 {
 155     AdgLDimPrivate *data = ((AdgLDim *) object)->data;
 156
 157     switch (prop_id) {
 158     case PROP_DIRECTION:
 159         data->direction = g_value_get_double(value);
 160         break;
 161     default:
 162         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
 163         break;
 164     }
 165 }
 166
 167
 168 /**
 169  * adg_ldim_new:
 170  *
 171  * Creates a new - unreferenced - linear dimension. You must, at least, define
 172  * the reference points with adg_dim_set_ref(), the dimension direction with
 173  * adg_ldim_set_direction() and the position reference using adg_dim_set_pos()
 174  * or, better, adg_ldim_set_pos().
 175  *
 176  * Return value: the new entity
 177  */
 178 AdgEntity *
 179 adg_ldim_new(void)
 180 {
 181     return (AdgEntity *) g_object_new(ADG_TYPE_LDIM, NULL);
 182 }
 183
 184 /**
 185  * adg_ldim_new_full:
 186  * @ref1: the first reference point
 187  * @ref2: the second reference point
 188  * @direction: angle where to extend the dimension
 189  * @pos: the position reference
 190  *
 191  * Creates a new linear dimension, specifing all the needed properties in
 192  * one shot.
 193  *
 194  * Return value: the new entity
 195  */
 196 AdgEntity *
 197 adg_ldim_new_full(const AdgPair *ref1, const AdgPair *ref2,
 198                   gdouble direction, const AdgPair *pos)
 199 {
 200     AdgEntity *entity = (AdgEntity *) g_object_new(ADG_TYPE_LDIM,
 201                                                    "ref1", ref1,
 202                                                    "ref2", ref2,
 203                                                    "direction", direction,
 204                                                    NULL);
 205     adg_ldim_set_pos((AdgLDim *) entity, pos);
 206     return entity;
 207 }
 208
 209 /**
 210  * adg_ldim_new_full_explicit:
 211  * @ref1_x: the x coordinate of the first reference point
 212  * @ref1_y: the y coordinate of the first reference point
 213  * @ref2_x: the x coordinate of the second reference point
 214  * @ref2_y: the y coordinate of the second reference point
 215  * @direction: angle where to extend the dimension
 216  * @pos_x: the x coordinate of the position reference
 217  * @pos_y: the y coordinate of the position reference
 218  *
 219  * Wrappes adg_ldim_new_full() with explicit quotes.
 220  *
 221  * Return value: the new entity
 222  */
 223 AdgEntity *
 224 adg_ldim_new_full_explicit(gdouble ref1_x, gdouble ref1_y,
 225                            gdouble ref2_x, gdouble ref2_y,
 226                            gdouble direction, gdouble pos_x, gdouble pos_y)
 227 {
 228     AdgPair ref1;
 229     AdgPair ref2;
 230     AdgPair pos;
 231
 232     ref1.x = ref1_x;
 233     ref1.y = ref1_y;
 234     ref2.x = ref2_x;
 235     ref2.y = ref2_y;
 236     pos.x = pos_x;
 237     pos.y = pos_y;
 238
 239     return adg_ldim_new_full(&ref1, &ref2, direction, &pos);
 240 }
 241
 242 /**
 243  * adg_ldim_set_pos:
 244  * @ldim: an #AdgLDim entity
 245  * @pos: an #AdgPair structure
 246  *
 247  * Sets the position references (pos1 and pos2 properties) of @ldim using a
 248  * single @pos point. Before this call, @ldim MUST HAVE defined the reference
 249  * points and the direction. If these conditions are not met, an error message
 250  * is logged and the position references will not be set.
 251  */
 252 void
 253 adg_ldim_set_pos(AdgLDim *ldim, const AdgPair *pos)
 254 {
 255     AdgLDimPrivate *data;
 256     const AdgPair *ref1, *ref2;
 257     AdgPair pos1, pos2;
 258     CpmlPair baseline_vector, extension_vector;
 259     gdouble d, k;
 260
 261     g_return_if_fail(ADG_IS_LDIM(ldim));
 262
 263     data = ldim->data;
 264     ref1 = adg_dim_get_ref1((AdgDim *) ldim);
 265     ref2 = adg_dim_get_ref2((AdgDim *) ldim);
 266
 267     cpml_vector_from_angle(&extension_vector, data->direction, 1);
 268
 269     baseline_vector.x = -extension_vector.y;
 270     baseline_vector.y = extension_vector.x;
 271
 272     d = extension_vector.y * baseline_vector.x -
 273         extension_vector.x * baseline_vector.y;
 274     g_return_if_fail(d != 0);
 275
 276     k = ((pos->y - ref1->y) * baseline_vector.x -
 277          (pos->x - ref1->x) * baseline_vector.y) / d;
 278     pos1.x = ref1->x + k * extension_vector.x;
 279     pos1.y = ref1->y + k * extension_vector.y;
 280
 281     k = ((pos->y - ref2->y) * baseline_vector.x -
 282          (pos->x - ref2->x) * baseline_vector.y) / d;
 283     pos2.x = ref2->x + k * extension_vector.x;
 284     pos2.y = ref2->y + k * extension_vector.y;
 285
 286     adg_dim_set_pos((AdgDim *) ldim, &pos1, &pos2);
 287 }
 288
 289 /**
 290  * adg_ldim_set_pos_explicit:
 291  * @ldim: an #AdgLDim entity
 292  * @pos_x: the new x coordinate position reference
 293  * @pos_y: the new y coordinate position reference
 294  *
 295  * Wrappers adg_ldim_set_pos() with explicit coordinates.
 296  */
 297 void
 298 adg_ldim_set_pos_explicit(AdgLDim *ldim, gdouble pos_x, gdouble pos_y)
 299 {
 300     AdgPair pos;
 301
 302     pos.x = pos_x;
 303     pos.y = pos_y;
 304
 305     adg_ldim_set_pos(ldim, &pos);
 306 }
 307
 308 /**
 309  * adg_ldim_get_direction:
 310  * @ldim: an #AdgLDim entity
 311  *
 312  * Gets the direction where @ldim will extend.
 313  *
 314  * Return value: the direction angle in radians
 315  */
 316 gdouble
 317 adg_ldim_get_direction(AdgLDim *ldim)
 318 {
 319     AdgLDimPrivate *data;
 320
 321     g_return_val_if_fail(ADG_IS_LDIM(ldim), 0);
 322
 323     data = ldim->data;
 324
 325     return data->direction;
 326 }
 327
 328 /**
 329  * adg_ldim_set_direction:
 330  * @ldim: an #AdgLDim entity
 331  * @direction: an angle value, in radians
 332  *
 333  * Sets the direction angle where to extend @ldim.
 334  */
 335 void
 336 adg_ldim_set_direction(AdgLDim *ldim, gdouble direction)
 337 {
 338     AdgLDimPrivate *data;
 339
 340     g_return_if_fail(ADG_IS_LDIM(ldim));
 341
 342     data = ldim->data;
 343     data->direction = direction;
 344
 345     g_object_notify((GObject *) ldim, "direction");
 346 }
 347
 348
 349 static gboolean
 350 invalidate(AdgEntity *entity)
 351 {
 352     clear((AdgLDim *) entity);
 353     return ((AdgEntityClass *) adg_ldim_parent_class)->invalidate(entity);
 354 }
 355
 356 static gboolean
 357 render(AdgEntity *entity, cairo_t *cr)
 358 {
 359     AdgLDim *ldim;
 360     AdgLDimPrivate *data;
 361     AdgStyle *dim_style;
 362     AdgStyle *arrow_style;
 363     AdgStyle *line_style;
 364     AdgMatrix local;
 365
 366     ldim = (AdgLDim *) entity;
 367     data = ldim->data;
 368     dim_style = adg_entity_get_style(entity, ADG_SLOT_DIM_STYLE);
 369     arrow_style = adg_dim_style_get_arrow_style((AdgDimStyle *) dim_style);
 370     line_style = adg_dim_style_get_line_style((AdgDimStyle *) dim_style);
 371     adg_entity_get_local_matrix(entity, &local);
 372
 373     update(ldim);
 374     adg_entity_apply(entity, ADG_SLOT_DIM_STYLE, cr);
 375
 376     cairo_save(cr);
 377     cairo_transform(cr, &local);
 378     adg_arrow_style_render((AdgArrowStyle *) arrow_style, cr, &data->director);
 379     cpml_segment_reverse(&data->director);
 380     adg_arrow_style_render((AdgArrowStyle *) arrow_style, cr, &data->director);
 381     cpml_segment_reverse(&data->director);
 382     cairo_append_path(cr, &data->path);
 383     cairo_restore(cr);
 384
 385     adg_style_apply(line_style, cr);
 386     cairo_stroke(cr);
 387
 388     adg_dim_render_quote((AdgDim *) ldim, cr);
 389
 390     return TRUE;
 391 }
 392
 393 static gchar *
 394 default_quote(AdgDim *dim)
 395 {
 396     const AdgPair *pos1, *pos2;
 397     AdgStyle *dim_style;
 398     gdouble distance;
 399     const gchar *format;
 400
 401     pos1 = adg_dim_get_pos1(dim);
 402     pos2 = adg_dim_get_pos2(dim);
 403     distance = cpml_pair_distance(pos1, pos2);
 404     dim_style = adg_entity_get_style((AdgEntity *) dim, ADG_SLOT_DIM_STYLE);
 405     format = adg_dim_style_get_number_format((AdgDimStyle *) dim_style);
 406
 407     return g_strdup_printf(format, distance);
 408 }
 409
 410 static void
 411 update(AdgLDim *ldim)
 412 {
 413     AdgLDimPrivate *data;
 414     AdgStyle *dim_style;
 415     AdgStyle *arrow_style;
 416     const AdgPair *ref1, *ref2, *pos1, *pos2;
 417     gdouble level;
 418     gdouble baseline_spacing, from_offset;
 419     cairo_path_data_t *baseline1, *baseline2;
 420     cairo_path_data_t *from1, *to1, *from2, *to2;
 421     cairo_path_data_t *arrow1, *arrow2;
 422     AdgMatrix unlocal;
 423     CpmlPair vector;
 424     AdgPair offset;
 425     gdouble angle;
 426
 427     data = ldim->data;
 428     dim_style = adg_entity_get_style((AdgEntity *) ldim, ADG_SLOT_DIM_STYLE);
 429     arrow_style = adg_dim_style_get_arrow_style((AdgDimStyle *) dim_style);
 430
 431     ref1 = adg_dim_get_ref1((AdgDim *) ldim);
 432     ref2 = adg_dim_get_ref2((AdgDim *) ldim);
 433     pos1 = adg_dim_get_pos1((AdgDim *) ldim);
 434     pos2 = adg_dim_get_pos2((AdgDim *) ldim);
 435     level = adg_dim_get_level((AdgDim *) ldim);
 436
 437     baseline_spacing = adg_dim_style_get_baseline_spacing((AdgDimStyle *) dim_style);
 438     from_offset = adg_dim_style_get_from_offset((AdgDimStyle *) dim_style);
 439
 440     baseline1 = data->path_data + 1;
 441     baseline2 = data->path_data + 3;
 442     from1 = data->path_data + 5;
 443     to1 = data->path_data + 7;
 444     from2 = data->path_data + 9;
 445     to2 = data->path_data + 11;
 446     arrow1 = data->director_data + 1;
 447     arrow2 = data->director_data + 3;
 448
 449     /* Get the inverted local matrix */
 450     adg_entity_get_local_matrix((AdgEntity *) ldim, &unlocal);
 451     if (cairo_matrix_invert(&unlocal) != CAIRO_STATUS_SUCCESS)
 452         return;
 453
 454     /* Set vector to the director of the extension lines */
 455     cpml_vector_from_angle(&vector, data->direction, 1);
 456
 457     /* Calculate from1 and from2 */
 458     offset.x = vector.x * from_offset;
 459     offset.y = vector.y * from_offset;
 460     cairo_matrix_transform_distance(&unlocal, &offset.x, &offset.y);
 461
 462     from1->point.x = ref1->x + offset.x;
 463     from1->point.y = ref1->y + offset.y;
 464     from2->point.x = ref2->x + offset.x;
 465     from2->point.y = ref2->y + offset.y;
 466
 467     /* Calculate arrow1 and arrow2 */
 468     offset.x = vector.x * baseline_spacing * level;
 469     offset.y = vector.y * baseline_spacing * level;
 470     cairo_matrix_transform_distance(&unlocal, &offset.x, &offset.y);
 471
 472     arrow1->point.x = pos1->x + offset.x;
 473     arrow1->point.y = pos1->y + offset.y;
 474     arrow2->point.x = pos2->x + offset.x;
 475     arrow2->point.y = pos2->y + offset.y;
 476
 477     /* Calculate to1 and to2 */
 478     offset.x = vector.x * adg_dim_style_get_to_offset((AdgDimStyle *) dim_style);
 479     offset.y = vector.y * adg_dim_style_get_to_offset((AdgDimStyle *) dim_style);
 480     cairo_matrix_transform_distance(&unlocal, &offset.x, &offset.y);
 481
 482     to1->point.x = arrow1->point.x + offset.x;
 483     to1->point.y = arrow1->point.y + offset.y;
 484     to2->point.x = arrow2->point.x + offset.x;
 485     to2->point.y = arrow2->point.y + offset.y;
 486
 487     /* Set vector to the director of the baseline */
 488     offset.x = arrow2->point.x - arrow1->point.x;
 489     offset.y = arrow2->point.y - arrow1->point.y;
 490     cpml_vector_set_length(cpml_pair_copy(&vector, &offset), 1);
 491
 492     /* Update the AdgDim cache contents */
 493     adg_dim_set_org_explicit((AdgDim *) ldim,
 494                              (arrow1->point.x + arrow2->point.x) / 2.,
 495                              (arrow1->point.y + arrow2->point.y) / 2.);
 496     angle = cpml_vector_angle(&vector);
 497     adg_dim_set_angle((AdgDim *) ldim, angle);
 498
 499     /* Calculate baseline1 and baseline2 */
 500     offset.y = adg_arrow_style_get_margin((AdgArrowStyle *) arrow_style);
 501     offset.x = vector.x * offset.y;
 502     offset.y *= vector.y;
 503     cairo_matrix_transform_distance(&unlocal, &offset.x, &offset.y);
 504
 505     baseline1->point.x = arrow1->point.x + offset.x;
 506     baseline1->point.y = arrow1->point.y + offset.y;
 507     baseline2->point.x = arrow2->point.x - offset.x;
 508     baseline2->point.y = arrow2->point.y - offset.y;
 509
 510     data->path.status = CAIRO_STATUS_SUCCESS;
 511 }
 512
 513 static void
 514 clear(AdgLDim *ldim)
 515 {
 516     AdgLDimPrivate *data = ldim->data;
 517
 518     data->path.status = CAIRO_STATUS_INVALID_PATH_DATA;
 519 }