cpml/cpml-path.c

   1 /* CPML - Cairo Path Manipulation Library
   2  * Copyright (C) 2008, 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 Library 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  * Library 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., 59 Temple Place - Suite 330,
  17  * Boston, MA  02111-1307, USA.
  18  */
  19
  20
  21 #include "cpml-path.h"
  22
  23 #include <string.h>
  24
  25 static cairo_bool_t     strip_leadings          (CpmlPath       *path);
  26 static cairo_bool_t     path_to_segment         (CpmlPath       *segment,
  27                                                  const CpmlPath *path);
  28 static cairo_bool_t     path_to_primitive       (CpmlPath       *primitive,
  29                                                  const CpmlPath *path);
  30
  31 /**
  32  * cpml_path_from_cairo:
  33  * @path: an allocated #CpmlPath structure
  34  * @src: the source cairo_path_t
  35  * @cr: a cairo context
  36  *
  37  * Builds a CpmlPath from a cairo_path_t structure. This operations involves
  38  * stripping the leading MOVE_TO data and setting @path->org
  39  *
  40  * @cr is used to get the current point (if needed): it can be %NULL,
  41  * in which case (0,0) will be used.
  42  *
  43  * @path and @src can be the same object (a #CpmlPath structure).
  44  *
  45  * Return value: 1 on success, 0 on errors
  46  */
  47 cairo_bool_t
  48 cpml_path_from_cairo(CpmlPath *path, const cairo_path_t *src, cairo_t *cr)
  49 {
  50         CpmlPair org = {0., 0.};
  51
  52         if (cr && cairo_has_current_point(cr))
  53                 cairo_get_current_point(cr, &org.x, &org.y);
  54
  55         return cpml_path_from_cairo_explicit(path, src, &org);
  56 }
  57
  58 /**
  59  * cpml_path_from_cairo_explicit:
  60  * @path: an allocated #CpmlPath structure
  61  * @src: the source cairo_path_t
  62  * @org: a specific origin
  63  *
  64  * Similar to cpml_path_from_cairo() but using an explicit origin.
  65  *
  66  * @path and @src can be the same object (a #CpmlPath structure).
  67  *
  68  * @org can be %NULL, in which case the original path->org pair
  69  * is left untouched.
  70  *
  71  * Return value: 1 on success, 0 on errors
  72  */
  73 cairo_bool_t
  74 cpml_path_from_cairo_explicit(CpmlPath *path, const cairo_path_t *src,
  75                               const CpmlPair *org)
  76 {
  77         if (src->status != CAIRO_STATUS_SUCCESS)
  78                 return 0;
  79
  80         if (path != (CpmlPath *) src)
  81                 memcpy(path, src, sizeof(cairo_path_t));
  82
  83         if (strip_leadings(path)) {
  84                 /* org taken from leadings MOVE_TO */
  85         } else if (path->cairo_path.status != CAIRO_STATUS_SUCCESS) {
  86                 /* Error: probably an empty path provided */
  87                 return 0;
  88         } else if (org) {
  89                 /* Use the provided org */
  90                 cpml_pair_copy(&path->org, org);
  91         }
  92
  93         return 1;
  94 }
  95
  96 /**
  97  * cpml_path_copy:
  98  * @path: an allocated #CpmlPath
  99  * @src: the source path to copy
 100  *
 101  * Strips the leading CAIRO_PATH_MOVE_TO primitives, updating the CpmlPath
 102  * structure accordling. Also the path org is update.
 103  *
 104  * Return value: @path or %NULL on errors
 105  */
 106 CpmlPath *
 107 cpml_path_copy(CpmlPath *path, const CpmlPath *src)
 108 {
 109         if (path == NULL || src == NULL)
 110                 return NULL;
 111
 112         return memcpy(path, src, sizeof(CpmlPath));
 113 }
 114
 115 /**
 116  * cpml_segment_from_path:
 117  * @segment: an allocated #CpmlPath struct
 118  * @path: the source path
 119  * @index: the segment to retrieve (starting from 1);
 120  *         %CPML_FIRST or %CPML_LAST can be used
 121  *
 122  * Gets a specific segment from a path.
 123  *
 124  * Return value: 1 if a valid segment was found, 0 on errors
 125  */
 126 cairo_bool_t
 127 cpml_segment_from_path(CpmlPath *segment, const CpmlPath *path, int index)
 128 {
 129         CpmlPath residue, result;
 130         int i;
 131
 132         if (!cpml_path_copy(&residue, path))
 133                 return 0;
 134
 135         i = 0;
 136
 137         do {
 138                 if (!path_to_segment(&result, &residue))
 139                         return index == CPML_LAST && i > 0;
 140
 141                 residue.cairo_path.data += result.cairo_path.num_data;
 142                 residue.cairo_path.num_data -= result.cairo_path.num_data;
 143                 ++i;
 144
 145                 if (index == CPML_LAST) {
 146                         cpml_path_copy(segment, &result);
 147                         continue;
 148                 }
 149         } while (i < index);
 150
 151         cpml_path_copy(segment, &result);
 152         return 1;
 153 }
 154
 155 /**
 156  * cpml_primitive_from_path:
 157  * @primitive: an allocated #CpmlPath struct
 158  * @path: the source path
 159  * @index: the primitive to retrieve (starting from 1);
 160  *         %CPML_FIRST or %CPML_LAST can be used
 161  *
 162  * Gets a specific primitive from a path.
 163  *
 164  * Return value: 1 if a valid primitive was found, 0 on errors
 165  */
 166 cairo_bool_t
 167 cpml_primitive_from_path(CpmlPath *primitive, const CpmlPath *path, int index)
 168 {
 169         CpmlPath residue, result;
 170         int i;
 171
 172         if (!cpml_path_copy(&residue, path))
 173                 return 0;
 174
 175         i = 0;
 176
 177         do {
 178                 if (!path_to_primitive(&result, &residue))
 179                         return index == CPML_LAST && i > 0;
 180
 181                 residue.cairo_path.data += result.cairo_path.num_data;
 182                 residue.cairo_path.num_data -= result.cairo_path.num_data;
 183                 ++i;
 184
 185                 if (index == CPML_LAST) {
 186                         cpml_path_copy(primitive, &result);
 187                         continue;
 188                 }
 189         } while (i < index);
 190
 191         cpml_path_copy(primitive, &result);
 192         return 1;
 193 }
 194
 195 /**
 196  * cpml_primitive_get_pair:
 197  * @primitive: the source primitive
 198  * @pair: the allocated CpmlPair destination
 199  * @index: index of the pair to retrieve, starting from 1
 200  *
 201  * Shortcut to get a pair from a primitive.
 202  *
 203  * Return value: 1 on success, 0 on errors
 204  */
 205 cairo_bool_t
 206 cpml_primitive_get_pair(const CpmlPath *primitive, CpmlPair *pair, int index)
 207 {
 208         cairo_path_data_t *data = primitive->cairo_path.data;
 209
 210         if (index == 0 || index > data[0].header.length)
 211                 return 0;
 212
 213         pair->x = data[index].point.x;
 214         pair->y = data[index].point.y;
 215         return 1;
 216 }
 217
 218 /**
 219  * cpml_primitive_set_pair:
 220  * @primitive: an allocated CpmlPath primitive
 221  * @pair: the source pair
 222  * @index: index of the pair to change, starting from 1
 223  *
 224  * Shortcut to set a pair on a primitive.
 225  *
 226  * Return value: 1 on success, 0 on errors
 227  */
 228 cairo_bool_t
 229 cpml_primitive_set_pair(CpmlPath *primitive, const CpmlPair *pair, int index)
 230 {
 231         cairo_path_data_t *data = primitive->cairo_path.data;
 232
 233         if (index == 0 || index > data[0].header.length)
 234                 return 0;
 235
 236         data[index].point.x = pair->x;
 237         data[index].point.y = pair->y;
 238         return 1;
 239 }
 240
 241 /**
 242  * cpml_primitive_get_point:
 243  * @primitive: the source primitive
 244  * @point: the allocated CpmlPair destination
 245  * @pos: the position factor, being 0 the starting and 1 the ending point
 246  *
 247  * Gets a point lying on @primitive at a specific percentual position.
 248  *
 249  * Return value: 1 on success, 0 on errors
 250  */
 251 cairo_bool_t
 252 cpml_primitive_get_point(const CpmlPath *primitive,
 253                          CpmlPair *point, double pos)
 254 {
 255         int type = primitive->cairo_path.data[0].header.type;
 256
 257         if (type != CAIRO_PATH_CLOSE_PATH && type != CAIRO_PATH_LINE_TO &&
 258             type != CAIRO_PATH_CURVE_TO)
 259                 return 0;
 260
 261         /* Common cases */
 262         if (type == CAIRO_PATH_CLOSE_PATH || pos == 0.) {
 263                 return cpml_pair_copy(point, &primitive->org);
 264         } else if (pos == 1.0) {
 265                 int n = type == CAIRO_PATH_LINE_TO ? 1 : 3;
 266                 return cpml_primitive_get_pair(primitive, point, n);
 267         }
 268
 269         /* TODO */
 270         return 0;
 271 }
 272
 273 /**
 274  * cpml_primitive_reverse:
 275  * @primitive: an allocated #CpmlPath struct
 276  *
 277  * Reverses a primitive.
 278  *
 279  * Return value: 1 on success, 0 on errors
 280  */
 281 cairo_bool_t
 282 cpml_primitive_reverse(CpmlPath *primitive)
 283 {
 284         CpmlPair tmp;
 285
 286         switch (primitive->cairo_path.data[0].header.type) {
 287         case CAIRO_PATH_LINE_TO:
 288                 cpml_pair_copy(&tmp, &primitive->org);
 289                 cpml_primitive_get_pair(primitive, &primitive->org, 1);
 290                 cpml_primitive_set_pair(primitive, &tmp, 1);
 291                 break;
 292         case CAIRO_PATH_CURVE_TO:
 293                 cpml_pair_copy(&tmp, &primitive->org);
 294                 cpml_primitive_get_pair(primitive, &primitive->org, 3);
 295                 cpml_primitive_set_pair(primitive, &tmp, 3);
 296
 297                 cpml_primitive_get_pair(primitive, &tmp, 2);
 298                 primitive->cairo_path.data[2].point.x =
 299                         primitive->cairo_path.data[3].point.x;
 300                 primitive->cairo_path.data[2].point.y =
 301                         primitive->cairo_path.data[3].point.y;
 302                 cpml_primitive_set_pair(primitive, &tmp, 3);
 303                 break;
 304         default:
 305                 return 0;
 306         }
 307
 308         return 1;
 309 }
 310
 311 /**
 312  * strip_leadings:
 313  * @path: a #CpmlPath
 314  *
 315  * Strips the leading CAIRO_PATH_MOVE_TO primitives, updating the CpmlPath
 316  * structure accordling. Also the path org is update.
 317  *
 318  * Return value: 1 on success, 0 on no leading MOVE_TOs or on errors
 319  *               (check for path->cairo_path.status == CAIRO_STATUS_SUCCESS)
 320  */
 321 static cairo_bool_t
 322 strip_leadings(CpmlPath *path)
 323 {
 324         if (path->cairo_path.data[0].header.type != CAIRO_PATH_MOVE_TO)
 325                 return 0;
 326
 327         do {
 328                 ++path->cairo_path.data;
 329                 path->org.x = path->cairo_path.data->point.x;
 330                 path->org.y = path->cairo_path.data->point.y;
 331                 ++path->cairo_path.data;
 332                 path->cairo_path.num_data -= 2;
 333                 if (path->cairo_path.num_data <= 0) {
 334                         path->cairo_path.status =
 335                                 CAIRO_STATUS_INVALID_PATH_DATA;
 336                         return 0;
 337                 }
 338         } while (path->cairo_path.data->header.type == CAIRO_PATH_MOVE_TO);
 339
 340         return 1;
 341 }
 342
 343 /**
 344  * path_to_segment:
 345  * @segment: an allocated #CpmlPath struct
 346  * @path: the source path
 347  *
 348  * Converts a path to a segment. @segment and @path can be the same struct.
 349  *
 350  * Return value: 1 if a valid segment is found, 0 on errors
 351  */
 352 static cairo_bool_t
 353 path_to_segment(CpmlPath *segment, const CpmlPath *path)
 354 {
 355         cairo_path_data_t *path_data;
 356         int i;
 357
 358         if (segment != path)
 359                 cpml_path_copy(segment, path);
 360
 361         if (!strip_leadings(segment) &&
 362             segment->cairo_path.status != CAIRO_STATUS_SUCCESS)
 363                 return 0;
 364
 365         path_data = segment->cairo_path.data;
 366         i = 0;
 367
 368         do {
 369                 if (path_data->header.type == CAIRO_PATH_MOVE_TO) {
 370                         --i;
 371                         break;
 372                 } else if (path_data->header.type == CAIRO_PATH_CLOSE_PATH) {
 373                         break;
 374                 }
 375                 i += path_data->header.length;
 376                 path_data += path_data->header.length;
 377         } while (i < segment->cairo_path.num_data);
 378
 379         segment->cairo_path.num_data = i;
 380         return 1;
 381 }
 382
 383 /**
 384  * path_to_primitive:
 385  * @primitive: an allocated #CpmlPath struct
 386  * @path: the source path
 387  *
 388  * Converts a path to a primitive. @primitive and @path can be the same struct.
 389  *
 390  * Return value: 1 if a valid primitive is found, 0 on errors
 391  */
 392 static cairo_bool_t
 393 path_to_primitive(CpmlPath *primitive, const CpmlPath *path)
 394 {
 395         cairo_path_data_t *path_data;
 396
 397         if (primitive != path)
 398                 cpml_path_copy(primitive, path);
 399
 400         if (!strip_leadings(primitive) &&
 401             primitive->cairo_path.status != CAIRO_STATUS_SUCCESS)
 402                 return 0;
 403
 404         primitive->cairo_path.num_data = 1;
 405         return 1;
 406 }