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