1 /* libs/android_runtime/android/graphics/Path.cpp 2 ** 3 ** Copyright 2006, The Android Open Source Project 4 ** 5 ** Licensed under the Apache License, Version 2.0 (the "License"); 6 ** you may not use this file except in compliance with the License. 7 ** You may obtain a copy of the License at 8 ** 9 ** http://www.apache.org/licenses/LICENSE-2.0 10 ** 11 ** Unless required by applicable law or agreed to in writing, software 12 ** distributed under the License is distributed on an "AS IS" BASIS, 13 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 ** See the License for the specific language governing permissions and 15 ** limitations under the License. 16 */ 17 18 // This file was generated from the C++ include file: SkPath.h 19 // Any changes made to this file will be discarded by the build. 20 // To change this file, either edit the include, or device/tools/gluemaker/main.cpp, 21 // or one of the auxilary file specifications in device/tools/gluemaker. 22 23 #include "jni.h" 24 #include "GraphicsJNI.h" 25 #include <android_runtime/AndroidRuntime.h> 26 27 #include "SkPath.h" 28 #include "SkPathOps.h" 29 30 #include <ResourceCache.h> 31 #include <vector> 32 #include <map> 33 34 namespace android { 35 36 class SkPathGlue { 37 public: 38 39 static void finalizer(JNIEnv* env, jobject clazz, jlong objHandle) { 40 SkPath* obj = reinterpret_cast<SkPath*>(objHandle); 41 #ifdef USE_OPENGL_RENDERER 42 if (android::uirenderer::ResourceCache::hasInstance()) { 43 android::uirenderer::ResourceCache::getInstance().destructor(obj); 44 return; 45 } 46 #endif 47 delete obj; 48 } 49 50 static jlong init1(JNIEnv* env, jobject clazz) { 51 return reinterpret_cast<jlong>(new SkPath()); 52 } 53 54 static jlong init2(JNIEnv* env, jobject clazz, jlong valHandle) { 55 SkPath* val = reinterpret_cast<SkPath*>(valHandle); 56 return reinterpret_cast<jlong>(new SkPath(*val)); 57 } 58 59 static void reset(JNIEnv* env, jobject clazz, jlong objHandle) { 60 SkPath* obj = reinterpret_cast<SkPath*>(objHandle); 61 obj->reset(); 62 } 63 64 static void rewind(JNIEnv* env, jobject clazz, jlong objHandle) { 65 SkPath* obj = reinterpret_cast<SkPath*>(objHandle); 66 obj->rewind(); 67 } 68 69 static void assign(JNIEnv* env, jobject clazz, jlong dstHandle, jlong srcHandle) { 70 SkPath* dst = reinterpret_cast<SkPath*>(dstHandle); 71 const SkPath* src = reinterpret_cast<SkPath*>(srcHandle); 72 *dst = *src; 73 } 74 75 static jboolean isConvex(JNIEnv* env, jobject clazz, jlong objHandle) { 76 SkPath* obj = reinterpret_cast<SkPath*>(objHandle); 77 return obj->isConvex(); 78 } 79 80 static jint getFillType(JNIEnv* env, jobject clazz, jlong objHandle) { 81 SkPath* obj = reinterpret_cast<SkPath*>(objHandle); 82 return obj->getFillType(); 83 } 84 85 static void setFillType(JNIEnv* env, jobject clazz, jlong pathHandle, jint ftHandle) { 86 SkPath* path = reinterpret_cast<SkPath*>(pathHandle); 87 SkPath::FillType ft = static_cast<SkPath::FillType>(ftHandle); 88 path->setFillType(ft); 89 } 90 91 static jboolean isEmpty(JNIEnv* env, jobject clazz, jlong objHandle) { 92 SkPath* obj = reinterpret_cast<SkPath*>(objHandle); 93 return obj->isEmpty(); 94 } 95 96 static jboolean isRect(JNIEnv* env, jobject clazz, jlong objHandle, jobject jrect) { 97 SkRect rect; 98 SkPath* obj = reinterpret_cast<SkPath*>(objHandle); 99 jboolean result = obj->isRect(&rect); 100 GraphicsJNI::rect_to_jrectf(rect, env, jrect); 101 return result; 102 } 103 104 static void computeBounds(JNIEnv* env, jobject clazz, jlong objHandle, jobject jbounds) { 105 SkPath* obj = reinterpret_cast<SkPath*>(objHandle); 106 const SkRect& bounds = obj->getBounds(); 107 GraphicsJNI::rect_to_jrectf(bounds, env, jbounds); 108 } 109 110 static void incReserve(JNIEnv* env, jobject clazz, jlong objHandle, jint extraPtCount) { 111 SkPath* obj = reinterpret_cast<SkPath*>(objHandle); 112 obj->incReserve(extraPtCount); 113 } 114 115 static void moveTo__FF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat x, jfloat y) { 116 SkPath* obj = reinterpret_cast<SkPath*>(objHandle); 117 obj->moveTo(x, y); 118 } 119 120 static void rMoveTo(JNIEnv* env, jobject clazz, jlong objHandle, jfloat dx, jfloat dy) { 121 SkPath* obj = reinterpret_cast<SkPath*>(objHandle); 122 obj->rMoveTo(dx, dy); 123 } 124 125 static void lineTo__FF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat x, jfloat y) { 126 SkPath* obj = reinterpret_cast<SkPath*>(objHandle); 127 obj->lineTo(x, y); 128 } 129 130 static void rLineTo(JNIEnv* env, jobject clazz, jlong objHandle, jfloat dx, jfloat dy) { 131 SkPath* obj = reinterpret_cast<SkPath*>(objHandle); 132 obj->rLineTo(dx, dy); 133 } 134 135 static void quadTo__FFFF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat x1, jfloat y1, jfloat x2, jfloat y2) { 136 SkPath* obj = reinterpret_cast<SkPath*>(objHandle); 137 obj->quadTo(x1, y1, x2, y2); 138 } 139 140 static void rQuadTo(JNIEnv* env, jobject clazz, jlong objHandle, jfloat dx1, jfloat dy1, jfloat dx2, jfloat dy2) { 141 SkPath* obj = reinterpret_cast<SkPath*>(objHandle); 142 obj->rQuadTo(dx1, dy1, dx2, dy2); 143 } 144 145 static void cubicTo__FFFFFF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat x1, jfloat y1, jfloat x2, jfloat y2, jfloat x3, jfloat y3) { 146 SkPath* obj = reinterpret_cast<SkPath*>(objHandle); 147 obj->cubicTo(x1, y1, x2, y2, x3, y3); 148 } 149 150 static void rCubicTo(JNIEnv* env, jobject clazz, jlong objHandle, jfloat x1, jfloat y1, jfloat x2, jfloat y2, jfloat x3, jfloat y3) { 151 SkPath* obj = reinterpret_cast<SkPath*>(objHandle); 152 obj->rCubicTo(x1, y1, x2, y2, x3, y3); 153 } 154 155 static void arcTo(JNIEnv* env, jobject clazz, jlong objHandle, jfloat left, jfloat top, 156 jfloat right, jfloat bottom, jfloat startAngle, jfloat sweepAngle, 157 jboolean forceMoveTo) { 158 SkPath* obj = reinterpret_cast<SkPath*>(objHandle); 159 SkRect oval = SkRect::MakeLTRB(left, top, right, bottom); 160 obj->arcTo(oval, startAngle, sweepAngle, forceMoveTo); 161 } 162 163 static void close(JNIEnv* env, jobject clazz, jlong objHandle) { 164 SkPath* obj = reinterpret_cast<SkPath*>(objHandle); 165 obj->close(); 166 } 167 168 static void addRect(JNIEnv* env, jobject clazz, jlong objHandle, 169 jfloat left, jfloat top, jfloat right, jfloat bottom, jint dirHandle) { 170 SkPath* obj = reinterpret_cast<SkPath*>(objHandle); 171 SkPath::Direction dir = static_cast<SkPath::Direction>(dirHandle); 172 obj->addRect(left, top, right, bottom, dir); 173 } 174 175 static void addOval(JNIEnv* env, jobject clazz, jlong objHandle, 176 jfloat left, jfloat top, jfloat right, jfloat bottom, jint dirHandle) { 177 SkPath* obj = reinterpret_cast<SkPath*>(objHandle); 178 SkPath::Direction dir = static_cast<SkPath::Direction>(dirHandle); 179 SkRect oval = SkRect::MakeLTRB(left, top, right, bottom); 180 obj->addOval(oval, dir); 181 } 182 183 static void addCircle(JNIEnv* env, jobject clazz, jlong objHandle, jfloat x, jfloat y, jfloat radius, jint dirHandle) { 184 SkPath* obj = reinterpret_cast<SkPath*>(objHandle); 185 SkPath::Direction dir = static_cast<SkPath::Direction>(dirHandle); 186 obj->addCircle(x, y, radius, dir); 187 } 188 189 static void addArc(JNIEnv* env, jobject clazz, jlong objHandle, jfloat left, jfloat top, 190 jfloat right, jfloat bottom, jfloat startAngle, jfloat sweepAngle) { 191 SkRect oval = SkRect::MakeLTRB(left, top, right, bottom); 192 SkPath* obj = reinterpret_cast<SkPath*>(objHandle); 193 obj->addArc(oval, startAngle, sweepAngle); 194 } 195 196 static void addRoundRectXY(JNIEnv* env, jobject clazz, jlong objHandle, jfloat left, jfloat top, 197 jfloat right, jfloat bottom, jfloat rx, jfloat ry, jint dirHandle) { 198 SkRect rect = SkRect::MakeLTRB(left, top, right, bottom); 199 SkPath* obj = reinterpret_cast<SkPath*>(objHandle); 200 SkPath::Direction dir = static_cast<SkPath::Direction>(dirHandle); 201 obj->addRoundRect(rect, rx, ry, dir); 202 } 203 204 static void addRoundRect8(JNIEnv* env, jobject, jlong objHandle, jfloat left, jfloat top, 205 jfloat right, jfloat bottom, jfloatArray array, jint dirHandle) { 206 SkRect rect = SkRect::MakeLTRB(left, top, right, bottom); 207 SkPath* obj = reinterpret_cast<SkPath*>(objHandle); 208 SkPath::Direction dir = static_cast<SkPath::Direction>(dirHandle); 209 AutoJavaFloatArray afa(env, array, 8); 210 #ifdef SK_SCALAR_IS_FLOAT 211 const float* src = afa.ptr(); 212 #else 213 #error Need to convert float array to SkScalar array before calling the following function. 214 #endif 215 obj->addRoundRect(rect, src, dir); 216 } 217 218 static void addPath__PathFF(JNIEnv* env, jobject clazz, jlong objHandle, jlong srcHandle, jfloat dx, jfloat dy) { 219 SkPath* obj = reinterpret_cast<SkPath*>(objHandle); 220 SkPath* src = reinterpret_cast<SkPath*>(srcHandle); 221 obj->addPath(*src, dx, dy); 222 } 223 224 static void addPath__Path(JNIEnv* env, jobject clazz, jlong objHandle, jlong srcHandle) { 225 SkPath* obj = reinterpret_cast<SkPath*>(objHandle); 226 SkPath* src = reinterpret_cast<SkPath*>(srcHandle); 227 obj->addPath(*src); 228 } 229 230 static void addPath__PathMatrix(JNIEnv* env, jobject clazz, jlong objHandle, jlong srcHandle, jlong matrixHandle) { 231 SkPath* obj = reinterpret_cast<SkPath*>(objHandle); 232 SkPath* src = reinterpret_cast<SkPath*>(srcHandle); 233 SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle); 234 obj->addPath(*src, *matrix); 235 } 236 237 static void offset__FFPath(JNIEnv* env, jobject clazz, jlong objHandle, jfloat dx, jfloat dy, jlong dstHandle) { 238 SkPath* obj = reinterpret_cast<SkPath*>(objHandle); 239 SkPath* dst = reinterpret_cast<SkPath*>(dstHandle); 240 obj->offset(dx, dy, dst); 241 } 242 243 static void offset__FF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat dx, jfloat dy) { 244 SkPath* obj = reinterpret_cast<SkPath*>(objHandle); 245 obj->offset(dx, dy); 246 } 247 248 static void setLastPoint(JNIEnv* env, jobject clazz, jlong objHandle, jfloat dx, jfloat dy) { 249 SkPath* obj = reinterpret_cast<SkPath*>(objHandle); 250 obj->setLastPt(dx, dy); 251 } 252 253 static void transform__MatrixPath(JNIEnv* env, jobject clazz, jlong objHandle, jlong matrixHandle, jlong dstHandle) { 254 SkPath* obj = reinterpret_cast<SkPath*>(objHandle); 255 SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle); 256 SkPath* dst = reinterpret_cast<SkPath*>(dstHandle); 257 obj->transform(*matrix, dst); 258 } 259 260 static void transform__Matrix(JNIEnv* env, jobject clazz, jlong objHandle, jlong matrixHandle) { 261 SkPath* obj = reinterpret_cast<SkPath*>(objHandle); 262 SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle); 263 obj->transform(*matrix); 264 } 265 266 static jboolean op(JNIEnv* env, jobject clazz, jlong p1Handle, jlong p2Handle, jint opHandle, jlong rHandle) { 267 SkPath* p1 = reinterpret_cast<SkPath*>(p1Handle); 268 SkPath* p2 = reinterpret_cast<SkPath*>(p2Handle); 269 SkPathOp op = static_cast<SkPathOp>(opHandle); 270 SkPath* r = reinterpret_cast<SkPath*>(rHandle); 271 return Op(*p1, *p2, op, r); 272 } 273 274 typedef SkPoint (*bezierCalculation)(float t, const SkPoint* points); 275 276 static void addMove(std::vector<SkPoint>& segmentPoints, std::vector<float>& lengths, 277 const SkPoint& point) { 278 float length = 0; 279 if (!lengths.empty()) { 280 length = lengths.back(); 281 } 282 segmentPoints.push_back(point); 283 lengths.push_back(length); 284 } 285 286 static void addLine(std::vector<SkPoint>& segmentPoints, std::vector<float>& lengths, 287 const SkPoint& toPoint) { 288 if (segmentPoints.empty()) { 289 segmentPoints.push_back(SkPoint::Make(0, 0)); 290 lengths.push_back(0); 291 } else if (segmentPoints.back() == toPoint) { 292 return; // Empty line 293 } 294 float length = lengths.back() + SkPoint::Distance(segmentPoints.back(), toPoint); 295 segmentPoints.push_back(toPoint); 296 lengths.push_back(length); 297 } 298 299 static float cubicCoordinateCalculation(float t, float p0, float p1, float p2, float p3) { 300 float oneMinusT = 1 - t; 301 float oneMinusTSquared = oneMinusT * oneMinusT; 302 float oneMinusTCubed = oneMinusTSquared * oneMinusT; 303 float tSquared = t * t; 304 float tCubed = tSquared * t; 305 return (oneMinusTCubed * p0) + (3 * oneMinusTSquared * t * p1) 306 + (3 * oneMinusT * tSquared * p2) + (tCubed * p3); 307 } 308 309 static SkPoint cubicBezierCalculation(float t, const SkPoint* points) { 310 float x = cubicCoordinateCalculation(t, points[0].x(), points[1].x(), 311 points[2].x(), points[3].x()); 312 float y = cubicCoordinateCalculation(t, points[0].y(), points[1].y(), 313 points[2].y(), points[3].y()); 314 return SkPoint::Make(x, y); 315 } 316 317 static float quadraticCoordinateCalculation(float t, float p0, float p1, float p2) { 318 float oneMinusT = 1 - t; 319 return oneMinusT * ((oneMinusT * p0) + (t * p1)) + t * ((oneMinusT * p1) + (t * p2)); 320 } 321 322 static SkPoint quadraticBezierCalculation(float t, const SkPoint* points) { 323 float x = quadraticCoordinateCalculation(t, points[0].x(), points[1].x(), points[2].x()); 324 float y = quadraticCoordinateCalculation(t, points[0].y(), points[1].y(), points[2].y()); 325 return SkPoint::Make(x, y); 326 } 327 328 // Subdivide a section of the Bezier curve, set the mid-point and the mid-t value. 329 // Returns true if further subdivision is necessary as defined by errorSquared. 330 static bool subdividePoints(const SkPoint* points, bezierCalculation bezierFunction, 331 float t0, const SkPoint &p0, float t1, const SkPoint &p1, 332 float& midT, SkPoint &midPoint, float errorSquared) { 333 midT = (t1 + t0) / 2; 334 float midX = (p1.x() + p0.x()) / 2; 335 float midY = (p1.y() + p0.y()) / 2; 336 337 midPoint = (*bezierFunction)(midT, points); 338 float xError = midPoint.x() - midX; 339 float yError = midPoint.y() - midY; 340 float midErrorSquared = (xError * xError) + (yError * yError); 341 return midErrorSquared > errorSquared; 342 } 343 344 // Divides Bezier curves until linear interpolation is very close to accurate, using 345 // errorSquared as a metric. Cubic Bezier curves can have an inflection point that improperly 346 // short-circuit subdivision. If you imagine an S shape, the top and bottom points being the 347 // starting and end points, linear interpolation would mark the center where the curve places 348 // the point. It is clearly not the case that we can linearly interpolate at that point. 349 // doubleCheckDivision forces a second examination between subdivisions to ensure that linear 350 // interpolation works. 351 static void addBezier(const SkPoint* points, 352 bezierCalculation bezierFunction, std::vector<SkPoint>& segmentPoints, 353 std::vector<float>& lengths, float errorSquared, bool doubleCheckDivision) { 354 typedef std::map<float, SkPoint> PointMap; 355 PointMap tToPoint; 356 357 tToPoint[0] = (*bezierFunction)(0, points); 358 tToPoint[1] = (*bezierFunction)(1, points); 359 360 PointMap::iterator iter = tToPoint.begin(); 361 PointMap::iterator next = iter; 362 ++next; 363 while (next != tToPoint.end()) { 364 bool needsSubdivision = true; 365 SkPoint midPoint; 366 do { 367 float midT; 368 needsSubdivision = subdividePoints(points, bezierFunction, iter->first, 369 iter->second, next->first, next->second, midT, midPoint, errorSquared); 370 if (!needsSubdivision && doubleCheckDivision) { 371 SkPoint quarterPoint; 372 float quarterT; 373 needsSubdivision = subdividePoints(points, bezierFunction, iter->first, 374 iter->second, midT, midPoint, quarterT, quarterPoint, errorSquared); 375 if (needsSubdivision) { 376 // Found an inflection point. No need to double-check. 377 doubleCheckDivision = false; 378 } 379 } 380 if (needsSubdivision) { 381 next = tToPoint.insert(iter, PointMap::value_type(midT, midPoint)); 382 } 383 } while (needsSubdivision); 384 iter = next; 385 next++; 386 } 387 388 // Now that each division can use linear interpolation with less than the allowed error 389 for (iter = tToPoint.begin(); iter != tToPoint.end(); ++iter) { 390 addLine(segmentPoints, lengths, iter->second); 391 } 392 } 393 394 static void createVerbSegments(SkPath::Verb verb, const SkPoint* points, 395 std::vector<SkPoint>& segmentPoints, std::vector<float>& lengths, float errorSquared) { 396 switch (verb) { 397 case SkPath::kMove_Verb: 398 addMove(segmentPoints, lengths, points[0]); 399 break; 400 case SkPath::kClose_Verb: 401 addLine(segmentPoints, lengths, points[0]); 402 break; 403 case SkPath::kLine_Verb: 404 addLine(segmentPoints, lengths, points[1]); 405 break; 406 case SkPath::kQuad_Verb: 407 addBezier(points, quadraticBezierCalculation, segmentPoints, lengths, 408 errorSquared, false); 409 break; 410 case SkPath::kCubic_Verb: 411 addBezier(points, cubicBezierCalculation, segmentPoints, lengths, 412 errorSquared, true); 413 break; 414 default: 415 // Leave element as NULL, Conic sections are not supported. 416 break; 417 } 418 } 419 420 // Returns a float[] with each point along the path represented by 3 floats 421 // * fractional length along the path that the point resides 422 // * x coordinate 423 // * y coordinate 424 // Note that more than one point may have the same length along the path in 425 // the case of a move. 426 // NULL can be returned if the Path is empty. 427 static jfloatArray approximate(JNIEnv* env, jclass, jlong pathHandle, float acceptableError) 428 { 429 SkPath* path = reinterpret_cast<SkPath*>(pathHandle); 430 SkASSERT(path); 431 SkPath::Iter pathIter(*path, false); 432 SkPath::Verb verb; 433 SkPoint points[4]; 434 std::vector<SkPoint> segmentPoints; 435 std::vector<float> lengths; 436 float errorSquared = acceptableError * acceptableError; 437 438 while ((verb = pathIter.next(points, false)) != SkPath::kDone_Verb) { 439 createVerbSegments(verb, points, segmentPoints, lengths, errorSquared); 440 } 441 442 if (segmentPoints.empty()) { 443 int numVerbs = path->countVerbs(); 444 if (numVerbs == 1) { 445 addMove(segmentPoints, lengths, path->getPoint(0)); 446 } else { 447 // Invalid or empty path. Fall back to point(0,0) 448 addMove(segmentPoints, lengths, SkPoint()); 449 } 450 } 451 452 float totalLength = lengths.back(); 453 if (totalLength == 0) { 454 // Lone Move instructions should still be able to animate at the same value. 455 segmentPoints.push_back(segmentPoints.back()); 456 lengths.push_back(1); 457 totalLength = 1; 458 } 459 460 size_t numPoints = segmentPoints.size(); 461 size_t approximationArraySize = numPoints * 3; 462 463 float* approximation = new float[approximationArraySize]; 464 465 int approximationIndex = 0; 466 for (size_t i = 0; i < numPoints; i++) { 467 const SkPoint& point = segmentPoints[i]; 468 approximation[approximationIndex++] = lengths[i] / totalLength; 469 approximation[approximationIndex++] = point.x(); 470 approximation[approximationIndex++] = point.y(); 471 } 472 473 jfloatArray result = env->NewFloatArray(approximationArraySize); 474 env->SetFloatArrayRegion(result, 0, approximationArraySize, approximation); 475 delete[] approximation; 476 return result; 477 } 478 }; 479 480 static JNINativeMethod methods[] = { 481 {"finalizer", "(J)V", (void*) SkPathGlue::finalizer}, 482 {"init1","()J", (void*) SkPathGlue::init1}, 483 {"init2","(J)J", (void*) SkPathGlue::init2}, 484 {"native_reset","(J)V", (void*) SkPathGlue::reset}, 485 {"native_rewind","(J)V", (void*) SkPathGlue::rewind}, 486 {"native_set","(JJ)V", (void*) SkPathGlue::assign}, 487 {"native_isConvex","(J)Z", (void*) SkPathGlue::isConvex}, 488 {"native_getFillType","(J)I", (void*) SkPathGlue::getFillType}, 489 {"native_setFillType","(JI)V", (void*) SkPathGlue::setFillType}, 490 {"native_isEmpty","(J)Z", (void*) SkPathGlue::isEmpty}, 491 {"native_isRect","(JLandroid/graphics/RectF;)Z", (void*) SkPathGlue::isRect}, 492 {"native_computeBounds","(JLandroid/graphics/RectF;)V", (void*) SkPathGlue::computeBounds}, 493 {"native_incReserve","(JI)V", (void*) SkPathGlue::incReserve}, 494 {"native_moveTo","(JFF)V", (void*) SkPathGlue::moveTo__FF}, 495 {"native_rMoveTo","(JFF)V", (void*) SkPathGlue::rMoveTo}, 496 {"native_lineTo","(JFF)V", (void*) SkPathGlue::lineTo__FF}, 497 {"native_rLineTo","(JFF)V", (void*) SkPathGlue::rLineTo}, 498 {"native_quadTo","(JFFFF)V", (void*) SkPathGlue::quadTo__FFFF}, 499 {"native_rQuadTo","(JFFFF)V", (void*) SkPathGlue::rQuadTo}, 500 {"native_cubicTo","(JFFFFFF)V", (void*) SkPathGlue::cubicTo__FFFFFF}, 501 {"native_rCubicTo","(JFFFFFF)V", (void*) SkPathGlue::rCubicTo}, 502 {"native_arcTo","(JFFFFFFZ)V", (void*) SkPathGlue::arcTo}, 503 {"native_close","(J)V", (void*) SkPathGlue::close}, 504 {"native_addRect","(JFFFFI)V", (void*) SkPathGlue::addRect}, 505 {"native_addOval","(JFFFFI)V", (void*) SkPathGlue::addOval}, 506 {"native_addCircle","(JFFFI)V", (void*) SkPathGlue::addCircle}, 507 {"native_addArc","(JFFFFFF)V", (void*) SkPathGlue::addArc}, 508 {"native_addRoundRect","(JFFFFFFI)V", (void*) SkPathGlue::addRoundRectXY}, 509 {"native_addRoundRect","(JFFFF[FI)V", (void*) SkPathGlue::addRoundRect8}, 510 {"native_addPath","(JJFF)V", (void*) SkPathGlue::addPath__PathFF}, 511 {"native_addPath","(JJ)V", (void*) SkPathGlue::addPath__Path}, 512 {"native_addPath","(JJJ)V", (void*) SkPathGlue::addPath__PathMatrix}, 513 {"native_offset","(JFFJ)V", (void*) SkPathGlue::offset__FFPath}, 514 {"native_offset","(JFF)V", (void*) SkPathGlue::offset__FF}, 515 {"native_setLastPoint","(JFF)V", (void*) SkPathGlue::setLastPoint}, 516 {"native_transform","(JJJ)V", (void*) SkPathGlue::transform__MatrixPath}, 517 {"native_transform","(JJ)V", (void*) SkPathGlue::transform__Matrix}, 518 {"native_op","(JJIJ)Z", (void*) SkPathGlue::op}, 519 {"native_approximate", "(JF)[F", (void*) SkPathGlue::approximate}, 520 }; 521 522 int register_android_graphics_Path(JNIEnv* env) { 523 int result = AndroidRuntime::registerNativeMethods(env, "android/graphics/Path", methods, 524 sizeof(methods) / sizeof(methods[0])); 525 return result; 526 } 527 528 } 529
