src/adg/adg-rdim.c

   1 /* ADG - Automatic Drawing Generation
   2  * Copyright (C) 2007,2008,2009,2010  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-internal.h"
  37 #include "adg-rdim.h"
  38 #include "adg-rdim-private.h"
  39 #include "adg-dim-private.h"
  40 #include "adg-dim-style.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 = CPML_MOVE;
  95     move_to.header.length = 2;
  96     line_to.header.type = CPML_LINE;
  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.global_map);
 105
 106     data->cpml.path.status = CAIRO_STATUS_INVALID_PATH_DATA;
 107     data->cpml.path.data = data->cpml.data;
 108     data->cpml.path.num_data = G_N_ELEMENTS(data->cpml.data);
 109     data->cpml.path.data[0] = move_to;
 110     data->cpml.path.data[2] = line_to;
 111     data->cpml.path.data[4] = move_to;
 112     data->cpml.path.data[6] = line_to;
 113
 114     rdim->data = data;
 115 }
 116
 117 static void
 118 dispose(GObject *object)
 119 {
 120     dispose_marker((AdgRDim *) object);
 121
 122     if (PARENT_OBJECT_CLASS->dispose)
 123         PARENT_OBJECT_CLASS->dispose(object);
 124 }
 125
 126
 127 /**
 128  * adg_rdim_new:
 129  *
 130  * Creates a new uninitialized radial dimension. To be useful, you
 131  * need at least define the center of the arc to quote in #AdgDim:ref1,
 132  * a point on the arc in #AdgDim:ref2 and the position of the quote
 133  * in #AdgDim:pos using any valid #AdgDim method.
 134  *
 135  * Returns: a newly created quote
 136  **/
 137 AdgRDim *
 138 adg_rdim_new(void)
 139 {
 140     return g_object_new(ADG_TYPE_RDIM, NULL);
 141 }
 142
 143 /**
 144  * adg_rdim_new_full:
 145  * @center: center of the arc to quote
 146  * @radius: where the quote must be applied on the arc
 147  * @pos: position of the quote text
 148  *
 149  * Creates a new quote by specifying explicitely all the needed
 150  * data to get a valid quote.
 151  *
 152  * Returns: a newly created quote
 153  **/
 154 AdgRDim *
 155 adg_rdim_new_full(const AdgPair *center, const AdgPair *radius,
 156                   const AdgPair *pos)
 157 {
 158     AdgRDim *rdim;
 159     AdgDim *dim;
 160
 161     rdim = adg_rdim_new();
 162     dim = (AdgDim *) rdim;
 163
 164     adg_dim_set_ref1_from_pair(dim, center);
 165     adg_dim_set_ref2_from_pair(dim, radius);
 166     adg_dim_set_pos_from_pair(dim, pos);
 167
 168     return rdim;
 169 }
 170
 171 /**
 172  * adg_rdim_new_full_explicit:
 173  * @center_x: x coordinate of the center of the arc to quote
 174  * @center_y: y coordinate of the center of the arc to quote
 175  * @radius_x: x coordiante where the quote must be applied on the arc
 176  * @radius_y: y coordiante where the quote must be applied on the arc
 177  * @pos_x: x coordinate of the quote text
 178  * @pos_y: y coordinate of the quote text
 179  *
 180  * Does the same job of adg_rdim_full() but using specific coordinates
 181  * instead of AdgPair structures.
 182  * data to get a valid quote.
 183  *
 184  * Returns: a newly created quote
 185  **/
 186 AdgRDim *
 187 adg_rdim_new_full_explicit(gdouble center_x, gdouble center_y,
 188                            gdouble radius_x, gdouble radius_y,
 189                            gdouble pos_x,    gdouble pos_y)
 190 {
 191     AdgPair center, radius, pos;
 192
 193     center.x = center_x;
 194     center.y = center_y;
 195     radius.x = radius_x;
 196     radius.y = radius_y;
 197     pos.x = pos_x;
 198     pos.y = pos_y;
 199
 200     return adg_rdim_new_full(&center, &radius, &pos);
 201 }
 202
 203 /**
 204  * adg_rdim_new_full_from_model:
 205  * @model: the model from which the named pairs are taken
 206  * @center: the center point of the arc to quote
 207  * @radius: an arbitrary point on the arc
 208  * @pos: the position reference
 209  *
 210  * Creates a new radial dimension, specifing all the needed properties in
 211  * one shot and using named pairs from @model.
 212  *
 213  * Returns: the newly created radial dimension entity
 214  **/
 215 AdgRDim *
 216 adg_rdim_new_full_from_model(AdgModel *model, const gchar *center,
 217                              const gchar *radius, const gchar *pos)
 218 {
 219     AdgDim *dim = g_object_new(ADG_TYPE_RDIM, NULL);
 220
 221     adg_dim_set_ref1_from_model(dim, model, center);
 222     adg_dim_set_ref2_from_model(dim, model, radius);
 223     adg_dim_set_pos_from_model(dim, model, pos);
 224
 225     return (AdgRDim *) dim;
 226 }
 227
 228
 229 static void
 230 local_changed(AdgEntity *entity)
 231 {
 232     unset_trail((AdgRDim *) entity);
 233
 234     if (PARENT_ENTITY_CLASS->local_changed)
 235         PARENT_ENTITY_CLASS->local_changed(entity);
 236 }
 237
 238 static void
 239 invalidate(AdgEntity *entity)
 240 {
 241     AdgRDim *rdim;
 242     AdgRDimPrivate *data;
 243
 244     rdim = (AdgRDim *) entity;
 245     data = rdim->data;
 246
 247     dispose_marker(rdim);
 248     data->geometry_arranged = FALSE;
 249     unset_trail(rdim);
 250
 251     if (PARENT_ENTITY_CLASS->invalidate)
 252         PARENT_ENTITY_CLASS->invalidate(entity);
 253 }
 254
 255 static void
 256 arrange(AdgEntity *entity)
 257 {
 258     AdgRDim *rdim;
 259     AdgDim *dim;
 260     AdgRDimPrivate *data;
 261     AdgAlignment *quote;
 262     AdgDimStyle *dim_style;
 263     gboolean outside;
 264     const AdgMatrix *local;
 265     AdgPair ref1, ref2, base;
 266     AdgPair pair;
 267
 268     if (PARENT_ENTITY_CLASS->arrange)
 269         PARENT_ENTITY_CLASS->arrange(entity);
 270
 271     rdim = (AdgRDim *) entity;
 272     dim = (AdgDim *) rdim;
 273     data = rdim->data;
 274     quote = adg_dim_get_quote(dim);
 275
 276     update_geometry(rdim);
 277     update_entities(rdim);
 278
 279     if (data->cpml.path.status == CAIRO_STATUS_SUCCESS) {
 280         AdgEntity *quote_entity = (AdgEntity *) quote;
 281         adg_entity_set_global_map(quote_entity, &data->quote.global_map);
 282         return;
 283     }
 284
 285     dim_style = GET_DIM_STYLE(dim);
 286     outside = adg_dim_get_outside(dim);
 287     if (outside == ADG_THREE_STATE_UNKNOWN)
 288         outside = ADG_THREE_STATE_OFF;
 289
 290     local = adg_entity_get_local_matrix(entity);
 291     cpml_pair_copy(&ref1, adg_point_get_pair(adg_dim_get_ref1(dim)));
 292     cpml_pair_copy(&ref2, adg_point_get_pair(adg_dim_get_ref2(dim)));
 293     cpml_pair_copy(&base, &data->point.base);
 294
 295     cpml_pair_transform(&ref1, local);
 296     cpml_pair_transform(&ref2, local);
 297     cpml_pair_transform(&base, local);
 298     base.x += data->shift.base.x;
 299     base.y += data->shift.base.y;
 300
 301     /* baseline start */
 302     cpml_pair_to_cairo(&base, &data->cpml.data[1]);
 303
 304     /* baseline end */
 305     cpml_pair_to_cairo(&ref2, &data->cpml.data[3]);
 306
 307     if (outside) {
 308         data->cpml.data[2].header.length = 2;
 309         /* TODO: outside radius dimensions */
 310     } else {
 311         data->cpml.data[2].header.length = 6;
 312     }
 313
 314     data->cpml.path.status = CAIRO_STATUS_SUCCESS;
 315
 316     if (quote != NULL) {
 317         AdgEntity *quote_entity;
 318         AdgMatrix map;
 319
 320         quote_entity = (AdgEntity *) quote;
 321         cpml_pair_from_cairo(&pair, &data->cpml.data[1]);
 322
 323         adg_alignment_set_factor_explicit(quote, 1, 0);
 324
 325         cairo_matrix_init_translate(&map, pair.x, pair.y);
 326         cairo_matrix_rotate(&map, data->angle);
 327         adg_entity_set_global_map(quote_entity, &map);
 328
 329         adg_matrix_copy(&data->quote.global_map,
 330                         adg_entity_get_global_map(quote_entity));
 331     }
 332
 333     if (data->marker != NULL) {
 334         adg_marker_set_segment(data->marker, data->trail, outside ? 2 : 1);
 335         adg_entity_local_changed((AdgEntity *) data->marker);
 336     }
 337
 338     /* TODO: compute the extents */
 339 }
 340
 341 static void
 342 render(AdgEntity *entity, cairo_t *cr)
 343 {
 344     AdgRDim *rdim;
 345     AdgDim *dim;
 346     AdgRDimPrivate *data;
 347     AdgDimStyle *dim_style;
 348     AdgDress dress;
 349     const cairo_path_t *cairo_path;
 350
 351     rdim = (AdgRDim *) entity;
 352     dim = (AdgDim *) entity;
 353     data = rdim->data;
 354     dim_style = GET_DIM_STYLE(dim);
 355
 356     adg_style_apply((AdgStyle *) dim_style, entity, cr);
 357
 358     if (data->marker != NULL)
 359         adg_entity_render((AdgEntity *) data->marker, cr);
 360
 361     adg_entity_render((AdgEntity *) adg_dim_get_quote(dim), cr);
 362
 363     dress = adg_dim_style_get_line_dress(dim_style);
 364     adg_entity_apply_dress(entity, dress, cr);
 365
 366     cairo_path = adg_trail_get_cairo_path(data->trail);
 367     cairo_append_path(cr, cairo_path);
 368     cairo_stroke(cr);
 369 }
 370
 371 static gchar *
 372 default_value(AdgDim *dim)
 373 {
 374     AdgRDim *rdim;
 375     AdgRDimPrivate *data;
 376     AdgDimStyle *dim_style;
 377     const gchar *format;
 378
 379     rdim = (AdgRDim *) dim;
 380     data = rdim->data;
 381     dim_style = GET_DIM_STYLE(dim);
 382     format = adg_dim_style_get_number_format(dim_style);
 383
 384     update_geometry(rdim);
 385
 386     return g_strdup_printf(format, data->radius);
 387 }
 388
 389 static void
 390 update_geometry(AdgRDim *rdim)
 391 {
 392     AdgRDimPrivate *data;
 393     AdgDim *dim;
 394     AdgDimStyle *dim_style;
 395     const AdgPair *ref1, *ref2;
 396     const AdgPair *pos;
 397     gdouble spacing, level, pos_distance;
 398     CpmlVector vector;
 399
 400     data = rdim->data;
 401
 402     if (data->geometry_arranged)
 403         return;
 404
 405     dim = (AdgDim *) rdim;
 406     dim_style = GET_DIM_STYLE(rdim);
 407     ref1 = adg_point_get_pair(adg_dim_get_ref1(dim));
 408     ref2 = adg_point_get_pair(adg_dim_get_ref2(dim));
 409     pos = adg_point_get_pair(adg_dim_get_pos(dim));
 410     spacing = adg_dim_style_get_baseline_spacing(dim_style);
 411     level = adg_dim_get_level(dim);
 412     pos_distance = cpml_pair_distance(pos, ref1);
 413     vector.x = ref2->x - ref1->x;
 414     vector.y = ref2->y - ref1->y;
 415     if (cpml_pair_squared_distance(pos, ref1) <
 416         cpml_pair_squared_distance(pos, ref2)) {
 417         vector.x = -vector.x;
 418         vector.y = -vector.y;
 419     }
 420
 421     /* radius */
 422     data->radius = cpml_pair_distance(&vector, NULL);
 423
 424     /* angle */
 425     data->angle = adg_dim_quote_angle(dim, cpml_vector_angle(&vector));
 426
 427     /* point.base */
 428     cpml_pair_copy(&data->point.base, &vector);
 429     cpml_vector_set_length(&data->point.base, pos_distance);
 430     data->point.base.x += ref1->x;
 431     data->point.base.y += ref1->y;
 432
 433     /* shift.base */
 434     cpml_pair_copy(&data->shift.base, &vector);
 435     cpml_vector_set_length(&data->shift.base, spacing * level);
 436
 437     data->geometry_arranged = TRUE;
 438 }
 439
 440 static void
 441 update_entities(AdgRDim *rdim)
 442 {
 443     AdgRDimPrivate *data;
 444     AdgDimStyle *dim_style;
 445
 446     data = rdim->data;
 447     dim_style = GET_DIM_STYLE(rdim);
 448
 449     if (data->trail == NULL)
 450         data->trail = adg_trail_new(trail_callback, rdim);
 451
 452     if (data->marker == NULL)
 453         data->marker = adg_dim_style_marker2_new(dim_style);
 454 }
 455
 456 static void
 457 unset_trail(AdgRDim *rdim)
 458 {
 459     AdgRDimPrivate *data = rdim->data;
 460
 461     if (data->trail != NULL)
 462         adg_model_clear((AdgModel *) data->trail);
 463
 464     data->cpml.path.status = CAIRO_STATUS_INVALID_PATH_DATA;
 465 }
 466
 467 static void
 468 dispose_marker(AdgRDim *rdim)
 469 {
 470     AdgRDimPrivate *data = rdim->data;
 471
 472     if (data->trail != NULL) {
 473         g_object_unref(data->trail);
 474         data->trail = NULL;
 475     }
 476
 477     if (data->marker != NULL) {
 478         g_object_unref(data->marker);
 479         data->marker = NULL;
 480     }
 481 }
 482
 483 static CpmlPath *
 484 trail_callback(AdgTrail *trail, gpointer user_data)
 485 {
 486     AdgRDim *rdim;
 487     AdgRDimPrivate *data;
 488
 489     rdim = (AdgRDim *) user_data;
 490     data = rdim->data;
 491
 492     return &data->cpml.path;
 493 }