Matrix.cpp revision 36bef0bf30d6bae48cf3837df351075ca4fce654
1/* libs/android_runtime/android/graphics/Matrix.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#include "jni.h" 19#include "GraphicsJNI.h" 20#include <android_runtime/AndroidRuntime.h> 21 22#include "SkMatrix.h" 23#include "SkTemplates.h" 24 25#include "Matrix.h" 26 27#include <Caches.h> 28 29namespace android { 30 31class SkMatrixGlue { 32public: 33 34 static void finalizer(JNIEnv* env, jobject clazz, jlong objHandle) { 35 SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); 36 delete obj; 37 } 38 39 static jlong create(JNIEnv* env, jobject clazz, jlong srcHandle) { 40 const SkMatrix* src = reinterpret_cast<SkMatrix*>(srcHandle); 41 SkMatrix* obj = new SkMatrix(); 42 if (src) 43 *obj = *src; 44 else 45 obj->reset(); 46 return reinterpret_cast<jlong>(obj); 47 } 48 49 static jboolean isIdentity(JNIEnv* env, jobject clazz, jlong objHandle) { 50 SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); 51 return obj->isIdentity() ? JNI_TRUE : JNI_FALSE; 52 } 53 static jboolean rectStaysRect(JNIEnv* env, jobject clazz, jlong objHandle) { 54 SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); 55 return obj->rectStaysRect() ? JNI_TRUE : JNI_FALSE; 56 } 57 static void reset(JNIEnv* env, jobject clazz, jlong objHandle) { 58 SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); 59 obj->reset(); 60 } 61 static void set(JNIEnv* env, jobject clazz, jlong objHandle, jlong otherHandle) { 62 SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); 63 SkMatrix* other = reinterpret_cast<SkMatrix*>(otherHandle); 64 *obj = *other; 65 } 66 static void setTranslate(JNIEnv* env, jobject clazz, jlong objHandle, jfloat dx, jfloat dy) { 67 SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); 68 SkScalar dx_ = SkFloatToScalar(dx); 69 SkScalar dy_ = SkFloatToScalar(dy); 70 obj->setTranslate(dx_, dy_); 71 } 72 static void setScale__FFFF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat sx, jfloat sy, jfloat px, jfloat py) { 73 SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); 74 SkScalar sx_ = SkFloatToScalar(sx); 75 SkScalar sy_ = SkFloatToScalar(sy); 76 SkScalar px_ = SkFloatToScalar(px); 77 SkScalar py_ = SkFloatToScalar(py); 78 obj->setScale(sx_, sy_, px_, py_); 79 } 80 static void setScale__FF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat sx, jfloat sy) { 81 SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); 82 SkScalar sx_ = SkFloatToScalar(sx); 83 SkScalar sy_ = SkFloatToScalar(sy); 84 obj->setScale(sx_, sy_); 85 } 86 static void setRotate__FFF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat degrees, jfloat px, jfloat py) { 87 SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); 88 SkScalar degrees_ = SkFloatToScalar(degrees); 89 SkScalar px_ = SkFloatToScalar(px); 90 SkScalar py_ = SkFloatToScalar(py); 91 obj->setRotate(degrees_, px_, py_); 92 } 93 static void setRotate__F(JNIEnv* env, jobject clazz, jlong objHandle, jfloat degrees) { 94 SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); 95 SkScalar degrees_ = SkFloatToScalar(degrees); 96 obj->setRotate(degrees_); 97 } 98 static void setSinCos__FFFF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat sinValue, jfloat cosValue, jfloat px, jfloat py) { 99 SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); 100 SkScalar sinValue_ = SkFloatToScalar(sinValue); 101 SkScalar cosValue_ = SkFloatToScalar(cosValue); 102 SkScalar px_ = SkFloatToScalar(px); 103 SkScalar py_ = SkFloatToScalar(py); 104 obj->setSinCos(sinValue_, cosValue_, px_, py_); 105 } 106 static void setSinCos__FF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat sinValue, jfloat cosValue) { 107 SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); 108 SkScalar sinValue_ = SkFloatToScalar(sinValue); 109 SkScalar cosValue_ = SkFloatToScalar(cosValue); 110 obj->setSinCos(sinValue_, cosValue_); 111 } 112 static void setSkew__FFFF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat kx, jfloat ky, jfloat px, jfloat py) { 113 SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); 114 SkScalar kx_ = SkFloatToScalar(kx); 115 SkScalar ky_ = SkFloatToScalar(ky); 116 SkScalar px_ = SkFloatToScalar(px); 117 SkScalar py_ = SkFloatToScalar(py); 118 obj->setSkew(kx_, ky_, px_, py_); 119 } 120 static void setSkew__FF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat kx, jfloat ky) { 121 SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); 122 SkScalar kx_ = SkFloatToScalar(kx); 123 SkScalar ky_ = SkFloatToScalar(ky); 124 obj->setSkew(kx_, ky_); 125 } 126 static jboolean setConcat(JNIEnv* env, jobject clazz, jlong objHandle, jlong aHandle, jlong bHandle) { 127 SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); 128 SkMatrix* a = reinterpret_cast<SkMatrix*>(aHandle); 129 SkMatrix* b = reinterpret_cast<SkMatrix*>(bHandle); 130 return obj->setConcat(*a, *b) ? JNI_TRUE : JNI_FALSE; 131 } 132 133 static jboolean preTranslate(JNIEnv* env, jobject clazz, jlong objHandle, jfloat dx, jfloat dy) { 134 SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); 135 SkScalar dx_ = SkFloatToScalar(dx); 136 SkScalar dy_ = SkFloatToScalar(dy); 137 return obj->preTranslate(dx_, dy_) ? JNI_TRUE : JNI_FALSE; 138 } 139 140 static jboolean preScale__FFFF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat sx, jfloat sy, jfloat px, jfloat py) { 141 SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); 142 SkScalar sx_ = SkFloatToScalar(sx); 143 SkScalar sy_ = SkFloatToScalar(sy); 144 SkScalar px_ = SkFloatToScalar(px); 145 SkScalar py_ = SkFloatToScalar(py); 146 return obj->preScale(sx_, sy_, px_, py_) ? JNI_TRUE : JNI_FALSE; 147 } 148 149 static jboolean preScale__FF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat sx, jfloat sy) { 150 SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); 151 SkScalar sx_ = SkFloatToScalar(sx); 152 SkScalar sy_ = SkFloatToScalar(sy); 153 return obj->preScale(sx_, sy_) ? JNI_TRUE : JNI_FALSE; 154 } 155 156 static jboolean preRotate__FFF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat degrees, jfloat px, jfloat py) { 157 SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); 158 SkScalar degrees_ = SkFloatToScalar(degrees); 159 SkScalar px_ = SkFloatToScalar(px); 160 SkScalar py_ = SkFloatToScalar(py); 161 return obj->preRotate(degrees_, px_, py_) ? JNI_TRUE : JNI_FALSE; 162 } 163 164 static jboolean preRotate__F(JNIEnv* env, jobject clazz, jlong objHandle, jfloat degrees) { 165 SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); 166 SkScalar degrees_ = SkFloatToScalar(degrees); 167 return obj->preRotate(degrees_) ? JNI_TRUE : JNI_FALSE; 168 } 169 170 static jboolean preSkew__FFFF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat kx, jfloat ky, jfloat px, jfloat py) { 171 SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); 172 SkScalar kx_ = SkFloatToScalar(kx); 173 SkScalar ky_ = SkFloatToScalar(ky); 174 SkScalar px_ = SkFloatToScalar(px); 175 SkScalar py_ = SkFloatToScalar(py); 176 return obj->preSkew(kx_, ky_, px_, py_) ? JNI_TRUE : JNI_FALSE; 177 } 178 179 static jboolean preSkew__FF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat kx, jfloat ky) { 180 SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); 181 SkScalar kx_ = SkFloatToScalar(kx); 182 SkScalar ky_ = SkFloatToScalar(ky); 183 return obj->preSkew(kx_, ky_) ? JNI_TRUE : JNI_FALSE; 184 } 185 186 static jboolean preConcat(JNIEnv* env, jobject clazz, jlong objHandle, jlong otherHandle) { 187 SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); 188 SkMatrix* other = reinterpret_cast<SkMatrix*>(otherHandle); 189 return obj->preConcat(*other) ? JNI_TRUE : JNI_FALSE; 190 } 191 192 static jboolean postTranslate(JNIEnv* env, jobject clazz, jlong objHandle, jfloat dx, jfloat dy) { 193 SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); 194 SkScalar dx_ = SkFloatToScalar(dx); 195 SkScalar dy_ = SkFloatToScalar(dy); 196 return obj->postTranslate(dx_, dy_) ? JNI_TRUE : JNI_FALSE; 197 } 198 199 static jboolean postScale__FFFF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat sx, jfloat sy, jfloat px, jfloat py) { 200 SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); 201 SkScalar sx_ = SkFloatToScalar(sx); 202 SkScalar sy_ = SkFloatToScalar(sy); 203 SkScalar px_ = SkFloatToScalar(px); 204 SkScalar py_ = SkFloatToScalar(py); 205 return obj->postScale(sx_, sy_, px_, py_) ? JNI_TRUE : JNI_FALSE; 206 } 207 208 static jboolean postScale__FF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat sx, jfloat sy) { 209 SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); 210 SkScalar sx_ = SkFloatToScalar(sx); 211 SkScalar sy_ = SkFloatToScalar(sy); 212 return obj->postScale(sx_, sy_) ? JNI_TRUE : JNI_FALSE; 213 } 214 215 static jboolean postRotate__FFF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat degrees, jfloat px, jfloat py) { 216 SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); 217 SkScalar degrees_ = SkFloatToScalar(degrees); 218 SkScalar px_ = SkFloatToScalar(px); 219 SkScalar py_ = SkFloatToScalar(py); 220 return obj->postRotate(degrees_, px_, py_) ? JNI_TRUE : JNI_FALSE; 221 } 222 223 static jboolean postRotate__F(JNIEnv* env, jobject clazz, jlong objHandle, jfloat degrees) { 224 SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); 225 SkScalar degrees_ = SkFloatToScalar(degrees); 226 return obj->postRotate(degrees_) ? JNI_TRUE : JNI_FALSE; 227 } 228 229 static jboolean postSkew__FFFF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat kx, jfloat ky, jfloat px, jfloat py) { 230 SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); 231 SkScalar kx_ = SkFloatToScalar(kx); 232 SkScalar ky_ = SkFloatToScalar(ky); 233 SkScalar px_ = SkFloatToScalar(px); 234 SkScalar py_ = SkFloatToScalar(py); 235 return obj->postSkew(kx_, ky_, px_, py_) ? JNI_TRUE : JNI_FALSE; 236 } 237 238 static jboolean postSkew__FF(JNIEnv* env, jobject clazz, jlong matrixHandle, jfloat kx, jfloat ky) { 239 SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle); 240 SkScalar kx_ = SkFloatToScalar(kx); 241 SkScalar ky_ = SkFloatToScalar(ky); 242 return matrix->postSkew(kx_, ky_) ? JNI_TRUE : JNI_FALSE; 243 } 244 245 static jboolean postConcat(JNIEnv* env, jobject clazz, jlong matrixHandle, jlong otherHandle) { 246 SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle); 247 SkMatrix* other = reinterpret_cast<SkMatrix*>(otherHandle); 248 return matrix->postConcat(*other) ? JNI_TRUE : JNI_FALSE; 249 } 250 251 static jboolean setRectToRect(JNIEnv* env, jobject clazz, jlong matrixHandle, jobject src, jobject dst, jint stfHandle) { 252 SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle); 253 SkMatrix::ScaleToFit stf = static_cast<SkMatrix::ScaleToFit>(stfHandle); 254 SkRect src_; 255 GraphicsJNI::jrectf_to_rect(env, src, &src_); 256 SkRect dst_; 257 GraphicsJNI::jrectf_to_rect(env, dst, &dst_); 258 return matrix->setRectToRect(src_, dst_, stf) ? JNI_TRUE : JNI_FALSE; 259 } 260 261 static jboolean setPolyToPoly(JNIEnv* env, jobject clazz, jlong matrixHandle, 262 jfloatArray jsrc, jint srcIndex, 263 jfloatArray jdst, jint dstIndex, jint ptCount) { 264 SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle); 265 SkASSERT(srcIndex >= 0); 266 SkASSERT(dstIndex >= 0); 267 SkASSERT((unsigned)ptCount <= 4); 268 269 AutoJavaFloatArray autoSrc(env, jsrc, srcIndex + (ptCount << 1), kRO_JNIAccess); 270 AutoJavaFloatArray autoDst(env, jdst, dstIndex + (ptCount << 1), kRW_JNIAccess); 271 float* src = autoSrc.ptr() + srcIndex; 272 float* dst = autoDst.ptr() + dstIndex; 273 bool result; 274 275#ifdef SK_SCALAR_IS_FIXED 276 SkPoint srcPt[4], dstPt[4]; 277 for (int i = 0; i < ptCount; i++) { 278 int x = i << 1; 279 int y = x + 1; 280 srcPt[i].set(SkFloatToScalar(src[x]), SkFloatToScalar(src[y])); 281 dstPt[i].set(SkFloatToScalar(dst[x]), SkFloatToScalar(dst[y])); 282 } 283 result = matrix->setPolyToPoly(srcPt, dstPt, ptCount); 284#else 285 result = matrix->setPolyToPoly((const SkPoint*)src, (const SkPoint*)dst, 286 ptCount); 287#endif 288 return result ? JNI_TRUE : JNI_FALSE; 289 } 290 291 static jboolean invert(JNIEnv* env, jobject clazz, jlong matrixHandle, jlong inverseHandle) { 292 SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle); 293 SkMatrix* inverse = reinterpret_cast<SkMatrix*>(inverseHandle); 294 return matrix->invert(inverse); 295 } 296 297 static void mapPoints(JNIEnv* env, jobject clazz, jlong matrixHandle, 298 jfloatArray dst, jint dstIndex, 299 jfloatArray src, jint srcIndex, 300 jint ptCount, jboolean isPts) { 301 SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle); 302 SkASSERT(ptCount >= 0); 303 AutoJavaFloatArray autoSrc(env, src, srcIndex + (ptCount << 1), kRO_JNIAccess); 304 AutoJavaFloatArray autoDst(env, dst, dstIndex + (ptCount << 1), kRW_JNIAccess); 305 float* srcArray = autoSrc.ptr() + srcIndex; 306 float* dstArray = autoDst.ptr() + dstIndex; 307 308#ifdef SK_SCALAR_IS_FIXED 309 // we allocate twice the count, 1 set for src, 1 for dst 310 SkAutoSTMalloc<32, SkPoint> storage(ptCount * 2); 311 SkPoint* pts = storage.get(); 312 SkPoint* srcPt = pts; 313 SkPoint* dstPt = pts + ptCount; 314 315 int i; 316 for (i = 0; i < ptCount; i++) { 317 srcPt[i].set(SkFloatToScalar(srcArray[i << 1]), 318 SkFloatToScalar(srcArray[(i << 1) + 1])); 319 } 320 321 if (isPts) 322 matrix->mapPoints(dstPt, srcPt, ptCount); 323 else 324 matrix->mapVectors(dstPt, srcPt, ptCount); 325 326 for (i = 0; i < ptCount; i++) { 327 dstArray[i << 1] = SkScalarToFloat(dstPt[i].fX); 328 dstArray[(i << 1) + 1] = SkScalarToFloat(dstPt[i].fY); 329 } 330#else 331 if (isPts) 332 matrix->mapPoints((SkPoint*)dstArray, (const SkPoint*)srcArray, 333 ptCount); 334 else 335 matrix->mapVectors((SkVector*)dstArray, (const SkVector*)srcArray, 336 ptCount); 337#endif 338 } 339 340 static jboolean mapRect__RectFRectF(JNIEnv* env, jobject clazz, jlong matrixHandle, jobjectArray dst, jobject src) { 341 SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle); 342 SkRect dst_, src_; 343 GraphicsJNI::jrectf_to_rect(env, src, &src_); 344 jboolean rectStaysRect = matrix->mapRect(&dst_, src_); 345 GraphicsJNI::rect_to_jrectf(dst_, env, dst); 346 return rectStaysRect ? JNI_TRUE : JNI_FALSE; 347 } 348 349 static jfloat mapRadius(JNIEnv* env, jobject clazz, jlong matrixHandle, jfloat radius) { 350 SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle); 351 float result; 352 result = SkScalarToFloat(matrix->mapRadius(SkFloatToScalar(radius))); 353 return static_cast<jfloat>(result); 354 } 355 static void getValues(JNIEnv* env, jobject clazz, jlong matrixHandle, jfloatArray values) { 356 SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle); 357 AutoJavaFloatArray autoValues(env, values, 9, kRW_JNIAccess); 358 float* dst = autoValues.ptr(); 359 360#ifdef SK_SCALAR_IS_FIXED 361 for (int i = 0; i < 6; i++) { 362 dst[i] = SkFixedToFloat(matrix->get(i)); 363 } 364 for (int j = 6; j < 9; j++) { 365 dst[j] = SkFractToFloat(matrix->get(j)); 366 } 367#else 368 for (int i = 0; i < 9; i++) { 369 dst[i] = matrix->get(i); 370 } 371#endif 372 } 373 374 static void setValues(JNIEnv* env, jobject clazz, jlong matrixHandle, jfloatArray values) { 375 SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle); 376 AutoJavaFloatArray autoValues(env, values, 9, kRO_JNIAccess); 377 const float* src = autoValues.ptr(); 378 379#ifdef SK_SCALAR_IS_FIXED 380 for (int i = 0; i < 6; i++) { 381 matrix->set(i, SkFloatToFixed(src[i])); 382 } 383 for (int j = 6; j < 9; j++) { 384 matrix->set(j, SkFloatToFract(src[j])); 385 } 386#else 387 for (int i = 0; i < 9; i++) { 388 matrix->set(i, src[i]); 389 } 390#endif 391 } 392 393 static jboolean equals(JNIEnv* env, jobject clazz, jlong aHandle, jlong bHandle) { 394 const SkMatrix* a = reinterpret_cast<SkMatrix*>(aHandle); 395 const SkMatrix* b = reinterpret_cast<SkMatrix*>(bHandle); 396 return *a == *b; 397 } 398 }; 399 400static JNINativeMethod methods[] = { 401 {"finalizer", "(J)V", (void*) SkMatrixGlue::finalizer}, 402 {"native_create","(J)J", (void*) SkMatrixGlue::create}, 403 {"native_isIdentity","(J)Z", (void*) SkMatrixGlue::isIdentity}, 404 {"native_rectStaysRect","(J)Z", (void*) SkMatrixGlue::rectStaysRect}, 405 {"native_reset","(J)V", (void*) SkMatrixGlue::reset}, 406 {"native_set","(JJ)V", (void*) SkMatrixGlue::set}, 407 {"native_setTranslate","(JFF)V", (void*) SkMatrixGlue::setTranslate}, 408 {"native_setScale","(JFFFF)V", (void*) SkMatrixGlue::setScale__FFFF}, 409 {"native_setScale","(JFF)V", (void*) SkMatrixGlue::setScale__FF}, 410 {"native_setRotate","(JFFF)V", (void*) SkMatrixGlue::setRotate__FFF}, 411 {"native_setRotate","(JF)V", (void*) SkMatrixGlue::setRotate__F}, 412 {"native_setSinCos","(JFFFF)V", (void*) SkMatrixGlue::setSinCos__FFFF}, 413 {"native_setSinCos","(JFF)V", (void*) SkMatrixGlue::setSinCos__FF}, 414 {"native_setSkew","(JFFFF)V", (void*) SkMatrixGlue::setSkew__FFFF}, 415 {"native_setSkew","(JFF)V", (void*) SkMatrixGlue::setSkew__FF}, 416 {"native_setConcat","(JJJ)Z", (void*) SkMatrixGlue::setConcat}, 417 {"native_preTranslate","(JFF)Z", (void*) SkMatrixGlue::preTranslate}, 418 {"native_preScale","(JFFFF)Z", (void*) SkMatrixGlue::preScale__FFFF}, 419 {"native_preScale","(JFF)Z", (void*) SkMatrixGlue::preScale__FF}, 420 {"native_preRotate","(JFFF)Z", (void*) SkMatrixGlue::preRotate__FFF}, 421 {"native_preRotate","(JF)Z", (void*) SkMatrixGlue::preRotate__F}, 422 {"native_preSkew","(JFFFF)Z", (void*) SkMatrixGlue::preSkew__FFFF}, 423 {"native_preSkew","(JFF)Z", (void*) SkMatrixGlue::preSkew__FF}, 424 {"native_preConcat","(JJ)Z", (void*) SkMatrixGlue::preConcat}, 425 {"native_postTranslate","(JFF)Z", (void*) SkMatrixGlue::postTranslate}, 426 {"native_postScale","(JFFFF)Z", (void*) SkMatrixGlue::postScale__FFFF}, 427 {"native_postScale","(JFF)Z", (void*) SkMatrixGlue::postScale__FF}, 428 {"native_postRotate","(JFFF)Z", (void*) SkMatrixGlue::postRotate__FFF}, 429 {"native_postRotate","(JF)Z", (void*) SkMatrixGlue::postRotate__F}, 430 {"native_postSkew","(JFFFF)Z", (void*) SkMatrixGlue::postSkew__FFFF}, 431 {"native_postSkew","(JFF)Z", (void*) SkMatrixGlue::postSkew__FF}, 432 {"native_postConcat","(JJ)Z", (void*) SkMatrixGlue::postConcat}, 433 {"native_setRectToRect","(JLandroid/graphics/RectF;Landroid/graphics/RectF;I)Z", (void*) SkMatrixGlue::setRectToRect}, 434 {"native_setPolyToPoly","(J[FI[FII)Z", (void*) SkMatrixGlue::setPolyToPoly}, 435 {"native_invert","(JJ)Z", (void*) SkMatrixGlue::invert}, 436 {"native_mapPoints","(J[FI[FIIZ)V", (void*) SkMatrixGlue::mapPoints}, 437 {"native_mapRect","(JLandroid/graphics/RectF;Landroid/graphics/RectF;)Z", (void*) SkMatrixGlue::mapRect__RectFRectF}, 438 {"native_mapRadius","(JF)F", (void*) SkMatrixGlue::mapRadius}, 439 {"native_getValues","(J[F)V", (void*) SkMatrixGlue::getValues}, 440 {"native_setValues","(J[F)V", (void*) SkMatrixGlue::setValues}, 441 {"native_equals", "(JJ)Z", (void*) SkMatrixGlue::equals} 442}; 443 444static jfieldID sNativeInstanceField; 445 446int register_android_graphics_Matrix(JNIEnv* env) { 447 int result = AndroidRuntime::registerNativeMethods(env, "android/graphics/Matrix", methods, 448 sizeof(methods) / sizeof(methods[0])); 449 450 jclass clazz = env->FindClass("android/graphics/Matrix"); 451 sNativeInstanceField = env->GetFieldID(clazz, "native_instance", "J"); 452 453 return result; 454} 455 456SkMatrix* android_graphics_Matrix_getSkMatrix(JNIEnv* env, jobject matrixObj) { 457 return reinterpret_cast<SkMatrix*>(env->GetLongField(matrixObj, sNativeInstanceField)); 458} 459 460} 461