src/adg/adg-rdim.c

   1 /* ADG - Automatic Drawing Generation
   2  * Copyright (C) 2007,2008,2009,2010,2011  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-container.h"
  38 #include "adg-alignment.h"
  39 #include "adg-model.h"
  40 #include "adg-point.h"
  41 #include "adg-trail.h"
  42 #include "adg-marker.h"
  43 #include "adg-style.h"
  44 #include "adg-dim-style.h"
  45 #include "adg-textual.h"
  46 #include "adg-toy-text.h"
  47 #include "adg-dim.h"
  48 #include "adg-dim-private.h"
  49 #include <math.h>
  50
  51 #include "adg-rdim.h"
  52 #include "adg-rdim-private.h"
  53
  54
  55 #define _ADG_OLD_OBJECT_CLASS  ((GObjectClass *) adg_rdim_parent_class)
  56 #define _ADG_OLD_ENTITY_CLASS  ((AdgEntityClass *) adg_rdim_parent_class)
  57
  58
  59 G_DEFINE_TYPE(AdgRDim, adg_rdim, ADG_TYPE_DIM)
  60
  61 enum {
  62     PROP_0,
  63     PROP_VALUE
  64 };
  65
  66
  67 static void             _adg_dispose            (GObject        *object);
  68 static void             _adg_get_property       (GObject        *object,
  69                                                  guint           param_id,
  70                                                  GValue         *value,
  71                                                  GParamSpec     *pspec);
  72 static void             _adg_set_property       (GObject        *object,
  73                                                  guint           param_id,
  74                                                  const GValue   *value,
  75                                                  GParamSpec     *pspec);
  76 static void             _adg_global_changed     (AdgEntity      *entity);
  77 static void             _adg_local_changed      (AdgEntity      *entity);
  78 static void             _adg_invalidate         (AdgEntity      *entity);
  79 static void             _adg_arrange            (AdgEntity      *entity);
  80 static void             _adg_render             (AdgEntity      *entity,
  81                                                  cairo_t        *cr);
  82 static gchar *          _adg_default_value      (AdgDim         *dim);
  83 static gboolean         _adg_update_geometry    (AdgRDim        *rdim);
  84 static void             _adg_update_entities    (AdgRDim        *rdim);
  85 static void             _adg_clear_trail        (AdgRDim        *rdim);
  86 static void             _adg_dispose_marker     (AdgRDim        *rdim);
  87 static CpmlPath *       _adg_trail_callback     (AdgTrail       *trail,
  88                                                  gpointer        user_data);
  89
  90
  91 static void
  92 adg_rdim_class_init(AdgRDimClass *klass)
  93 {
  94     GObjectClass *gobject_class;
  95     AdgEntityClass *entity_class;
  96     AdgDimClass *dim_class;
  97     GParamSpec *param, *old_param;
  98
  99     gobject_class = (GObjectClass *) klass;
 100     entity_class = (AdgEntityClass *) klass;
 101     dim_class = (AdgDimClass *) klass;
 102
 103     g_type_class_add_private(klass, sizeof(AdgRDimPrivate));
 104
 105     gobject_class->dispose = _adg_dispose;
 106     gobject_class->get_property = _adg_get_property;
 107     gobject_class->set_property = _adg_set_property;
 108
 109     entity_class->global_changed = _adg_global_changed;
 110     entity_class->local_changed = _adg_local_changed;
 111     entity_class->invalidate = _adg_invalidate;
 112     entity_class->arrange = _adg_arrange;
 113     entity_class->render = _adg_render;
 114
 115     dim_class->default_value = _adg_default_value;
 116
 117     /* Override #AdgDim:value to prepend "R "
 118      * to the default set value template string */
 119     old_param = g_object_class_find_property(gobject_class, "value");
 120     param = g_param_spec_string(old_param->name,
 121                                 g_param_spec_get_nick(old_param),
 122                                 g_param_spec_get_blurb(old_param),
 123                                 "R <>",
 124                                 old_param->flags);
 125     g_object_class_install_property(gobject_class, PROP_VALUE, param);
 126 }
 127
 128 static void
 129 adg_rdim_init(AdgRDim *rdim)
 130 {
 131     AdgRDimPrivate *data;
 132     cairo_path_data_t move_to, line_to;
 133
 134     data = G_TYPE_INSTANCE_GET_PRIVATE(rdim, ADG_TYPE_RDIM, AdgRDimPrivate);
 135     move_to.header.type = CPML_MOVE;
 136     move_to.header.length = 2;
 137     line_to.header.type = CPML_LINE;
 138     line_to.header.length = 2;
 139
 140     data->trail = NULL;
 141     data->marker = NULL;
 142     data->geometry_arranged = FALSE;
 143     data->radius = -1.;
 144     data->shift.base.x = data->shift.base.y = 0;
 145     cairo_matrix_init_identity(&data->quote.global_map);
 146
 147     data->cpml.path.status = CAIRO_STATUS_INVALID_PATH_DATA;
 148     data->cpml.path.data = data->cpml.data;
 149     data->cpml.path.num_data = G_N_ELEMENTS(data->cpml.data);
 150     data->cpml.path.data[0] = move_to;
 151     data->cpml.path.data[2] = line_to;
 152     data->cpml.path.data[4] = move_to;
 153     data->cpml.path.data[6] = line_to;
 154
 155     rdim->data = data;
 156 }
 157
 158 static void
 159 _adg_dispose(GObject *object)
 160 {
 161     _adg_dispose_marker((AdgRDim *) object);
 162
 163     if (_ADG_OLD_OBJECT_CLASS->dispose)
 164         _ADG_OLD_OBJECT_CLASS->dispose(object);
 165 }
 166
 167 static void
 168 _adg_get_property(GObject *object, guint prop_id,
 169                   GValue *value, GParamSpec *pspec)
 170 {
 171     switch (prop_id) {
 172     case PROP_VALUE:
 173         g_value_set_string(value, adg_dim_get_value((AdgDim *) object));
 174         break;
 175     default:
 176         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
 177         break;
 178     }
 179 }
 180
 181 static void
 182 _adg_set_property(GObject *object, guint prop_id,
 183                   const GValue *value, GParamSpec *pspec)
 184 {
 185     switch (prop_id) {
 186     case PROP_VALUE:
 187         adg_dim_set_value((AdgDim *) object, g_value_get_string(value));
 188         break;
 189     default:
 190         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
 191         break;
 192     }
 193 }
 194
 195
 196 /**
 197  * adg_rdim_new:
 198  *
 199  * Creates a new uninitialized radial dimension. To be useful, you
 200  * need at least define the center of the arc to quote in #AdgDim:ref1,
 201  * a point on the arc in #AdgDim:ref2 and the position of the quote
 202  * in #AdgDim:pos using any valid #AdgDim method.
 203  *
 204  * Returns: a newly created quote
 205  **/
 206 AdgRDim *
 207 adg_rdim_new(void)
 208 {
 209     return g_object_new(ADG_TYPE_RDIM, NULL);
 210 }
 211
 212 /**
 213  * adg_rdim_new_full:
 214  * @center: center of the arc to quote
 215  * @radius: where the quote must be applied on the arc
 216  * @pos: position of the quote text
 217  *
 218  * Creates a new quote by specifying explicitely all the needed
 219  * data to get a valid quote.
 220  *
 221  * Returns: a newly created quote
 222  **/
 223 AdgRDim *
 224 adg_rdim_new_full(const AdgPair *center, const AdgPair *radius,
 225                   const AdgPair *pos)
 226 {
 227     AdgRDim *rdim;
 228     AdgDim *dim;
 229
 230     rdim = adg_rdim_new();
 231     dim = (AdgDim *) rdim;
 232
 233     adg_dim_set_ref1_from_pair(dim, center);
 234     adg_dim_set_ref2_from_pair(dim, radius);
 235     adg_dim_set_pos_from_pair(dim, pos);
 236
 237     return rdim;
 238 }
 239
 240 /**
 241  * adg_rdim_new_full_explicit:
 242  * @center_x: x coordinate of the center of the arc to quote
 243  * @center_y: y coordinate of the center of the arc to quote
 244  * @radius_x: x coordiante where the quote must be applied on the arc
 245  * @radius_y: y coordiante where the quote must be applied on the arc
 246  * @pos_x: x coordinate of the quote text
 247  * @pos_y: y coordinate of the quote text
 248  *
 249  * Does the same job of adg_rdim_full() but using specific coordinates
 250  * instead of AdgPair structures.
 251  * data to get a valid quote.
 252  *
 253  * Returns: a newly created quote
 254  **/
 255 AdgRDim *
 256 adg_rdim_new_full_explicit(gdouble center_x, gdouble center_y,
 257                            gdouble radius_x, gdouble radius_y,
 258                            gdouble pos_x,    gdouble pos_y)
 259 {
 260     AdgPair center, radius, pos;
 261
 262     center.x = center_x;
 263     center.y = center_y;
 264     radius.x = radius_x;
 265     radius.y = radius_y;
 266     pos.x = pos_x;
 267     pos.y = pos_y;
 268
 269     return adg_rdim_new_full(&center, &radius, &pos);
 270 }
 271
 272 /**
 273  * adg_rdim_new_full_from_model:
 274  * @model: the model from which the named pairs are taken
 275  * @center: the center point of the arc to quote
 276  * @radius: an arbitrary point on the arc
 277  * @pos: the position reference
 278  *
 279  * Creates a new radial dimension, specifing all the needed properties in
 280  * one shot and using named pairs from @model.
 281  *
 282  * Returns: the newly created radial dimension entity
 283  **/
 284 AdgRDim *
 285 adg_rdim_new_full_from_model(AdgModel *model, const gchar *center,
 286                              const gchar *radius, const gchar *pos)
 287 {
 288     AdgDim *dim = g_object_new(ADG_TYPE_RDIM, NULL);
 289
 290     adg_dim_set_ref1_from_model(dim, model, center);
 291     adg_dim_set_ref2_from_model(dim, model, radius);
 292     adg_dim_set_pos_from_model(dim, model, pos);
 293
 294     return (AdgRDim *) dim;
 295 }
 296
 297
 298 static void
 299 _adg_global_changed(AdgEntity *entity)
 300 {
 301     AdgRDimPrivate *data = ((AdgRDim *) entity)->data;
 302
 303     _adg_clear_trail((AdgRDim *) entity);
 304
 305     if (_ADG_OLD_ENTITY_CLASS->global_changed)
 306         _ADG_OLD_ENTITY_CLASS->global_changed(entity);
 307
 308     if (data->marker != NULL)
 309         adg_entity_global_changed((AdgEntity *) data->marker);
 310 }
 311
 312 static void
 313 _adg_local_changed(AdgEntity *entity)
 314 {
 315     _adg_clear_trail((AdgRDim *) entity);
 316
 317     if (_ADG_OLD_ENTITY_CLASS->local_changed)
 318         _ADG_OLD_ENTITY_CLASS->local_changed(entity);
 319 }
 320
 321 static void
 322 _adg_invalidate(AdgEntity *entity)
 323 {
 324     AdgRDim *rdim;
 325     AdgRDimPrivate *data;
 326
 327     rdim = (AdgRDim *) entity;
 328     data = rdim->data;
 329
 330     _adg_dispose_marker(rdim);
 331     data->geometry_arranged = FALSE;
 332     _adg_clear_trail(rdim);
 333
 334     if (_ADG_OLD_ENTITY_CLASS->invalidate)
 335         _ADG_OLD_ENTITY_CLASS->invalidate(entity);
 336 }
 337
 338 static void
 339 _adg_arrange(AdgEntity *entity)
 340 {
 341     AdgRDim *rdim;
 342     AdgDim *dim;
 343     AdgRDimPrivate *data;
 344     AdgAlignment *quote;
 345     AdgDimStyle *dim_style;
 346     gboolean outside;
 347     const AdgMatrix *local;
 348     AdgPair ref1, ref2, base;
 349     AdgPair pair;
 350
 351     if (_ADG_OLD_ENTITY_CLASS->arrange)
 352         _ADG_OLD_ENTITY_CLASS->arrange(entity);
 353
 354     rdim = (AdgRDim *) entity;
 355     dim = (AdgDim *) rdim;
 356     data = rdim->data;
 357     quote = adg_dim_get_quote(dim);
 358
 359     if (!_adg_update_geometry(rdim))
 360         return;
 361
 362     _adg_update_entities(rdim);
 363
 364     if (data->cpml.path.status == CAIRO_STATUS_SUCCESS) {
 365         AdgEntity *quote_entity = (AdgEntity *) quote;
 366         adg_entity_set_global_map(quote_entity, &data->quote.global_map);
 367         return;
 368     }
 369
 370     dim_style = _ADG_GET_DIM_STYLE(dim);
 371     outside = adg_dim_get_outside(dim);
 372     if (outside == ADG_THREE_STATE_UNKNOWN)
 373         outside = ADG_THREE_STATE_OFF;
 374
 375     local = adg_entity_get_local_matrix(entity);
 376     cpml_pair_copy(&ref1, adg_point_get_pair(adg_dim_get_ref1(dim)));
 377     cpml_pair_copy(&ref2, adg_point_get_pair(adg_dim_get_ref2(dim)));
 378     cpml_pair_copy(&base, &data->point.base);
 379
 380     cpml_pair_transform(&ref1, local);
 381     cpml_pair_transform(&ref2, local);
 382     cpml_pair_transform(&base, local);
 383     base.x += data->shift.base.x;
 384     base.y += data->shift.base.y;
 385
 386     /* baseline start */
 387     cpml_pair_to_cairo(&base, &data->cpml.data[1]);
 388
 389     /* baseline end */
 390     cpml_pair_to_cairo(&ref2, &data->cpml.data[3]);
 391
 392     if (outside) {
 393         data->cpml.data[2].header.length = 2;
 394         /* TODO: outside radius dimensions */
 395     } else {
 396         data->cpml.data[2].header.length = 6;
 397     }
 398
 399     data->cpml.path.status = CAIRO_STATUS_SUCCESS;
 400
 401     if (quote != NULL) {
 402         AdgEntity *quote_entity;
 403         AdgMatrix map;
 404
 405         quote_entity = (AdgEntity *) quote;
 406         cpml_pair_from_cairo(&pair, &data->cpml.data[1]);
 407
 408         adg_alignment_set_factor_explicit(quote, 1, 0);
 409
 410         cairo_matrix_init_translate(&map, pair.x, pair.y);
 411         cairo_matrix_rotate(&map, data->angle);
 412         adg_entity_set_global_map(quote_entity, &map);
 413
 414         adg_matrix_copy(&data->quote.global_map,
 415                         adg_entity_get_global_map(quote_entity));
 416     }
 417
 418     if (data->marker != NULL) {
 419         adg_marker_set_segment(data->marker, data->trail, outside ? 2 : 1);
 420         adg_entity_local_changed((AdgEntity *) data->marker);
 421     }
 422
 423     /* TODO: compute the extents */
 424 }
 425
 426 static void
 427 _adg_render(AdgEntity *entity, cairo_t *cr)
 428 {
 429     AdgRDim *rdim;
 430     AdgDim *dim;
 431     AdgRDimPrivate *data;
 432     AdgDimStyle *dim_style;
 433     AdgDress dress;
 434     const cairo_path_t *cairo_path;
 435
 436     rdim = (AdgRDim *) entity;
 437     data = rdim->data;
 438
 439     if (!data->geometry_arranged) {
 440         /* Entity not arranged, probably due to undefined pair found */
 441         return;
 442     }
 443
 444     dim = (AdgDim *) entity;
 445     dim_style = _ADG_GET_DIM_STYLE(dim);
 446
 447     adg_style_apply((AdgStyle *) dim_style, entity, cr);
 448     adg_entity_render((AdgEntity *) adg_dim_get_quote(dim), cr);
 449
 450     if (data->marker != NULL)
 451         adg_entity_render((AdgEntity *) data->marker, cr);
 452
 453     cairo_transform(cr, adg_entity_get_global_matrix(entity));
 454     dress = adg_dim_style_get_line_dress(dim_style);
 455     adg_entity_apply_dress(entity, dress, cr);
 456
 457     cairo_path = adg_trail_get_cairo_path(data->trail);
 458     cairo_append_path(cr, cairo_path);
 459     cairo_stroke(cr);
 460 }
 461
 462 static gchar *
 463 _adg_default_value(AdgDim *dim)
 464 {
 465     AdgRDim *rdim;
 466     AdgRDimPrivate *data;
 467     AdgDimStyle *dim_style;
 468     const gchar *format;
 469
 470     rdim = (AdgRDim *) dim;
 471     data = rdim->data;
 472     dim_style = _ADG_GET_DIM_STYLE(dim);
 473     format = adg_dim_style_get_number_format(dim_style);
 474
 475     if (!_adg_update_geometry(rdim))
 476         return g_strdup("undef");
 477
 478     return g_strdup_printf(format, data->radius);
 479 }
 480
 481 static gboolean
 482 _adg_update_geometry(AdgRDim *rdim)
 483 {
 484     AdgRDimPrivate *data;
 485     AdgDim *dim;
 486     AdgDimStyle *dim_style;
 487     const AdgPair *ref1, *ref2;
 488     const AdgPair *pos;
 489     gdouble spacing, level, pos_distance;
 490     CpmlVector vector;
 491
 492     data = rdim->data;
 493
 494     if (data->geometry_arranged)
 495         return TRUE;
 496
 497     dim = (AdgDim *) rdim;
 498     ref1 = adg_point_get_pair(adg_dim_get_ref1(dim));
 499     ref2 = adg_point_get_pair(adg_dim_get_ref2(dim));
 500     pos = adg_point_get_pair(adg_dim_get_pos(dim));
 501
 502     if (ref1 == NULL || ref2 == NULL || pos == NULL)
 503         return FALSE;
 504
 505     dim_style = _ADG_GET_DIM_STYLE(rdim);
 506     spacing = adg_dim_style_get_baseline_spacing(dim_style);
 507     level = adg_dim_get_level(dim);
 508     pos_distance = cpml_pair_distance(pos, ref1);
 509     vector.x = ref2->x - ref1->x;
 510     vector.y = ref2->y - ref1->y;
 511
 512     if (cpml_pair_squared_distance(pos, ref1) <
 513         cpml_pair_squared_distance(pos, ref2)) {
 514         vector.x = -vector.x;
 515         vector.y = -vector.y;
 516     }
 517
 518     /* radius */
 519     data->radius = cpml_pair_distance(&vector, NULL);
 520
 521     /* angle */
 522     data->angle = adg_dim_quote_angle(dim, cpml_vector_angle(&vector));
 523
 524     /* point.base */
 525     cpml_pair_copy(&data->point.base, &vector);
 526     cpml_vector_set_length(&data->point.base, pos_distance);
 527     data->point.base.x += ref1->x;
 528     data->point.base.y += ref1->y;
 529
 530     /* shift.base */
 531     cpml_pair_copy(&data->shift.base, &vector);
 532     cpml_vector_set_length(&data->shift.base, spacing * level);
 533
 534     data->geometry_arranged = TRUE;
 535
 536     return TRUE;
 537 }
 538
 539 static void
 540 _adg_update_entities(AdgRDim *rdim)
 541 {
 542     AdgEntity *entity;
 543     AdgRDimPrivate *data;
 544     AdgDimStyle *dim_style;
 545
 546     entity = (AdgEntity *) rdim;
 547     data = rdim->data;
 548     dim_style = _ADG_GET_DIM_STYLE(rdim);
 549
 550     if (data->trail == NULL)
 551         data->trail = adg_trail_new(_adg_trail_callback, rdim);
 552
 553     if (data->marker == NULL) {
 554         data->marker = adg_dim_style_marker2_new(dim_style);
 555         adg_entity_set_parent((AdgEntity *) data->marker, entity);
 556     }
 557 }
 558
 559 static void
 560 _adg_clear_trail(AdgRDim *rdim)
 561 {
 562     AdgRDimPrivate *data = rdim->data;
 563
 564     if (data->trail != NULL)
 565         adg_model_clear((AdgModel *) data->trail);
 566
 567     data->cpml.path.status = CAIRO_STATUS_INVALID_PATH_DATA;
 568 }
 569
 570 static void
 571 _adg_dispose_marker(AdgRDim *rdim)
 572 {
 573     AdgRDimPrivate *data = rdim->data;
 574
 575     if (data->trail != NULL) {
 576         g_object_unref(data->trail);
 577         data->trail = NULL;
 578     }
 579
 580     if (data->marker != NULL) {
 581         g_object_unref(data->marker);
 582         data->marker = NULL;
 583     }
 584 }
 585
 586 static CpmlPath *
 587 _adg_trail_callback(AdgTrail *trail, gpointer user_data)
 588 {
 589     AdgRDim *rdim;
 590     AdgRDimPrivate *data;
 591
 592     rdim = (AdgRDim *) user_data;
 593     data = rdim->data;
 594
 595     return &data->cpml.path;
 596 }