adg/adg-marker.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-marker
  23  * @short_description: Base entity for markers
  24  *
  25  * A marker is an entity to be applied at the start or end of a segment.
  26  * Typical examples include arrows, ticks, dots and so on.
  27  *
  28  * The #AdgMarker:path and #AdgMarker:n-segment properties specify the
  29  * segment where the marker should be applied. Similarly to the
  30  * #AdgStroke type, if the associated path is destroyed the above
  31  * properties are unset.
  32  *
  33  * Use adg_marker_set_pos() to select the position where the marker
  34  * should be put: %0 means the start point of the segment while %1
  35  * means the end point.
  36  *
  37  * The #AdgMarker:model property and APIs are intended only for marker
  38  * implementation purposes.
  39  **/
  40
  41 /**
  42  * AdgMarker:
  43  *
  44  * All fields are privates and should not be used directly.
  45  * Use its public methods instead.
  46  **/
  47
  48
  49 #include "adg-marker.h"
  50 #include "adg-marker-private.h"
  51 #include "adg-intl.h"
  52
  53 #define PARENT_OBJECT_CLASS  ((GObjectClass *) adg_marker_parent_class)
  54
  55
  56 enum {
  57     PROP_0,
  58     PROP_PATH,
  59     PROP_N_SEGMENT,
  60     PROP_POS,
  61     PROP_SIZE,
  62     PROP_MODEL
  63 };
  64
  65
  66 static void             dispose                 (GObject        *object);
  67 static void             get_property            (GObject        *object,
  68                                                  guint           prop_id,
  69                                                  GValue         *value,
  70                                                  GParamSpec     *pspec);
  71 static void             set_property            (GObject        *object,
  72                                                  guint           prop_id,
  73                                                  const GValue   *value,
  74                                                  GParamSpec     *pspec);
  75 static gboolean         invalidate              (AdgEntity      *entity);
  76 static gboolean         set_path                (AdgMarker      *marker,
  77                                                  AdgPath        *path);
  78 static void             unset_path              (AdgMarker      *marker);
  79 static gboolean         set_n_segment           (AdgMarker      *marker,
  80                                                  gint            n_segment);
  81 static gboolean         set_pos                 (AdgMarker      *marker,
  82                                                  gdouble         pos);
  83 static gboolean         set_size                (AdgMarker      *marker,
  84                                                  gdouble         size);
  85 static gboolean         set_model               (AdgMarker      *marker,
  86                                                  AdgModel       *model);
  87 static AdgModel *       create_model            (AdgMarker      *marker);
  88
  89
  90 G_DEFINE_ABSTRACT_TYPE(AdgMarker, adg_marker, ADG_TYPE_ENTITY);
  91
  92
  93 static void
  94 adg_marker_class_init(AdgMarkerClass *klass)
  95 {
  96     GObjectClass *gobject_class;
  97     AdgEntityClass *entity_class;
  98     GParamSpec *param;
  99
 100     gobject_class = (GObjectClass *) klass;
 101     entity_class = (AdgEntityClass *) klass;
 102
 103     g_type_class_add_private(klass, sizeof(AdgMarkerPrivate));
 104
 105     gobject_class->dispose = dispose;
 106     gobject_class->set_property = set_property;
 107     gobject_class->get_property = get_property;
 108
 109     entity_class->invalidate = invalidate;
 110
 111     klass->create_model = create_model;
 112
 113     param = g_param_spec_object("path",
 114                                 P_("Path"),
 115                                 P_("The subject path for this marker"),
 116                                 ADG_TYPE_PATH,
 117                                 G_PARAM_CONSTRUCT|G_PARAM_READWRITE);
 118     g_object_class_install_property(gobject_class, PROP_PATH, param);
 119
 120     param = g_param_spec_uint("n-segment",
 121                               P_("Segment Index"),
 122                               P_("The segment of path where this marker should be applied (where 0 means undefined segment, 1 the first segment and so on)"),
 123                               0, G_MAXUINT, 0,
 124                               G_PARAM_CONSTRUCT|G_PARAM_READWRITE);
 125     g_object_class_install_property(gobject_class, PROP_N_SEGMENT, param);
 126
 127     param = g_param_spec_double("pos",
 128                                 P_("Position"),
 129                                 P_("The position ratio inside the segment where to put the marker (0 means the start point while 1 means the end point)"),
 130                                 0, 1, 0,
 131                                 G_PARAM_CONSTRUCT|G_PARAM_READWRITE);
 132     g_object_class_install_property(gobject_class, PROP_POS, param);
 133
 134     param = g_param_spec_double("size",
 135                                 P_("Marker Size"),
 136                                 P_("The size (in global space) of the marker"),
 137                                 0, G_MAXDOUBLE, 12,
 138                                 G_PARAM_READWRITE);
 139     g_object_class_install_property(gobject_class, PROP_SIZE, param);
 140
 141     param = g_param_spec_object("model",
 142                                 P_("Model"),
 143                                 P_("A general purpose model usable by the marker implementations"),
 144                                 ADG_TYPE_MODEL,
 145                                 G_PARAM_READWRITE);
 146     g_object_class_install_property(gobject_class, PROP_MODEL, param);
 147 }
 148
 149 static void
 150 adg_marker_init(AdgMarker *marker)
 151 {
 152     AdgMarkerPrivate *data = G_TYPE_INSTANCE_GET_PRIVATE(marker,
 153                                                          ADG_TYPE_MARKER,
 154                                                          AdgMarkerPrivate);
 155     data->path = NULL;
 156     data->n_segment = 0;
 157     data->backup_segment = NULL;
 158     memset(&data->segment, 0, sizeof(data->segment));
 159     data->pos = 0;
 160     data->size = 10;
 161     data->model = NULL;
 162
 163     marker->data = data;
 164 }
 165
 166 static void
 167 dispose(GObject *object)
 168 {
 169     AdgMarker *marker = (AdgMarker *) object;
 170
 171     adg_marker_set_model(marker, NULL);
 172     adg_marker_set_path(marker, NULL);
 173
 174     if (PARENT_OBJECT_CLASS->dispose != NULL)
 175         PARENT_OBJECT_CLASS->dispose(object);
 176 }
 177
 178
 179 static void
 180 get_property(GObject *object,
 181              guint prop_id, GValue *value, GParamSpec *pspec)
 182 {
 183     AdgMarkerPrivate *data = ((AdgMarker *) object)->data;
 184
 185     switch (prop_id) {
 186     case PROP_PATH:
 187         g_value_set_object(value, data->path);
 188         break;
 189     case PROP_N_SEGMENT:
 190         g_value_set_uint(value, data->n_segment);
 191         break;
 192     case PROP_POS:
 193         g_value_set_double(value, data->pos);
 194         break;
 195     case PROP_SIZE:
 196         g_value_set_double(value, data->size);
 197         break;
 198     case PROP_MODEL:
 199         g_value_set_object(value, data->model);
 200         break;
 201     default:
 202         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
 203         break;
 204     }
 205 }
 206
 207 static void
 208 set_property(GObject *object,
 209              guint prop_id, const GValue *value, GParamSpec *pspec)
 210 {
 211     AdgMarker *marker = (AdgMarker *) object;
 212
 213     switch (prop_id) {
 214     case PROP_PATH:
 215         set_path(marker, g_value_get_object(value));
 216         break;
 217     case PROP_N_SEGMENT:
 218         set_n_segment(marker, g_value_get_uint(value));
 219         break;
 220     case PROP_POS:
 221         set_pos(marker, g_value_get_double(value));
 222         break;
 223     case PROP_SIZE:
 224         set_size(marker, g_value_get_double(value));
 225         break;
 226     case PROP_MODEL:
 227         set_model(marker, g_value_get_object(value));
 228         break;
 229     default:
 230         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
 231         break;
 232     }
 233 }
 234
 235
 236 /**
 237  * adg_marker_get_path:
 238  * @marker: an #AdgMarker
 239  *
 240  * Gets the path where this marker should be applied.
 241  *
 242  * Returns: the path owned by @marker or %NULL on errors
 243  **/
 244 AdgPath *
 245 adg_marker_get_path(AdgMarker *marker)
 246 {
 247     AdgMarkerPrivate *data;
 248
 249     g_return_val_if_fail(ADG_IS_MARKER(marker), NULL);
 250
 251     data = marker->data;
 252
 253     return data->path;
 254 }
 255
 256 /**
 257  * adg_marker_set_path:
 258  * @marker: an #AdgMarker
 259  * @path: a new #AdgPath
 260  *
 261  * Sets a new path where the marker should be applied. The weak reference
 262  * to the old path (if an old path was present) is dropped while a new
 263  * weak reference is added to @path. If @path is destroyed, the weak
 264  * reference callback will automatically unset #AdgMarker:path and will
 265  * set #AdgMarker:n-segment to %0.
 266  *
 267  * After setting a new path, the #AdgMarker:n-segment property is
 268  * reset to %1. This means the first segment of the path is always
 269  * selected by default.
 270  **/
 271 void
 272 adg_marker_set_path(AdgMarker *marker, AdgPath *path)
 273 {
 274     g_return_if_fail(ADG_IS_MARKER(marker));
 275
 276     if (set_path(marker, path))
 277         g_object_notify((GObject *) marker, "path");
 278 }
 279
 280 /**
 281  * adg_marker_get_n_segment:
 282  * @marker: an #AdgMarker
 283  *
 284  * Returns the segment of the associated path where this marker
 285  * should be applied, where %1 is the first segment.
 286  *
 287  * Returns: an index greather than %0 on success or %0 on errors
 288  **/
 289 gint
 290 adg_marker_get_n_segment(AdgMarker *marker)
 291 {
 292     AdgMarkerPrivate *data;
 293
 294     g_return_val_if_fail(ADG_IS_MARKER(marker), 0);
 295
 296     data = marker->data;
 297
 298     return data->n_segment;
 299 }
 300
 301 /**
 302  * adg_marker_set_n_segment:
 303  * @marker: an #AdgMarker
 304  * @n_segment: a new segment index
 305  *
 306  * Sets a new segment to use. @n_segment is expected to be greather than
 307  * %0 and to not exceed the number of segments in the underlying path.
 308  * By convention, %1 is the first segment.
 309  **/
 310 void
 311 adg_marker_set_n_segment(AdgMarker *marker, gint n_segment)
 312 {
 313     g_return_if_fail(ADG_IS_MARKER(marker));
 314
 315     if (set_n_segment(marker, n_segment))
 316         g_object_notify((GObject *) marker, "n-segment");
 317 }
 318
 319 /**
 320  * adg_marker_get_backup_segment:
 321  * @marker: an #AdgMarker
 322  *
 323  * <note><para>
 324  * This function is only useful in marker implementations.
 325  * </para></note>
 326  *
 327  * Gets the original segment where the marker has been applied.
 328  * Applying a marker could modify the underlying path, usually
 329  * by trimming the original segment of a #AdgMarker:size dependent
 330  * length from the end. The marker instance holds a copy of the
 331  * original segment, got using adg_segment_deep_dup(), to be used
 332  * in recomputation (when the marker changes size, for instance).
 333  *
 334  * When the subject segment is changed (either by changing
 335  * #AdgMarker:path or #AdgMarker:n-segment) the original segment
 336  * is restored.
 337  *
 338  * Returns: the original segment or %NULL on errors
 339  **/
 340 const AdgSegment *
 341 adg_marker_get_backup_segment(AdgMarker *marker)
 342 {
 343     AdgMarkerPrivate *data;
 344
 345     g_return_val_if_fail(ADG_IS_MARKER(marker), NULL);
 346
 347     data = marker->data;
 348
 349     return data->backup_segment;
 350 }
 351
 352 /**
 353  * adg_marker_get_segment:
 354  * @marker: an #AdgMarker
 355  *
 356  * <note><para>
 357  * This function is only useful in marker implementations.
 358  * </para></note>
 359  *
 360  * Gets the segment where the marker will be applied. This segment
 361  * is eventually a modified version of the backup segment, after
 362  * having applied the marker.
 363  *
 364  * Returns: the segment or %NULL on errors
 365  **/
 366 AdgSegment *
 367 adg_marker_get_segment(AdgMarker *marker)
 368 {
 369     AdgMarkerPrivate *data;
 370
 371     g_return_val_if_fail(ADG_IS_MARKER(marker), NULL);
 372
 373     data = marker->data;
 374
 375     return &data->segment;
 376 }
 377
 378 /**
 379  * adg_marker_get_pos:
 380  * @marker: an #AdgMarker
 381  *
 382  * Gets the current position of @marker. The returned value is a ratio
 383  * position referred to the segment associated to @marker: %0 means the
 384  * start point and %1 means the end point of the segment.
 385  *
 386  * Returns: the marker position
 387  **/
 388 gdouble
 389 adg_marker_get_pos(AdgMarker *marker)
 390 {
 391     AdgMarkerPrivate *data;
 392
 393     g_return_val_if_fail(ADG_IS_MARKER(marker), 0);
 394
 395     data = marker->data;
 396
 397     return data->pos;
 398 }
 399
 400 /**
 401  * adg_marker_set_pos:
 402  * @marker: an #AdgMarker
 403  * @pos: the new pos
 404  *
 405  * Sets a new position on @marker. Check out adg_marker_get_pos() for
 406  * details on what @pos represents.
 407  **/
 408 void
 409 adg_marker_set_pos(AdgMarker *marker, gdouble pos)
 410 {
 411     g_return_if_fail(ADG_IS_MARKER(marker));
 412
 413     if (set_pos(marker, pos))
 414         g_object_notify((GObject *) marker, "pos");
 415 }
 416
 417 /**
 418  * adg_marker_get_size:
 419  * @marker: an #AdgMarker
 420  *
 421  * Gets the current size of @marker.
 422  *
 423  * Returns: the marker size, in global space
 424  **/
 425 gdouble
 426 adg_marker_get_size(AdgMarker *marker)
 427 {
 428     AdgMarkerPrivate *data;
 429
 430     g_return_val_if_fail(ADG_IS_MARKER(marker), 0);
 431
 432     data = marker->data;
 433
 434     return data->size;
 435 }
 436
 437 /**
 438  * adg_marker_set_size:
 439  * @marker: an #AdgMarker
 440  * @size: the new size
 441  *
 442  * Sets a new size on @marker. The @size is an implementation-dependent
 443  * property: it has meaning only when used by an #AdgMarker derived type.
 444  **/
 445 void
 446 adg_marker_set_size(AdgMarker *marker, gdouble size)
 447 {
 448     g_return_if_fail(ADG_IS_MARKER(marker));
 449
 450     if (set_size(marker, size))
 451         g_object_notify((GObject *) marker, "size");
 452 }
 453
 454 /**
 455  * adg_marker_model:
 456  * @marker: an #AdgMarker
 457  *
 458  * <note><para>
 459  * This function is only useful in marker implementations.
 460  * </para></note>
 461  *
 462  * Gets the model of @marker. If the model is not found, it is
 463  * automatically created by calling the create_model() virtual method.
 464  *
 465  * Returns: the current model owned by @marker or %NULL on errors
 466  **/
 467 AdgModel *
 468 adg_marker_model(AdgMarker *marker)
 469 {
 470     AdgMarkerPrivate *data;
 471
 472     g_return_val_if_fail(ADG_IS_MARKER(marker), NULL);
 473
 474     data = marker->data;
 475
 476     if (data->model == NULL) {
 477         /* Model not found: regenerate it */
 478         AdgMarkerClass *marker_class = ADG_MARKER_GET_CLASS(marker);
 479
 480         adg_marker_set_model(marker, marker_class->create_model(marker));
 481     }
 482
 483     return data->model;
 484 }
 485
 486 /**
 487  * adg_marker_get_model:
 488  * @marker: an #AdgMarker
 489  *
 490  * <note><para>
 491  * This function is only useful in marker implementations.
 492  * </para></note>
 493  *
 494  * Gets the current model of @marker. This is an accessor method:
 495  * if you need to get the model for rendering, use adg_marker_model()
 496  * instead.
 497  *
 498  * Returns: the cached model owned by @marker or %NULL on errors
 499  **/
 500 AdgModel *
 501 adg_marker_get_model(AdgMarker *marker)
 502 {
 503     AdgMarkerPrivate *data;
 504
 505     g_return_val_if_fail(ADG_IS_MARKER(marker), NULL);
 506
 507     data = marker->data;
 508
 509     return data->model;
 510 }
 511
 512 /**
 513  * adg_marker_set_model:
 514  * @marker: an #AdgMarker
 515  * @model: a new #AdgModel
 516  *
 517  * <note><para>
 518  * This function is only useful in marker implementations.
 519  * </para></note>
 520  *
 521  * Sets a new model for @marker. The reference to the old model (if an
 522  * old model was present) is dropped while a new reference is added to
 523  * @model.
 524  **/
 525 void
 526 adg_marker_set_model(AdgMarker *marker, AdgModel *model)
 527 {
 528     g_return_if_fail(ADG_IS_MARKER(marker));
 529
 530     if (set_model(marker, model))
 531         g_object_notify((GObject *) marker, "model");
 532 }
 533
 534
 535 static gboolean
 536 invalidate(AdgEntity *entity)
 537 {
 538     AdgMarker *marker = (AdgMarker *) entity;
 539
 540     adg_marker_set_model(marker, NULL);
 541
 542     return TRUE;
 543 }
 544
 545
 546 static gboolean
 547 set_path(AdgMarker *marker, AdgPath *path)
 548 {
 549     AdgMarkerPrivate *data;
 550     AdgEntity *entity;
 551
 552     data = marker->data;
 553
 554     if (path == data->path)
 555         return FALSE;
 556
 557     entity = (AdgEntity *) marker;
 558
 559     if (data->path != NULL) {
 560         /* Restore the original segment in the old path */
 561         set_n_segment(marker, 0);
 562
 563         g_object_weak_unref((GObject *) data->path,
 564                             (GWeakNotify) unset_path, marker);
 565         adg_model_remove_dependency((AdgModel *) data->path, entity);
 566     }
 567
 568     data->path = path;
 569
 570     if (data->path != NULL) {
 571         g_object_weak_ref((GObject *) data->path,
 572                           (GWeakNotify) unset_path, marker);
 573         adg_model_add_dependency((AdgModel *) data->path, entity);
 574
 575         /* Set the first segment by default */
 576         set_n_segment(marker, 1);
 577     }
 578
 579     return TRUE;
 580 }
 581
 582 static void
 583 unset_path(AdgMarker *marker)
 584 {
 585     AdgMarkerPrivate *data = marker->data;
 586
 587     if (data->path != NULL) {
 588         data->path = NULL;
 589         set_n_segment(marker, 0);
 590     }
 591 }
 592
 593 static gboolean
 594 set_n_segment(AdgMarker *marker, gint n_segment)
 595 {
 596     AdgMarkerPrivate *data = marker->data;
 597
 598     if (n_segment == data->n_segment)
 599         return FALSE;
 600
 601     if (data->n_segment > 0) {
 602         g_assert(data->backup_segment != NULL);
 603
 604         /* Restore the original segment */
 605         adg_segment_deep_copy(&data->segment, data->backup_segment);
 606     }
 607
 608     if (data->backup_segment != NULL) {
 609         g_free(data->backup_segment);
 610         data->backup_segment = NULL;
 611     }
 612
 613     if (n_segment > 0) {
 614         data->n_segment = 0;
 615         g_return_val_if_fail(data->path != NULL, FALSE);
 616
 617         if (!adg_path_get_segment(data->path,
 618                                   &data->segment, data->n_segment))
 619             return FALSE;
 620
 621         /* Backup the segment */
 622         data->backup_segment = adg_segment_deep_dup(&data->segment);
 623     }
 624
 625     data->n_segment = n_segment;
 626
 627     return TRUE;
 628 }
 629
 630 static gboolean
 631 set_pos(AdgMarker *marker, gdouble pos)
 632 {
 633     AdgMarkerPrivate *data = marker->data;
 634
 635     if (pos == data->pos)
 636         return FALSE;
 637
 638     data->pos = pos;
 639
 640     return TRUE;
 641 }
 642
 643 static gboolean
 644 set_size(AdgMarker *marker, gdouble size)
 645 {
 646     AdgMarkerPrivate *data = marker->data;
 647
 648     if (size == data->size)
 649         return FALSE;
 650
 651     data->size = size;
 652
 653     return TRUE;
 654 }
 655
 656 static gboolean
 657 set_model(AdgMarker *marker, AdgModel *model)
 658 {
 659     AdgMarkerPrivate *data = marker->data;
 660
 661     if (model == data->model)
 662         return FALSE;
 663
 664     if (data->model != NULL)
 665         g_object_unref((GObject *) data->model);
 666
 667     data->model = model;
 668
 669     if (data->model != NULL)
 670         g_object_ref((GObject *) data->model);
 671
 672     return TRUE;
 673 }
 674
 675 static AdgModel *
 676 create_model(AdgMarker *marker)
 677 {
 678     g_warning("%s: `create_model' method not implemented for type `%s'",
 679               G_STRLOC, g_type_name(G_OBJECT_TYPE(marker)));
 680     return NULL;
 681 }