adg/adg-point.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-point
  23  * @Section_Id:AdgPoint
  24  * @title: AdgPoint
  25  * @short_description: A struct holding x, y coordinates
  26  *                     (either named or explicit)
  27  *
  28  * AdgPoint is an opaque structure that manages 2D coordinates, either
  29  * set explicitely throught adg_point_set() and adg_point_set_explicit()
  30  * or taken from a model with adg_point_set_from_model(). It can be
  31  * thought as an #AdgPair on steroid, because it adds named pair
  32  * support to a simple pairs, and thus enabling coordinates depending
  33  * on #AdgModel instances.
  34  **/
  35
  36 /**
  37  * ADG_POINT_PAIR:
  38  * @point: an #AdgPoint
  39  *
  40  * #AdgPoint is an evolution of the pair concept, but internally the
  41  * relevant data is still kept by an #AdgPair struct. This macro
  42  * gets this struct. Being declared at the start of the #AdgPoint
  43  * struct, it'd suffice to cast the point to an #AdgPair too.
  44  *
  45  * Returns: the pair of @point
  46  **/
  47
  48 /**
  49  * AdgPoint:
  50  *
  51  * This is an opaque struct: all its fields are privates.
  52  **/
  53
  54
  55 #include "adg-point.h"
  56
  57 #include <string.h>
  58
  59
  60 struct _AdgPoint {
  61     AdgPair      pair;
  62     AdgModel    *model;
  63     gchar       *name;
  64 };
  65
  66 GType
  67 adg_point_get_type(void)
  68 {
  69     static int type = 0;
  70
  71     if (G_UNLIKELY(type == 0))
  72         type = g_boxed_type_register_static("AdgPoint",
  73                                             (GBoxedCopyFunc) adg_point_dup,
  74                                             (GBoxedFreeFunc) adg_point_destroy);
  75
  76     return type;
  77 }
  78
  79 /**
  80  * adg_point_copy:
  81  * @point: an #AdgPoint
  82  * @src: the source point to copy
  83  *
  84  * Copies @src into @point.
  85  *
  86  * Returns: @point
  87  **/
  88 AdgPoint *
  89 adg_point_copy(AdgPoint *point, const AdgPoint *src)
  90 {
  91     g_return_val_if_fail(point != NULL, NULL);
  92     g_return_val_if_fail(src != NULL, NULL);
  93
  94     if (src->model != NULL)
  95         g_object_ref(src->model);
  96
  97     if (point->model != NULL)
  98         g_object_unref(point->model);
  99
 100     return memcpy(point, src, sizeof(AdgPoint));
 101 }
 102
 103 /**
 104  * adg_point_dup:
 105  * @point: an #AdgPoint structure
 106  *
 107  * Duplicates @point.
 108  *
 109  * Returns: the duplicated #AdgPoint struct or %NULL on errors
 110  **/
 111 AdgPoint *
 112 adg_point_dup(const AdgPoint *point)
 113 {
 114     g_return_val_if_fail(point != NULL, NULL);
 115
 116     if (point->model != NULL)
 117         g_object_ref(point->model);
 118
 119     return g_memdup(point, sizeof(AdgPoint));
 120 }
 121
 122 /**
 123  * adg_point_new:
 124  *
 125  * Creates a new empty #AdgPoint. The returned pointer
 126  * should be freed with adg_point_destroy() when no longer needed.
 127  *
 128  * Returns: a newly created #AdgPoint
 129  **/
 130 AdgPoint *
 131 adg_point_new(void)
 132 {
 133     return g_new0(AdgPoint, 1);
 134 }
 135
 136 /**
 137  * adg_point_destroy:
 138  * @point: an #AdgPoint
 139  *
 140  * Destroys the @point instance, unreferencing the internal model if
 141  * @point is linked to a named pair.
 142  **/
 143 void
 144 adg_point_destroy(AdgPoint *point)
 145 {
 146     g_return_if_fail(point != NULL);
 147
 148     adg_point_set_from_model(point, NULL, NULL);
 149
 150     g_free(point);
 151 }
 152
 153 /**
 154  * adg_point_set:
 155  * @point: an #AdgPoint
 156  * @pair: the #AdgPair to use
 157  *
 158  * Sets an explicit pair in @point by using the given @pair. If
 159  * @point was linked to a named pair in a model, this link is
 160  * dropped before setting the pair.
 161  **/
 162 void
 163 adg_point_set(AdgPoint *point, const AdgPair *pair)
 164 {
 165     g_return_if_fail(point != NULL);
 166     g_return_if_fail(pair != NULL);
 167
 168     adg_point_set_explicit(point, pair->x, pair->y);
 169 }
 170
 171 /**
 172  * adg_point_set_explicit:
 173  * @point: an #AdgPoint
 174  * @x: the x coordinate of the point
 175  * @y: the y coordinate of the point
 176  *
 177  * Works in the same way of adg_point_set() but accept direct numbers
 178  * instead of an #AdgPair structure.
 179  **/
 180 void
 181 adg_point_set_explicit(AdgPoint *point, gdouble x, gdouble y)
 182 {
 183     g_return_if_fail(point != NULL);
 184
 185     /* Unlink the named pair dependency, if any */
 186     adg_point_set_from_model(point, NULL, NULL);
 187
 188     point->pair.x = x;
 189     point->pair.y = y;
 190 }
 191
 192 /**
 193  * adg_point_set_from_model:
 194  * @point: an #AdgPair
 195  * @model: the #AdgModel
 196  * @name: the id of a named pair in @model
 197  *
 198  * Links the @name named pair of @model to @point, so any subsequent
 199  * call to adg_point_update() will read the named pair content. A
 200  * new reference is added to @model while the previous model (if any)
 201  * is unreferenced.
 202  *
 203  * It is allowed to use %NULL as @model, in which case the link
 204  * between @point and the named pair is dropped.
 205  **/
 206 void
 207 adg_point_set_from_model(AdgPoint *point, AdgModel *model, const gchar *name)
 208 {
 209     g_return_if_fail(point != NULL);
 210
 211     /* Check if unlinking a yet unlinked point */
 212     if (model == NULL && point->model == NULL)
 213         return;
 214
 215     /* Ensure the name is not NULL if the model is specified */
 216     if (model != NULL) {
 217         g_return_if_fail(name != NULL);
 218     }
 219
 220     /* Check if the named pair is different from the old one */
 221     if (model == point->model && strcmp(point->name, name) == 0)
 222         return;
 223
 224     if (model != NULL)
 225         g_object_ref(model);
 226
 227     if (point->model != NULL) {
 228         /* Remove the old named pair */
 229         g_object_unref(point->model);
 230         g_free(point->name);
 231         point->model = NULL;
 232         point->name = NULL;
 233     }
 234
 235     if (model != NULL) {
 236         /* Set the new named pair */
 237         point->model = model;
 238         point->name = g_strdup(name);
 239     }
 240
 241     adg_point_update(point);
 242 }
 243
 244 /**
 245  * adg_point_update:
 246  * @point: an #AdgPoint
 247  *
 248  * Updates the pair of @point. If @point is an explicit pair (either
 249  * if set with adg_point_set() or adg_point_set_explicit()), no action
 250  * is taken. If @point is linked to a named pair, instead, the internal
 251  * pair is updated with the value returned by adg_model_get_named_pair().
 252  **/
 253 void
 254 adg_point_update(AdgPoint *point)
 255 {
 256     const AdgPair *pair;
 257
 258     g_return_if_fail(point != NULL);
 259
 260     /* A point with explicit coordinates does not need to be updated */
 261     if (point->model == NULL)
 262         return;
 263
 264     pair = adg_model_get_named_pair(point->model, point->name);
 265
 266     cpml_pair_copy(&point->pair, pair);
 267 }