src/c/sk_path.cpp

   1 /*
   2  * Copyright 2016 Xamarin Inc.
   3  *
   4  * Use of this source code is governed by a BSD-style license that can be
   5  * found in the LICENSE file.
   6  */
   7
   8 #include "SkPath.h"
   9 #include "SkPathOps.h"
  10 #include "SkParsePath.h"
  11
  12 #include "sk_path.h"
  13
  14 #include "sk_types_priv.h"
  15
  16 void sk_path_rmove_to(sk_path_t* cpath, float dx, float dy) {
  17     AsPath(cpath)->rMoveTo(dx, dy);
  18 }
  19
  20 void sk_path_rline_to(sk_path_t* cpath, float dx, float dy) {
  21     AsPath(cpath)->rLineTo(dx, dy);
  22 }
  23
  24 void sk_path_rquad_to(sk_path_t* cpath, float dx0, float dy0, float dx1, float dy1) {
  25     AsPath(cpath)->rQuadTo(dx0, dy0, dx1, dy1);
  26 }
  27
  28 void sk_path_rconic_to(sk_path_t* cpath, float dx0, float dy0, float dx1, float dy1, float w) {
  29     AsPath(cpath)->rConicTo(dx0, dy0, dx1, dy1, w);
  30 }
  31
  32 void sk_path_rcubic_to(sk_path_t* cpath, float dx0, float dy0, float dx1, float dy1, float dx2, float dy2) {
  33     AsPath(cpath)->rCubicTo(dx0, dy0, dx1, dy1, dx2, dy2);
  34 }
  35
  36 void sk_path_add_rect_start(sk_path_t* cpath, const sk_rect_t* crect, sk_path_direction_t cdir, uint32_t startIndex) {
  37     AsPath(cpath)->addRect(AsRect(*crect), (SkPath::Direction)cdir, startIndex);
  38 }
  39
  40 void sk_path_add_arc(sk_path_t* cpath, const sk_rect_t* crect, float startAngle, float sweepAngle) {
  41     AsPath(cpath)->addArc(AsRect(*crect), startAngle, sweepAngle);
  42 }
  43
  44 void sk_path_set_filltype(sk_path_t* cpath, sk_path_filltype_t cfilltype) {
  45     AsPath(cpath)->setFillType((SkPath::FillType)cfilltype);
  46 }
  47
  48 sk_path_filltype_t sk_path_get_filltype(sk_path_t *cpath) {
  49     return (sk_path_filltype_t)AsPath(cpath)->getFillType();
  50 }
  51
  52 void sk_path_transform(sk_path_t* cpath, const sk_matrix_t* cmatrix)
  53 {
  54     SkMatrix matrix;
  55     if (cmatrix) {
  56         from_c(cmatrix, &matrix);
  57     }
  58     return AsPath(cpath)->transform(matrix);
  59 }
  60
  61 sk_path_t* sk_path_clone(const sk_path_t* cpath)
  62 {
  63     return (sk_path_t*)new SkPath(AsPath(*cpath));
  64 }
  65
  66 void sk_path_rewind (sk_path_t* cpath)
  67 {
  68     AsPath (cpath)->rewind ();
  69 }
  70
  71 void sk_path_reset (sk_path_t* cpath)
  72 {
  73     AsPath (cpath)->reset ();
  74 }
  75
  76 sk_path_iterator_t* sk_path_create_iter (sk_path_t *cpath, int forceClose)
  77 {
  78     SkPath::Iter* iter = new SkPath::Iter(AsPath(*cpath), forceClose);
  79     return ToPathIter(iter);
  80 }
  81
  82 sk_path_verb_t sk_path_iter_next (sk_path_iterator_t *iterator, sk_point_t points [4], int doConsumeDegenerates, int exact)
  83 {
  84     SkPath::Iter *iter = AsPathIter(iterator);
  85     SkPoint *pts = AsPoint(points);
  86     SkPath::Verb verb = iter->next(pts, doConsumeDegenerates, exact);
  87     return (sk_path_verb_t)verb;
  88 }
  89
  90 float sk_path_iter_conic_weight (sk_path_iterator_t *iterator)
  91 {
  92     return AsPathIter(iterator)->conicWeight ();
  93 }
  94
  95 int sk_path_iter_is_close_line (sk_path_iterator_t *iterator)
  96 {
  97     return AsPathIter(iterator)->isCloseLine ();
  98 }
  99
 100 int sk_path_iter_is_closed_contour (sk_path_iterator_t *iterator)
 101 {
 102     return AsPathIter(iterator)->isClosedContour ();
 103 }
 104
 105 void sk_path_iter_destroy (sk_path_iterator_t *iterator)
 106 {
 107     delete AsPathIter (iterator);
 108 }
 109
 110 sk_path_rawiterator_t* sk_path_create_rawiter (sk_path_t *cpath)
 111 {
 112     SkPath::RawIter* iter = new SkPath::RawIter(AsPath(*cpath));
 113     return ToPathRawIter(iter);
 114 }
 115
 116 sk_path_verb_t sk_path_rawiter_next (sk_path_rawiterator_t *iterator, sk_point_t points [4])
 117 {
 118     SkPath::RawIter *iter = AsPathRawIter(iterator);
 119     SkPoint *pts = AsPoint(points);
 120     SkPath::Verb verb = iter->next(pts);
 121     return (sk_path_verb_t)verb;
 122 }
 123
 124 sk_path_verb_t sk_path_rawiter_peek (sk_path_rawiterator_t *iterator)
 125 {
 126     return (sk_path_verb_t) AsPathRawIter(iterator)->peek ();
 127 }
 128
 129 float sk_path_rawiter_conic_weight (sk_path_rawiterator_t *iterator)
 130 {
 131     return AsPathRawIter(iterator)->conicWeight ();
 132 }
 133
 134 void sk_path_rawiter_destroy (sk_path_rawiterator_t *iterator)
 135 {
 136     delete AsPathRawIter (iterator);
 137 }
 138
 139 void sk_path_add_path_offset (sk_path_t* cpath, sk_path_t* other, float dx, float dy, sk_path_add_mode_t add_mode)
 140 {
 141     AsPath (cpath)->addPath (AsPath (*other), dx, dy, (SkPath::AddPathMode) add_mode);
 142 }
 143
 144 void sk_path_add_path_matrix (sk_path_t* cpath, sk_path_t* other, sk_matrix_t *matrix, sk_path_add_mode_t add_mode)
 145 {
 146     SkMatrix skmatrix;
 147     from_c(matrix, &skmatrix);
 148     AsPath (cpath)->addPath (AsPath (*other), skmatrix, (SkPath::AddPathMode) add_mode);
 149 }
 150
 151 void sk_path_add_path (sk_path_t* cpath, sk_path_t* other, sk_path_add_mode_t add_mode)
 152 {
 153     AsPath (cpath)->addPath (AsPath (*other), (SkPath::AddPathMode) add_mode);
 154 }
 155
 156 void sk_path_add_path_reverse (sk_path_t* cpath, sk_path_t* other)
 157 {
 158     AsPath (cpath)->reverseAddPath (AsPath (*other));
 159 }
 160
 161 sk_path_t* sk_path_new() { return (sk_path_t*)new SkPath; }
 162
 163 void sk_path_delete(sk_path_t* cpath) { delete AsPath(cpath); }
 164
 165 void sk_path_move_to(sk_path_t* cpath, float x, float y) {
 166     AsPath(cpath)->moveTo(x, y);
 167 }
 168
 169 void sk_path_line_to(sk_path_t* cpath, float x, float y) {
 170     AsPath(cpath)->lineTo(x, y);
 171 }
 172
 173 void sk_path_quad_to(sk_path_t* cpath, float x0, float y0, float x1, float y1) {
 174     AsPath(cpath)->quadTo(x0, y0, x1, y1);
 175 }
 176
 177 void sk_path_conic_to(sk_path_t* cpath, float x0, float y0, float x1, float y1, float w) {
 178     AsPath(cpath)->conicTo(x0, y0, x1, y1, w);
 179 }
 180
 181 void sk_path_cubic_to(sk_path_t* cpath, float x0, float y0, float x1, float y1, float x2, float y2) {
 182     AsPath(cpath)->cubicTo(x0, y0, x1, y1, x2, y2);
 183 }
 184
 185 void sk_path_arc_to(sk_path_t* cpath, float rx, float ry, float xAxisRotate, sk_path_arc_size_t largeArc, sk_path_direction_t sweep, float x, float y) {
 186     AsPath(cpath)->arcTo(rx, ry, xAxisRotate, (SkPath::ArcSize)largeArc, (SkPath::Direction)sweep, x, y);
 187 }
 188
 189 void sk_path_rarc_to(sk_path_t* cpath, float rx, float ry, float xAxisRotate, sk_path_arc_size_t largeArc, sk_path_direction_t sweep, float x, float y) {
 190     AsPath(cpath)->rArcTo(rx, ry, xAxisRotate, (SkPath::ArcSize)largeArc, (SkPath::Direction)sweep, x, y);
 191 }
 192
 193 void sk_path_close(sk_path_t* cpath) {
 194     AsPath(cpath)->close();
 195 }
 196
 197 void sk_path_add_rect(sk_path_t* cpath, const sk_rect_t* crect, sk_path_direction_t cdir) {
 198     AsPath(cpath)->addRect(AsRect(*crect), (SkPath::Direction)cdir);
 199 }
 200
 201 void sk_path_add_rounded_rect(sk_path_t* cpath, const sk_rect_t* crect, float rx, float ry, sk_path_direction_t cdir) {
 202     AsPath(cpath)->addRoundRect(AsRect(*crect), rx, ry, (SkPath::Direction)cdir);
 203 }
 204
 205 void sk_path_add_oval(sk_path_t* cpath, const sk_rect_t* crect, sk_path_direction_t cdir) {
 206     AsPath(cpath)->addOval(AsRect(*crect), (SkPath::Direction)cdir);
 207 }
 208
 209 void sk_path_add_circle(sk_path_t* cpath, float x, float y, float radius, sk_path_direction_t dir) {
 210     AsPath(cpath)->addCircle(x, y, radius, (SkPath::Direction)dir);
 211 }
 212
 213 bool sk_path_get_bounds(const sk_path_t* cpath, sk_rect_t* crect) {
 214     const SkPath& path = AsPath(*cpath);
 215
 216     if (path.isEmpty()) {
 217         if (crect) {
 218             *crect = ToRect(SkRect::MakeEmpty());
 219         }
 220         return false;
 221     }
 222
 223     if (crect) {
 224         *crect = ToRect(path.getBounds());
 225     }
 226     return true;
 227 }
 228
 229 int sk_path_count_points(const sk_path_t* cpath) {
 230     const SkPath& path = AsPath(*cpath);
 231     return path.countPoints();
 232 }
 233
 234 void sk_path_get_point(const sk_path_t* cpath, int index, sk_point_t* cpoint) {
 235     const SkPath& path = AsPath(*cpath);
 236     if (cpoint) {
 237         SkPoint point = path.getPoint(index);
 238         *cpoint = ToPoint(point);
 239     }
 240 }
 241
 242 int sk_path_get_points(const sk_path_t* cpath, sk_point_t* cpoints, int max) {
 243     const SkPath& path = AsPath(*cpath);
 244     return path.getPoints(AsPoint(cpoints), max);
 245 }
 246
 247 bool sk_path_contains (const sk_path_t* cpath, float x, float y) {
 248     return AsPath(*cpath).contains(x, y);
 249 }
 250
 251 sk_path_convexity_t sk_path_get_convexity (const sk_path_t* cpath) {
 252     return (sk_path_convexity_t)AsPath(*cpath).getConvexity();
 253 }
 254
 255 void sk_path_set_convexity (sk_path_t* cpath, sk_path_convexity_t convexity) {
 256     AsPath(cpath)->setConvexity((SkPath::Convexity)convexity);
 257 }
 258
 259 SK_API bool sk_path_parse_svg_string (sk_path_t* cpath, const char* str) {
 260     return SkParsePath::FromSVGString(str, AsPath(cpath));
 261 }
 262
 263 SK_API void sk_path_to_svg_string (const sk_path_t* cpath, sk_string_t* str) {
 264     SkParsePath::ToSVGString(AsPath(*cpath), AsString(str));
 265 }
 266
 267 bool sk_path_get_last_point (const sk_path_t* cpath, sk_point_t* point) {
 268     if (point) {
 269         return AsPath(*cpath).getLastPt(AsPoint(point));
 270     } else {
 271         return false;
 272     }
 273 }
 274
 275 bool sk_pathop_op(const sk_path_t* one, const sk_path_t* two, sk_pathop_t op, sk_path_t* result) {
 276     return Op(AsPath(*one), AsPath(*two), (SkPathOp)op, AsPath(result));
 277 }
 278
 279 bool sk_pathop_simplify(const sk_path_t* path, sk_path_t* result) {
 280     return Simplify(AsPath(*path), AsPath(result));
 281 }
 282
 283 bool sk_pathop_tight_bounds(const sk_path_t* path, sk_rect_t* result) {
 284     return TightBounds(AsPath(*path), AsRect(result));
 285 }
 286
 287 sk_opbuilder_t* sk_opbuilder_new() {
 288     return ToOpBuilder(new SkOpBuilder());
 289 }
 290
 291 void sk_opbuilder_destroy(sk_opbuilder_t* builder) {
 292     delete AsOpBuilder(builder);
 293 }
 294
 295 void sk_opbuilder_add(sk_opbuilder_t* builder, const sk_path_t* path, sk_pathop_t op) {
 296     AsOpBuilder(builder)->add(AsPath(*path), (SkPathOp)op);
 297 }
 298
 299 bool sk_opbuilder_resolve(sk_opbuilder_t* builder, sk_path_t* result) {
 300     return AsOpBuilder(builder)->resolve(AsPath(result));
 301 }