src/adg/adg-projection.c

   1 /* ADG - Automatic Drawing Generation
   2  * Copyright (C) 2007-2021  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-projection
  23  * @short_description: The standard symbol for specifying the projection scheme
  24  *
  25  * The #AdgProjection is an entity representing the standard symbol
  26  * of the projection scheme.
  27  *
  28  * Since: 1.0
  29  **/
  30
  31 /**
  32  * AdgProjection:
  33  *
  34  * All fields are private and should not be used directly.
  35  * Use its public methods instead.
  36  *
  37  * Since: 1.0
  38  **/
  39
  40
  41 #include "adg-internal.h"
  42 #include "adg-model.h"
  43 #include "adg-trail.h"
  44 #include "adg-path.h"
  45 #include "adg-dress.h"
  46 #include "adg-param-dress.h"
  47
  48 #include "adg-projection.h"
  49 #include "adg-projection-private.h"
  50
  51
  52 G_DEFINE_TYPE_WITH_PRIVATE(AdgProjection, adg_projection, ADG_TYPE_ENTITY)
  53
  54 enum {
  55     PROP_0,
  56     PROP_SYMBOL_DRESS,
  57     PROP_AXIS_DRESS,
  58     PROP_SCHEME
  59 };
  60
  61
  62 static void             _adg_get_property       (GObject        *object,
  63                                                  guint           param_id,
  64                                                  GValue         *value,
  65                                                  GParamSpec     *pspec);
  66 static void             _adg_set_property       (GObject        *object,
  67                                                  guint           param_id,
  68                                                  const GValue   *value,
  69                                                  GParamSpec     *pspec);
  70 static void             _adg_arrange            (AdgEntity      *entity);
  71 static void             _adg_render             (AdgEntity      *entity,
  72                                                  cairo_t        *cr);
  73 static void             _adg_arrange_class      (AdgProjectionClass *projection_class,
  74                                                  AdgProjectionScheme scheme);
  75
  76
  77 static void
  78 adg_projection_class_init(AdgProjectionClass *klass)
  79 {
  80     GObjectClass *gobject_class;
  81     AdgEntityClass *entity_class;
  82     GParamSpec *param;
  83     AdgProjectionClassPrivate *data_class;
  84
  85     gobject_class = (GObjectClass *) klass;
  86     entity_class = (AdgEntityClass *) klass;
  87
  88     gobject_class->get_property = _adg_get_property;
  89     gobject_class->set_property = _adg_set_property;
  90
  91     entity_class->arrange = _adg_arrange;
  92     entity_class->render = _adg_render;
  93
  94     param = adg_param_spec_dress("symbol-dress",
  95                                  P_("Symbol Dress"),
  96                                  P_("The line dress to use for rendering the views of the projection"),
  97                                  ADG_DRESS_LINE,
  98                                  G_PARAM_READWRITE);
  99     g_object_class_install_property(gobject_class, PROP_SYMBOL_DRESS, param);
 100
 101     param = adg_param_spec_dress("axis-dress",
 102                                  P_("Axis Dress"),
 103                                  P_("The line dress to use for rendering the axis of the projection scheme"),
 104                                  ADG_DRESS_LINE,
 105                                  G_PARAM_READWRITE);
 106     g_object_class_install_property(gobject_class, PROP_AXIS_DRESS, param);
 107
 108     param = g_param_spec_enum("scheme",
 109                               P_("Projection Scheme"),
 110                               P_("The projection scheme to be represented"),
 111                               ADG_TYPE_PROJECTION_SCHEME,
 112                               ADG_PROJECTION_SCHEME_UNDEFINED,
 113                               G_PARAM_READWRITE);
 114     g_object_class_install_property(gobject_class, PROP_SCHEME, param);
 115
 116     /* Initialize the private class data: the allocated struct is
 117      * never freed as this type is registered statically, hence
 118      * never destroyed. A better approach would be to use the old
 119      * type initialization (no G_TYPE_DEFINE and friends) that
 120      * allows to specify a custom class finalization method */
 121     data_class = g_new(AdgProjectionClassPrivate, 1);
 122
 123     data_class->scheme = ADG_PROJECTION_SCHEME_UNDEFINED;
 124     data_class->symbol = NULL;
 125     data_class->axis = NULL;
 126     data_class->extents.is_defined = FALSE;
 127
 128     klass->data_class = data_class;
 129 }
 130
 131 static void
 132 adg_projection_init(AdgProjection *projection)
 133 {
 134     AdgProjectionPrivate *data = adg_projection_get_instance_private(projection);
 135     data->symbol_dress = ADG_DRESS_LINE;
 136     data->axis_dress = ADG_DRESS_LINE;
 137     data->scheme = ADG_PROJECTION_SCHEME_UNDEFINED;
 138 }
 139
 140 static void
 141 _adg_get_property(GObject *object, guint prop_id,
 142                   GValue *value, GParamSpec *pspec)
 143 {
 144     AdgProjectionPrivate *data = adg_projection_get_instance_private((AdgProjection *) object);
 145
 146     switch (prop_id) {
 147     case PROP_SYMBOL_DRESS:
 148         g_value_set_enum(value, data->symbol_dress);
 149         break;
 150     case PROP_AXIS_DRESS:
 151         g_value_set_enum(value, data->axis_dress);
 152         break;
 153     case PROP_SCHEME:
 154         g_value_set_enum(value, data->scheme);
 155         break;
 156     default:
 157         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
 158         break;
 159     }
 160 }
 161
 162 static void
 163 _adg_set_property(GObject *object, guint prop_id,
 164                   const GValue *value, GParamSpec *pspec)
 165 {
 166     AdgProjectionPrivate *data = adg_projection_get_instance_private((AdgProjection *) object);
 167
 168     switch (prop_id) {
 169     case PROP_SYMBOL_DRESS:
 170         data->symbol_dress = g_value_get_enum(value);
 171         break;
 172     case PROP_AXIS_DRESS:
 173         data->axis_dress = g_value_get_enum(value);
 174         break;
 175     case PROP_SCHEME:
 176         data->scheme = g_value_get_enum(value);
 177         adg_entity_invalidate((AdgEntity *) object);
 178         break;
 179     default:
 180         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
 181         break;
 182     }
 183 }
 184
 185
 186 /**
 187  * adg_projection_new:
 188  * @scheme: the scheme represented by this projection
 189  *
 190  * Creates a new projection entity representing the selected @scheme.
 191  * If @scheme is invalid, a projection symbol without a scheme is
 192  * returned, that is #AdgProjection:scheme is set to
 193  * #ADG_PROJECTION_SCHEME_UNDEFINED, and a warning is raised.
 194  *
 195  * Returns: (transfer full): the newly created projection entity.
 196  *
 197  * Since: 1.0
 198  **/
 199 AdgProjection *
 200 adg_projection_new(AdgProjectionScheme scheme)
 201 {
 202     return g_object_new(ADG_TYPE_PROJECTION, "scheme", scheme, NULL);
 203 }
 204
 205 /**
 206  * adg_projection_set_symbol_dress:
 207  * @projection: an #AdgProjection
 208  * @dress: the new #AdgDress to use
 209  *
 210  * Sets a new line dress for rendering the symbol of @projection. The
 211  * new dress must be a line dress: the check is done by calling
 212  * adg_dress_are_related() with @dress and the old dress as
 213  * arguments. Check out its documentation for further details.
 214  *
 215  * The default dress is a transparent line dress: the rendering
 216  * callback will stroke the symbol using the default color with
 217  * a predefined thickness.
 218  *
 219  * Since: 1.0
 220  **/
 221 void
 222 adg_projection_set_symbol_dress(AdgProjection *projection, AdgDress dress)
 223 {
 224     g_return_if_fail(ADG_IS_PROJECTION(projection));
 225     g_object_set(projection, "symbol-dress", dress, NULL);
 226 }
 227
 228 /**
 229  * adg_projection_get_symbol_dress:
 230  * @projection: an #AdgProjection
 231  *
 232  * Gets the line dress to be used in stroking the symbol of @projection.
 233  *
 234  * Returns: (transfer none): the requested line dress.
 235  *
 236  * Since: 1.0
 237  **/
 238 AdgDress
 239 adg_projection_get_symbol_dress(AdgProjection *projection)
 240 {
 241     AdgProjectionPrivate *data;
 242
 243     g_return_val_if_fail(ADG_IS_PROJECTION(projection), ADG_DRESS_UNDEFINED);
 244
 245     data = adg_projection_get_instance_private(projection);
 246     return data->symbol_dress;
 247 }
 248
 249 /**
 250  * adg_projection_set_axis_dress:
 251  * @projection: an #AdgProjection
 252  * @dress: the new #AdgDress to use
 253  *
 254  * Sets a new line dress for rendering the axis of @projection.
 255  * The new dress must be a line dress: the check is done by
 256  * calling adg_dress_are_related() with @dress and the old
 257  * dress as arguments. Check out its documentation for
 258  * further details.
 259  *
 260  * The default dress is a transparent line dress: the rendering
 261  * callback will stroke the axis using the default line style.
 262  *
 263  * Since: 1.0
 264  **/
 265 void
 266 adg_projection_set_axis_dress(AdgProjection *projection, AdgDress dress)
 267 {
 268     g_return_if_fail(ADG_IS_PROJECTION(projection));
 269     g_object_set(projection, "axis-dress", dress, NULL);
 270 }
 271
 272 /**
 273  * adg_projection_get_axis_dress:
 274  * @projection: an #AdgProjection
 275  *
 276  * Gets the line dress to be used in stroking the axis of @projection.
 277  *
 278  * Returns: (transfer none): the requested line dress.
 279  *
 280  * Since: 1.0
 281  **/
 282 AdgDress
 283 adg_projection_get_axis_dress(AdgProjection *projection)
 284 {
 285     AdgProjectionPrivate *data;
 286
 287     g_return_val_if_fail(ADG_IS_PROJECTION(projection), ADG_DRESS_UNDEFINED);
 288
 289     data = adg_projection_get_instance_private(projection);
 290     return data->axis_dress;
 291 }
 292
 293 /**
 294  * adg_projection_set_scheme:
 295  * @projection: an #AdgProjection
 296  * @scheme: the new projection scheme
 297  *
 298  * Sets a new scheme on @projection. If @scheme is different
 299  * from the old one, @projection is invalidated.
 300  *
 301  * Since: 1.0
 302  **/
 303 void
 304 adg_projection_set_scheme(AdgProjection *projection,
 305                           AdgProjectionScheme scheme)
 306 {
 307     g_return_if_fail(ADG_IS_PROJECTION(projection));
 308     g_object_set(projection, "scheme", scheme, NULL);
 309 }
 310
 311 /**
 312  * adg_projection_get_scheme:
 313  * @projection: an #AdgProjection
 314  *
 315  * Gets the scheme represented by @projection.
 316  *
 317  * Returns: (transfer none): the scheme of @projection
 318  *
 319  * Since: 1.0
 320  **/
 321 AdgProjectionScheme
 322 adg_projection_get_scheme(AdgProjection *projection)
 323 {
 324     AdgProjectionPrivate *data;
 325
 326     g_return_val_if_fail(ADG_IS_PROJECTION(projection),
 327                          ADG_PROJECTION_SCHEME_UNDEFINED);
 328
 329     data = adg_projection_get_instance_private(projection);
 330     return data->scheme;
 331 }
 332
 333
 334 static void
 335 _adg_arrange(AdgEntity *entity)
 336 {
 337     AdgProjectionPrivate *data = adg_projection_get_instance_private((AdgProjection *) entity);
 338     AdgProjectionClass *projection_class = ADG_PROJECTION_GET_CLASS(entity);
 339     AdgProjectionClassPrivate *data_class = projection_class->data_class;
 340     CpmlExtents extents;
 341
 342     _adg_arrange_class(projection_class, data->scheme);
 343     cpml_extents_copy(&extents, &data_class->extents);
 344
 345     cpml_extents_transform(&extents, adg_entity_get_local_matrix(entity));
 346     cpml_extents_transform(&extents, adg_entity_get_global_matrix(entity));
 347     adg_entity_set_extents(entity, &extents);
 348 }
 349
 350 static void
 351 _adg_arrange_class(AdgProjectionClass *projection_class,
 352                    AdgProjectionScheme scheme)
 353 {
 354     AdgProjectionClassPrivate *data_class;
 355     AdgPath *symbol, *axis;
 356
 357     data_class = projection_class->data_class;
 358
 359     if (data_class->scheme == scheme)
 360         return;
 361
 362     if (data_class->symbol != NULL)
 363         g_object_unref(data_class->symbol);
 364
 365     if (data_class->axis != NULL)
 366         g_object_unref(data_class->axis);
 367
 368     data_class->scheme = scheme;
 369
 370     switch(scheme) {
 371     case ADG_PROJECTION_SCHEME_UNDEFINED:
 372         symbol = NULL;
 373         axis = NULL;
 374         break;
 375     case ADG_PROJECTION_SCHEME_FIRST_ANGLE:
 376         symbol = adg_path_new();
 377         adg_path_move_to_explicit(symbol, 4, 19);
 378         adg_path_line_to_explicit(symbol, 24, 24);
 379         adg_path_line_to_explicit(symbol, 24, 4);
 380         adg_path_line_to_explicit(symbol, 4, 9);
 381         adg_path_close(symbol);
 382         adg_path_move_to_explicit(symbol, 49, 14);
 383         adg_path_arc_to_explicit(symbol, 29, 14, 49, 14);
 384         adg_path_move_to_explicit(symbol, 44, 14);
 385         adg_path_arc_to_explicit(symbol, 34, 14, 44, 14);
 386
 387         axis = adg_path_new();
 388         adg_path_move_to_explicit(axis, 0, 14);
 389         adg_path_line_to_explicit(axis, 53, 14);
 390         adg_path_move_to_explicit(axis, 39, 0);
 391         adg_path_line_to_explicit(axis, 39, 28);
 392         break;
 393     case ADG_PROJECTION_SCHEME_THIRD_ANGLE:
 394         symbol = adg_path_new();
 395         adg_path_move_to_explicit(symbol, 29, 19);
 396         adg_path_line_to_explicit(symbol, 49, 24);
 397         adg_path_line_to_explicit(symbol, 49, 4);
 398         adg_path_line_to_explicit(symbol, 29, 9);
 399         adg_path_close(symbol);
 400         adg_path_move_to_explicit(symbol, 24, 14);
 401         adg_path_arc_to_explicit(symbol, 4, 14, 24, 14);
 402         adg_path_move_to_explicit(symbol, 19, 14);
 403         adg_path_arc_to_explicit(symbol, 9, 14, 19, 14);
 404
 405         axis = adg_path_new();
 406         adg_path_move_to_explicit(axis, 0, 14);
 407         adg_path_line_to_explicit(axis, 53, 14);
 408         adg_path_move_to_explicit(axis, 14, 0);
 409         adg_path_line_to_explicit(axis, 14, 28);
 410         break;
 411     default:
 412         g_return_if_reached();
 413         break;
 414     }
 415
 416     data_class->symbol = symbol;
 417     data_class->axis = axis;
 418     data_class->extents.is_defined = FALSE;
 419
 420     if (axis != NULL)
 421         cpml_extents_add(&data_class->extents,
 422                          adg_trail_get_extents((AdgTrail *) axis));
 423
 424     if (symbol != NULL)
 425         cpml_extents_add(&data_class->extents,
 426                          adg_trail_get_extents((AdgTrail *) symbol));
 427 }
 428
 429 static void
 430 _adg_render(AdgEntity *entity, cairo_t *cr)
 431 {
 432     AdgProjectionPrivate *data = adg_projection_get_instance_private((AdgProjection *) entity);
 433     AdgProjectionClassPrivate *data_class = ADG_PROJECTION_GET_CLASS(entity)->data_class;
 434     const cairo_path_t *cairo_path;
 435
 436     cairo_transform(cr, adg_entity_get_global_matrix(entity));
 437
 438     if (data_class->symbol != NULL) {
 439         cairo_path = adg_trail_get_cairo_path((AdgTrail *) data_class->symbol);
 440
 441         cairo_save(cr);
 442         cairo_transform(cr, adg_entity_get_local_matrix(entity));
 443         cairo_append_path(cr, cairo_path);
 444         cairo_restore(cr);
 445
 446         cairo_set_line_width(cr, 2);
 447         adg_entity_apply_dress(entity, data->symbol_dress, cr);
 448
 449         cairo_stroke(cr);
 450     }
 451
 452     if (data_class->axis != NULL) {
 453         const gdouble dashes[] = { 5, 2, 1, 2 };
 454
 455         cairo_path = adg_trail_get_cairo_path((AdgTrail *) data_class->axis);
 456
 457         cairo_save(cr);
 458         cairo_transform(cr, adg_entity_get_local_matrix(entity));
 459         cairo_append_path(cr, cairo_path);
 460         cairo_restore(cr);
 461
 462         cairo_set_line_width(cr, 1);
 463         cairo_set_dash(cr, dashes, G_N_ELEMENTS(dashes), -1.5);
 464         adg_entity_apply_dress(entity, data->axis_dress, cr);
 465
 466         cairo_stroke(cr);
 467     }
 468 }