Path.cpp revision a2341a9f6addcd79723965ec5b1a1c5ae0f8bd65
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 29#include <Caches.h> 30 31namespace android { 32 33class SkPathGlue { 34public: 35 36 static void finalizer(JNIEnv* env, jobject clazz, SkPath* obj) { 37#ifdef USE_OPENGL_RENDERER 38 if (android::uirenderer::Caches::hasInstance()) { 39 android::uirenderer::Caches::getInstance().pathCache.remove(obj); 40 } 41#endif 42 delete obj; 43 } 44 45 static SkPath* init1(JNIEnv* env, jobject clazz) { 46 return new SkPath(); 47 } 48 49 static SkPath* init2(JNIEnv* env, jobject clazz, SkPath* val) { 50 return new SkPath(*val); 51 } 52 53 static void reset(JNIEnv* env, jobject clazz, SkPath* obj) { 54 obj->reset(); 55 } 56 57 static void rewind(JNIEnv* env, jobject clazz, SkPath* obj) { 58 obj->rewind(); 59 } 60 61 static void assign(JNIEnv* env, jobject clazz, SkPath* dst, const SkPath* src) { 62 *dst = *src; 63 } 64 65 static jint getFillType(JNIEnv* env, jobject clazz, SkPath* obj) { 66 return obj->getFillType(); 67 } 68 69 static void setFillType(JNIEnv* env, jobject clazz, SkPath* path, 70 SkPath::FillType ft) { 71 path->setFillType(ft); 72 } 73 74 static jboolean isEmpty(JNIEnv* env, jobject clazz, SkPath* obj) { 75 return obj->isEmpty(); 76 } 77 78 static jboolean isRect(JNIEnv* env, jobject clazz, SkPath* obj, jobject rect) { 79 SkRect rect_; 80 jboolean result = obj->isRect(&rect_); 81 GraphicsJNI::rect_to_jrectf(rect_, env, rect); 82 return result; 83 } 84 85 static void computeBounds(JNIEnv* env, jobject clazz, SkPath* obj, jobject bounds) { 86 const SkRect& bounds_ = obj->getBounds(); 87 GraphicsJNI::rect_to_jrectf(bounds_, env, bounds); 88 } 89 90 static void incReserve(JNIEnv* env, jobject clazz, SkPath* obj, jint extraPtCount) { 91 obj->incReserve(extraPtCount); 92 } 93 94 static void moveTo__FF(JNIEnv* env, jobject clazz, SkPath* obj, jfloat x, jfloat y) { 95 SkScalar x_ = SkFloatToScalar(x); 96 SkScalar y_ = SkFloatToScalar(y); 97 obj->moveTo(x_, y_); 98 } 99 100 static void rMoveTo(JNIEnv* env, jobject clazz, SkPath* obj, jfloat dx, jfloat dy) { 101 SkScalar dx_ = SkFloatToScalar(dx); 102 SkScalar dy_ = SkFloatToScalar(dy); 103 obj->rMoveTo(dx_, dy_); 104 } 105 106 static void lineTo__FF(JNIEnv* env, jobject clazz, SkPath* obj, jfloat x, jfloat y) { 107 SkScalar x_ = SkFloatToScalar(x); 108 SkScalar y_ = SkFloatToScalar(y); 109 obj->lineTo(x_, y_); 110 } 111 112 static void rLineTo(JNIEnv* env, jobject clazz, SkPath* obj, jfloat dx, jfloat dy) { 113 SkScalar dx_ = SkFloatToScalar(dx); 114 SkScalar dy_ = SkFloatToScalar(dy); 115 obj->rLineTo(dx_, dy_); 116 } 117 118 static void quadTo__FFFF(JNIEnv* env, jobject clazz, SkPath* obj, jfloat x1, jfloat y1, jfloat x2, jfloat y2) { 119 SkScalar x1_ = SkFloatToScalar(x1); 120 SkScalar y1_ = SkFloatToScalar(y1); 121 SkScalar x2_ = SkFloatToScalar(x2); 122 SkScalar y2_ = SkFloatToScalar(y2); 123 obj->quadTo(x1_, y1_, x2_, y2_); 124 } 125 126 static void rQuadTo(JNIEnv* env, jobject clazz, SkPath* obj, jfloat dx1, jfloat dy1, jfloat dx2, jfloat dy2) { 127 SkScalar dx1_ = SkFloatToScalar(dx1); 128 SkScalar dy1_ = SkFloatToScalar(dy1); 129 SkScalar dx2_ = SkFloatToScalar(dx2); 130 SkScalar dy2_ = SkFloatToScalar(dy2); 131 obj->rQuadTo(dx1_, dy1_, dx2_, dy2_); 132 } 133 134 static void cubicTo__FFFFFF(JNIEnv* env, jobject clazz, SkPath* obj, jfloat x1, jfloat y1, jfloat x2, jfloat y2, jfloat x3, jfloat y3) { 135 SkScalar x1_ = SkFloatToScalar(x1); 136 SkScalar y1_ = SkFloatToScalar(y1); 137 SkScalar x2_ = SkFloatToScalar(x2); 138 SkScalar y2_ = SkFloatToScalar(y2); 139 SkScalar x3_ = SkFloatToScalar(x3); 140 SkScalar y3_ = SkFloatToScalar(y3); 141 obj->cubicTo(x1_, y1_, x2_, y2_, x3_, y3_); 142 } 143 144 static void rCubicTo(JNIEnv* env, jobject clazz, SkPath* obj, jfloat x1, jfloat y1, jfloat x2, jfloat y2, jfloat x3, jfloat y3) { 145 SkScalar x1_ = SkFloatToScalar(x1); 146 SkScalar y1_ = SkFloatToScalar(y1); 147 SkScalar x2_ = SkFloatToScalar(x2); 148 SkScalar y2_ = SkFloatToScalar(y2); 149 SkScalar x3_ = SkFloatToScalar(x3); 150 SkScalar y3_ = SkFloatToScalar(y3); 151 obj->rCubicTo(x1_, y1_, x2_, y2_, x3_, y3_); 152 } 153 154 static void arcTo(JNIEnv* env, jobject clazz, SkPath* obj, jobject oval, jfloat startAngle, jfloat sweepAngle, jboolean forceMoveTo) { 155 SkRect oval_; 156 GraphicsJNI::jrectf_to_rect(env, oval, &oval_); 157 SkScalar startAngle_ = SkFloatToScalar(startAngle); 158 SkScalar sweepAngle_ = SkFloatToScalar(sweepAngle); 159 obj->arcTo(oval_, startAngle_, sweepAngle_, forceMoveTo); 160 } 161 162 static void close(JNIEnv* env, jobject clazz, SkPath* obj) { 163 obj->close(); 164 } 165 166 static void addRect__RectFI(JNIEnv* env, jobject clazz, SkPath* obj, jobject rect, SkPath::Direction dir) { 167 SkRect rect_; 168 GraphicsJNI::jrectf_to_rect(env, rect, &rect_); 169 obj->addRect(rect_, dir); 170 } 171 172 static void addRect__FFFFI(JNIEnv* env, jobject clazz, SkPath* obj, jfloat left, jfloat top, jfloat right, jfloat bottom, SkPath::Direction dir) { 173 SkScalar left_ = SkFloatToScalar(left); 174 SkScalar top_ = SkFloatToScalar(top); 175 SkScalar right_ = SkFloatToScalar(right); 176 SkScalar bottom_ = SkFloatToScalar(bottom); 177 obj->addRect(left_, top_, right_, bottom_, dir); 178 } 179 180 static void addOval(JNIEnv* env, jobject clazz, SkPath* obj, jobject oval, SkPath::Direction dir) { 181 SkRect oval_; 182 GraphicsJNI::jrectf_to_rect(env, oval, &oval_); 183 obj->addOval(oval_, dir); 184 } 185 186 static void addCircle(JNIEnv* env, jobject clazz, SkPath* obj, jfloat x, jfloat y, jfloat radius, SkPath::Direction dir) { 187 SkScalar x_ = SkFloatToScalar(x); 188 SkScalar y_ = SkFloatToScalar(y); 189 SkScalar radius_ = SkFloatToScalar(radius); 190 obj->addCircle(x_, y_, radius_, dir); 191 } 192 193 static void addArc(JNIEnv* env, jobject clazz, SkPath* obj, jobject oval, jfloat startAngle, jfloat sweepAngle) { 194 SkRect oval_; 195 GraphicsJNI::jrectf_to_rect(env, oval, &oval_); 196 SkScalar startAngle_ = SkFloatToScalar(startAngle); 197 SkScalar sweepAngle_ = SkFloatToScalar(sweepAngle); 198 obj->addArc(oval_, startAngle_, sweepAngle_); 199 } 200 201 static void addRoundRectXY(JNIEnv* env, jobject clazz, SkPath* obj, jobject rect, 202 jfloat rx, jfloat ry, SkPath::Direction dir) { 203 SkRect rect_; 204 GraphicsJNI::jrectf_to_rect(env, rect, &rect_); 205 SkScalar rx_ = SkFloatToScalar(rx); 206 SkScalar ry_ = SkFloatToScalar(ry); 207 obj->addRoundRect(rect_, rx_, ry_, dir); 208 } 209 210 static void addRoundRect8(JNIEnv* env, jobject, SkPath* obj, jobject rect, 211 jfloatArray array, SkPath::Direction dir) { 212 SkRect rect_; 213 GraphicsJNI::jrectf_to_rect(env, rect, &rect_); 214 AutoJavaFloatArray afa(env, array, 8); 215 const float* src = afa.ptr(); 216 SkScalar dst[8]; 217 218 for (int i = 0; i < 8; i++) { 219 dst[i] = SkFloatToScalar(src[i]); 220 } 221 obj->addRoundRect(rect_, dst, dir); 222 } 223 224 static void addPath__PathFF(JNIEnv* env, jobject clazz, SkPath* obj, SkPath* src, jfloat dx, jfloat dy) { 225 SkScalar dx_ = SkFloatToScalar(dx); 226 SkScalar dy_ = SkFloatToScalar(dy); 227 obj->addPath(*src, dx_, dy_); 228 } 229 230 static void addPath__Path(JNIEnv* env, jobject clazz, SkPath* obj, SkPath* src) { 231 obj->addPath(*src); 232 } 233 234 static void addPath__PathMatrix(JNIEnv* env, jobject clazz, SkPath* obj, SkPath* src, SkMatrix* matrix) { 235 obj->addPath(*src, *matrix); 236 } 237 238 static void offset__FFPath(JNIEnv* env, jobject clazz, SkPath* obj, jfloat dx, jfloat dy, SkPath* dst) { 239 SkScalar dx_ = SkFloatToScalar(dx); 240 SkScalar dy_ = SkFloatToScalar(dy); 241 obj->offset(dx_, dy_, dst); 242 } 243 244 static void offset__FF(JNIEnv* env, jobject clazz, SkPath* obj, jfloat dx, jfloat dy) { 245 SkScalar dx_ = SkFloatToScalar(dx); 246 SkScalar dy_ = SkFloatToScalar(dy); 247 obj->offset(dx_, dy_); 248 } 249 250 static void setLastPoint(JNIEnv* env, jobject clazz, SkPath* obj, jfloat dx, jfloat dy) { 251 SkScalar dx_ = SkFloatToScalar(dx); 252 SkScalar dy_ = SkFloatToScalar(dy); 253 obj->setLastPt(dx_, dy_); 254 } 255 256 static void transform__MatrixPath(JNIEnv* env, jobject clazz, SkPath* obj, SkMatrix* matrix, SkPath* dst) { 257 obj->transform(*matrix, dst); 258 } 259 260 static void transform__Matrix(JNIEnv* env, jobject clazz, SkPath* obj, SkMatrix* matrix) { 261 obj->transform(*matrix); 262 } 263 264}; 265 266static JNINativeMethod methods[] = { 267 {"finalizer", "(I)V", (void*) SkPathGlue::finalizer}, 268 {"init1","()I", (void*) SkPathGlue::init1}, 269 {"init2","(I)I", (void*) SkPathGlue::init2}, 270 {"native_reset","(I)V", (void*) SkPathGlue::reset}, 271 {"native_rewind","(I)V", (void*) SkPathGlue::rewind}, 272 {"native_set","(II)V", (void*) SkPathGlue::assign}, 273 {"native_getFillType","(I)I", (void*) SkPathGlue::getFillType}, 274 {"native_setFillType","(II)V", (void*) SkPathGlue::setFillType}, 275 {"native_isEmpty","(I)Z", (void*) SkPathGlue::isEmpty}, 276 {"native_isRect","(ILandroid/graphics/RectF;)Z", (void*) SkPathGlue::isRect}, 277 {"native_computeBounds","(ILandroid/graphics/RectF;)V", (void*) SkPathGlue::computeBounds}, 278 {"native_incReserve","(II)V", (void*) SkPathGlue::incReserve}, 279 {"native_moveTo","(IFF)V", (void*) SkPathGlue::moveTo__FF}, 280 {"native_rMoveTo","(IFF)V", (void*) SkPathGlue::rMoveTo}, 281 {"native_lineTo","(IFF)V", (void*) SkPathGlue::lineTo__FF}, 282 {"native_rLineTo","(IFF)V", (void*) SkPathGlue::rLineTo}, 283 {"native_quadTo","(IFFFF)V", (void*) SkPathGlue::quadTo__FFFF}, 284 {"native_rQuadTo","(IFFFF)V", (void*) SkPathGlue::rQuadTo}, 285 {"native_cubicTo","(IFFFFFF)V", (void*) SkPathGlue::cubicTo__FFFFFF}, 286 {"native_rCubicTo","(IFFFFFF)V", (void*) SkPathGlue::rCubicTo}, 287 {"native_arcTo","(ILandroid/graphics/RectF;FFZ)V", (void*) SkPathGlue::arcTo}, 288 {"native_close","(I)V", (void*) SkPathGlue::close}, 289 {"native_addRect","(ILandroid/graphics/RectF;I)V", (void*) SkPathGlue::addRect__RectFI}, 290 {"native_addRect","(IFFFFI)V", (void*) SkPathGlue::addRect__FFFFI}, 291 {"native_addOval","(ILandroid/graphics/RectF;I)V", (void*) SkPathGlue::addOval}, 292 {"native_addCircle","(IFFFI)V", (void*) SkPathGlue::addCircle}, 293 {"native_addArc","(ILandroid/graphics/RectF;FF)V", (void*) SkPathGlue::addArc}, 294 {"native_addRoundRect","(ILandroid/graphics/RectF;FFI)V", (void*) SkPathGlue::addRoundRectXY}, 295 {"native_addRoundRect","(ILandroid/graphics/RectF;[FI)V", (void*) SkPathGlue::addRoundRect8}, 296 {"native_addPath","(IIFF)V", (void*) SkPathGlue::addPath__PathFF}, 297 {"native_addPath","(II)V", (void*) SkPathGlue::addPath__Path}, 298 {"native_addPath","(III)V", (void*) SkPathGlue::addPath__PathMatrix}, 299 {"native_offset","(IFFI)V", (void*) SkPathGlue::offset__FFPath}, 300 {"native_offset","(IFF)V", (void*) SkPathGlue::offset__FF}, 301 {"native_setLastPoint","(IFF)V", (void*) SkPathGlue::setLastPoint}, 302 {"native_transform","(III)V", (void*) SkPathGlue::transform__MatrixPath}, 303 {"native_transform","(II)V", (void*) SkPathGlue::transform__Matrix} 304}; 305 306int register_android_graphics_Path(JNIEnv* env) { 307 int result = AndroidRuntime::registerNativeMethods(env, "android/graphics/Path", methods, 308 sizeof(methods) / sizeof(methods[0])); 309 return result; 310} 311 312} 313