adg/adg-rdim.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-rdim
  23  * @short_description: Linear dimensions
  24  *
  25  * The #AdgRDim entity represents a linear dimension.
  26  **/
  27
  28 /**
  29  * AdgRDim:
  30  *
  31  * All fields are private and should not be used directly.
  32  * Use its public methods instead.
  33  **/
  34
  35
  36 #include "adg-rdim.h"
  37 #include "adg-rdim-private.h"
  38 #include "adg-dim-private.h"
  39 #include "adg-dim-style.h"
  40 #include "adg-intl.h"
  41
  42 #define PARENT_OBJECT_CLASS  ((GObjectClass *) adg_rdim_parent_class)
  43 #define PARENT_ENTITY_CLASS  ((AdgEntityClass *) adg_rdim_parent_class)
  44
  45
  46 static void             dispose                 (GObject        *object);
  47 static void             local_changed           (AdgEntity      *entity);
  48 static void             invalidate              (AdgEntity      *entity);
  49 static void             arrange                 (AdgEntity      *entity);
  50 static void             render                  (AdgEntity      *entity,
  51                                                  cairo_t        *cr);
  52 static gchar *          default_value           (AdgDim         *dim);
  53 static void             update_geometry         (AdgRDim        *rdim);
  54 static void             update_entities         (AdgRDim        *rdim);
  55 static void             unset_trail             (AdgRDim        *rdim);
  56 static void             dispose_marker          (AdgRDim        *rdim);
  57 static CpmlPath *       trail_callback          (AdgTrail       *trail,
  58                                                  gpointer        user_data);
  59
  60
  61 G_DEFINE_TYPE(AdgRDim, adg_rdim, ADG_TYPE_DIM);
  62
  63
  64 static void
  65 adg_rdim_class_init(AdgRDimClass *klass)
  66 {
  67     GObjectClass *gobject_class;
  68     AdgEntityClass *entity_class;
  69     AdgDimClass *dim_class;
  70
  71     gobject_class = (GObjectClass *) klass;
  72     entity_class = (AdgEntityClass *) klass;
  73     dim_class = (AdgDimClass *) klass;
  74
  75     g_type_class_add_private(klass, sizeof(AdgRDimPrivate));
  76
  77     gobject_class->dispose = dispose;
  78
  79     entity_class->local_changed = local_changed;
  80     entity_class->invalidate = invalidate;
  81     entity_class->arrange = arrange;
  82     entity_class->render = render;
  83
  84     dim_class->default_value = default_value;
  85 }
  86
  87 static void
  88 adg_rdim_init(AdgRDim *rdim)
  89 {
  90     AdgRDimPrivate *data;
  91     cairo_path_data_t move_to, line_to;
  92
  93     data = G_TYPE_INSTANCE_GET_PRIVATE(rdim, ADG_TYPE_RDIM, AdgRDimPrivate);
  94     move_to.header.type = CAIRO_PATH_MOVE_TO;
  95     move_to.header.length = 2;
  96     line_to.header.type = CAIRO_PATH_LINE_TO;
  97     line_to.header.length = 2;
  98
  99     data->trail = NULL;
 100     data->marker = NULL;
 101     data->geometry_arranged = FALSE;
 102     data->radius = -1.;
 103     data->shift.base.x = data->shift.base.y = 0;
 104     cairo_matrix_init_identity(&data->quote.local_map);
 105     cairo_matrix_init_identity(&data->quote.global_map);
 106
 107     data->cpml.path.status = CAIRO_STATUS_INVALID_PATH_DATA;
 108     data->cpml.path.data = data->cpml.data;
 109     data->cpml.path.num_data = G_N_ELEMENTS(data->cpml.data);
 110     data->cpml.path.data[0] = move_to;
 111     data->cpml.path.data[2] = line_to;
 112     data->cpml.path.data[4] = move_to;
 113     data->cpml.path.data[6] = line_to;
 114
 115     rdim->data = data;
 116 }
 117
 118 static void
 119 dispose(GObject *object)
 120 {
 121     dispose_marker((AdgRDim *) object);
 122
 123     if (PARENT_OBJECT_CLASS->dispose != NULL)
 124         PARENT_OBJECT_CLASS->dispose(object);
 125 }
 126
 127
 128 /**
 129  * adg_rdim_new:
 130  *
 131  * Creates a new uninitialized radial dimension. To be useful, you
 132  * need at least define the center of the arc to quote (ref1) and
 133  * a point on the arc (ref2) with adg_dim_set_ref() and the
 134  * position of the quote with adg_dim_set_pos().
 135  *
 136  * Returns: a newly created quote
 137  **/
 138 AdgRDim *
 139 adg_rdim_new(void)
 140 {
 141     return g_object_new(ADG_TYPE_RDIM, NULL);
 142 }
 143
 144 /**
 145  * adg_rdim_new_full:
 146  * @center: center of the arc to quote
 147  * @radius: where the quote must be applied on the arc
 148  * @pos: position of the quote text
 149  *
 150  * Creates a new quote by specifying explicitely all the needed
 151  * data to get a valid quote.
 152  *
 153  * Returns: a newly created quote
 154  **/
 155 AdgRDim *
 156 adg_rdim_new_full(const AdgPair *center, const AdgPair *radius,
 157                   const AdgPair *pos)
 158 {
 159     return g_object_new(ADG_TYPE_RDIM, "ref1", center, "ref2", radius,
 160                         "pos", pos, NULL);
 161 }
 162
 163 /**
 164  * adg_rdim_new_full_explicit:
 165  * @center_x: x coordinate of the center of the arc to quote
 166  * @center_y: y coordinate of the center of the arc to quote
 167  * @radius_x: x coordiante where the quote must be applied on the arc
 168  * @radius_y: y coordiante where the quote must be applied on the arc
 169  * @pos_x: x coordinate of the quote text
 170  * @pos_y: y coordinate of the quote text
 171  *
 172  * Does the same job of adg_rdim_full() but using specific coordinates
 173  * instead of AdgPair structures.
 174  * data to get a valid quote.
 175  *
 176  * Returns: a newly created quote
 177  **/
 178 AdgRDim *
 179 adg_rdim_new_full_explicit(gdouble center_x, gdouble center_y,
 180                            gdouble radius_x, gdouble radius_y,
 181                            gdouble pos_x,    gdouble pos_y)
 182 {
 183     AdgPair center, radius, pos;
 184
 185     center.x = center_x;
 186     center.y = center_y;
 187     radius.x = radius_x;
 188     radius.y = radius_y;
 189     pos.x = pos_x;
 190     pos.y = pos_y;
 191
 192     return adg_rdim_new_full(&center, &radius, &pos);
 193 }
 194
 195
 196 static void
 197 local_changed(AdgEntity *entity)
 198 {
 199     unset_trail((AdgRDim *) entity);
 200
 201     PARENT_ENTITY_CLASS->local_changed(entity);
 202 }
 203
 204 static void
 205 invalidate(AdgEntity *entity)
 206 {
 207     AdgRDim *rdim;
 208     AdgRDimPrivate *data;
 209
 210     rdim = (AdgRDim *) entity;
 211     data = rdim->data;
 212
 213     dispose_marker(rdim);
 214     data->geometry_arranged = FALSE;
 215     unset_trail(rdim);
 216
 217     if (PARENT_ENTITY_CLASS->invalidate != NULL)
 218         PARENT_ENTITY_CLASS->invalidate(entity);
 219 }
 220
 221 static void
 222 arrange(AdgEntity *entity)
 223 {
 224     AdgRDim *rdim;
 225     AdgDim *dim;
 226     AdgRDimPrivate *data;
 227     AdgContainer *quote;
 228     AdgDimStyle *dim_style;
 229     gboolean outside;
 230     const AdgMatrix *local;
 231     AdgPair ref1, ref2, base;
 232     AdgPair pair;
 233
 234     PARENT_ENTITY_CLASS->arrange(entity);
 235
 236     rdim = (AdgRDim *) entity;
 237     dim = (AdgDim *) rdim;
 238     data = rdim->data;
 239     quote = adg_dim_get_quote(dim);
 240
 241     update_geometry(rdim);
 242     update_entities(rdim);
 243
 244     if (data->cpml.path.status == CAIRO_STATUS_SUCCESS) {
 245         AdgEntity *quote_entity = (AdgEntity *) quote;
 246         adg_entity_set_global_map(quote_entity, &data->quote.global_map);
 247         adg_entity_set_local_map(quote_entity, &data->quote.local_map);
 248         return;
 249     }
 250
 251     dim_style = GET_DIM_STYLE(dim);
 252     outside = adg_dim_get_outside(dim);
 253     if (outside == ADG_THREE_STATE_UNKNOWN)
 254         outside = ADG_THREE_STATE_OFF;
 255
 256     local = adg_entity_local_matrix(entity);
 257     cpml_pair_copy(&ref1, adg_dim_get_ref1(dim));
 258     cpml_pair_copy(&ref2, adg_dim_get_ref2(dim));
 259     cpml_pair_copy(&base, &data->point.base);
 260
 261     cpml_pair_transform(&ref1, local);
 262     cpml_pair_transform(&ref2, local);
 263     cpml_pair_transform(&base, local);
 264     cpml_pair_add(&base, &data->shift.base);
 265
 266     /* baseline start */
 267     cpml_pair_to_cairo(&base, &data->cpml.data[1]);
 268
 269     /* baseline end */
 270     cpml_pair_to_cairo(&ref2, &data->cpml.data[3]);
 271
 272     if (outside) {
 273         data->cpml.data[2].header.length = 2;
 274         /* TODO: outside radius dimensions */
 275     } else {
 276         data->cpml.data[2].header.length = 6;
 277     }
 278
 279     data->cpml.path.status = CAIRO_STATUS_SUCCESS;
 280
 281     if (quote != NULL) {
 282         /* Update global and local map of the quote container */
 283         AdgEntity *quote_entity;
 284         AdgMatrix matrix;
 285
 286         quote_entity = (AdgEntity *) quote;
 287         adg_matrix_copy(&matrix, local);
 288         cairo_matrix_invert(&matrix);
 289
 290         cpml_pair_from_cairo(&pair, &data->cpml.data[1]);
 291         cairo_matrix_transform_point(&matrix, &pair.x, &pair.y);
 292         cairo_matrix_init_translate(&matrix, pair.x, pair.y);
 293         adg_entity_set_local_map(quote_entity, &matrix);
 294
 295         cairo_matrix_init_rotate(&matrix, data->angle);
 296         adg_entity_transform_global_map(quote_entity, &matrix,
 297                                         ADG_TRANSFORM_BEFORE);
 298
 299         adg_entity_get_global_map(quote_entity, &data->quote.global_map);
 300         adg_entity_get_local_map(quote_entity, &data->quote.local_map);
 301     }
 302
 303     if (data->marker != NULL) {
 304         adg_marker_set_segment(data->marker, data->trail, outside ? 2 : 1);
 305         adg_entity_local_changed((AdgEntity *) data->marker);
 306     }
 307
 308     /* TODO: compute the extents */
 309 }
 310
 311 static void
 312 render(AdgEntity *entity, cairo_t *cr)
 313 {
 314     AdgRDim *rdim;
 315     AdgDim *dim;
 316     AdgRDimPrivate *data;
 317     AdgDimStyle *dim_style;
 318     AdgDress dress;
 319     const cairo_path_t *cairo_path;
 320
 321     rdim = (AdgRDim *) entity;
 322     dim = (AdgDim *) entity;
 323     data = rdim->data;
 324     dim_style = GET_DIM_STYLE(dim);
 325
 326     adg_style_apply((AdgStyle *) dim_style, entity, cr);
 327
 328     if (data->marker != NULL)
 329         adg_entity_render((AdgEntity *) data->marker, cr);
 330
 331     adg_entity_render((AdgEntity *) adg_dim_get_quote(dim), cr);
 332
 333     dress = adg_dim_style_get_line_dress(dim_style);
 334     adg_entity_apply_dress(entity, dress, cr);
 335
 336     cairo_path = adg_trail_get_cairo_path(data->trail);
 337     cairo_append_path(cr, cairo_path);
 338     cairo_stroke(cr);
 339 }
 340
 341 static gchar *
 342 default_value(AdgDim *dim)
 343 {
 344     AdgRDim *rdim;
 345     AdgRDimPrivate *data;
 346     AdgDimStyle *dim_style;
 347     const gchar *format;
 348
 349     rdim = (AdgRDim *) dim;
 350     data = rdim->data;
 351     dim_style = GET_DIM_STYLE(dim);
 352     format = adg_dim_style_get_number_format(dim_style);
 353
 354     update_geometry(rdim);
 355
 356     return g_strdup_printf(format, data->radius);
 357 }
 358
 359 static void
 360 update_geometry(AdgRDim *rdim)
 361 {
 362     AdgRDimPrivate *data;
 363     AdgDim *dim;
 364     AdgDimStyle *dim_style;
 365     const AdgPair *ref1, *ref2;
 366     const AdgPair *pos;
 367     gdouble spacing, level, pos_distance;
 368     CpmlVector vector;
 369
 370     data = rdim->data;
 371
 372     if (data->geometry_arranged)
 373         return;
 374
 375     dim = (AdgDim *) rdim;
 376     dim_style = GET_DIM_STYLE(rdim);
 377     ref1 = adg_dim_get_ref1(dim);
 378     ref2 = adg_dim_get_ref2(dim);
 379     pos = adg_dim_get_pos(dim);
 380     spacing = adg_dim_style_get_baseline_spacing(dim_style);
 381     level = adg_dim_get_level(dim);
 382     pos_distance = cpml_pair_distance(pos, ref1);
 383     cpml_pair_sub(cpml_pair_copy(&vector, ref2), ref1);
 384     if (cpml_pair_squared_distance(pos, ref1) <
 385         cpml_pair_squared_distance(pos, ref2))
 386         cpml_pair_negate(&vector);
 387
 388     /* radius */
 389     data->radius = cpml_pair_distance(&vector, NULL);
 390
 391     /* angle */
 392     data->angle = adg_dim_quote_angle(dim, cpml_vector_angle(&vector));
 393
 394     /* point.base */
 395     cpml_pair_copy(&data->point.base, &vector);
 396     cpml_vector_set_length(&data->point.base, pos_distance);
 397     cpml_pair_add(&data->point.base, ref1);
 398
 399     /* shift.base */
 400     cpml_pair_copy(&data->shift.base, &vector);
 401     cpml_vector_set_length(&data->shift.base, spacing * level);
 402
 403     data->geometry_arranged = TRUE;
 404 }
 405
 406 static void
 407 update_entities(AdgRDim *rdim)
 408 {
 409     AdgRDimPrivate *data;
 410     AdgDimStyle *dim_style;
 411
 412     data = rdim->data;
 413     dim_style = GET_DIM_STYLE(rdim);
 414
 415     if (data->trail == NULL)
 416         data->trail = adg_trail_new(trail_callback, rdim);
 417
 418     if (data->marker == NULL)
 419         data->marker = adg_dim_style_marker2_new(dim_style);
 420 }
 421
 422 static void
 423 unset_trail(AdgRDim *rdim)
 424 {
 425     AdgRDimPrivate *data = rdim->data;
 426
 427     if (data->trail != NULL)
 428         adg_model_clear((AdgModel *) data->trail);
 429
 430     data->cpml.path.status = CAIRO_STATUS_INVALID_PATH_DATA;
 431 }
 432
 433 static void
 434 dispose_marker(AdgRDim *rdim)
 435 {
 436     AdgRDimPrivate *data = rdim->data;
 437
 438     if (data->trail != NULL) {
 439         g_object_unref(data->trail);
 440         data->trail = NULL;
 441     }
 442
 443     if (data->marker != NULL) {
 444         g_object_unref(data->marker);
 445         data->marker = NULL;
 446     }
 447 }
 448
 449 static CpmlPath *
 450 trail_callback(AdgTrail *trail, gpointer user_data)
 451 {
 452     AdgRDim *rdim;
 453     AdgRDimPrivate *data;
 454
 455     rdim = (AdgRDim *) user_data;
 456     data = rdim->data;
 457
 458     return &data->cpml.path;
 459 }