diff options
Diffstat (limited to 'core/jni/android/graphics')
21 files changed, 1482 insertions, 1035 deletions
diff --git a/core/jni/android/graphics/Bitmap.cpp b/core/jni/android/graphics/Bitmap.cpp index 2125763..24160ab 100644 --- a/core/jni/android/graphics/Bitmap.cpp +++ b/core/jni/android/graphics/Bitmap.cpp @@ -289,8 +289,9 @@ static int getPremulBitmapCreateFlags(bool isMutable) { }
static jobject Bitmap_creator(JNIEnv* env, jobject, jintArray jColors,
- int offset, int stride, int width, int height,
- SkBitmap::Config config, jboolean isMutable) {
+ jint offset, jint stride, jint width, jint height,
+ jint configHandle, jboolean isMutable) {
+ SkBitmap::Config config = static_cast<SkBitmap::Config>(configHandle);
if (NULL != jColors) {
size_t n = env->GetArrayLength(jColors);
if (n < SkAbs32(stride) * (size_t)height) {
@@ -321,8 +322,10 @@ static jobject Bitmap_creator(JNIEnv* env, jobject, jintArray jColors, getPremulBitmapCreateFlags(isMutable), NULL, NULL);
}
-static jobject Bitmap_copy(JNIEnv* env, jobject, const SkBitmap* src,
- SkBitmap::Config dstConfig, jboolean isMutable) {
+static jobject Bitmap_copy(JNIEnv* env, jobject, jlong srcHandle,
+ jint dstConfigHandle, jboolean isMutable) {
+ const SkBitmap* src = reinterpret_cast<SkBitmap*>(srcHandle);
+ SkBitmap::Config dstConfig = static_cast<SkBitmap::Config>(dstConfigHandle);
SkBitmap result;
JavaPixelAllocator allocator(env);
@@ -333,7 +336,8 @@ static jobject Bitmap_copy(JNIEnv* env, jobject, const SkBitmap* src, getPremulBitmapCreateFlags(isMutable), NULL, NULL);
}
-static void Bitmap_destructor(JNIEnv* env, jobject, SkBitmap* bitmap) {
+static void Bitmap_destructor(JNIEnv* env, jobject, jlong bitmapHandle) {
+ SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle);
#ifdef USE_OPENGL_RENDERER
if (android::uirenderer::Caches::hasInstance()) {
android::uirenderer::Caches::getInstance().resourceCache.destructor(bitmap);
@@ -343,24 +347,28 @@ static void Bitmap_destructor(JNIEnv* env, jobject, SkBitmap* bitmap) { delete bitmap;
}
-static jboolean Bitmap_recycle(JNIEnv* env, jobject, SkBitmap* bitmap) {
+static jboolean Bitmap_recycle(JNIEnv* env, jobject, jlong bitmapHandle) {
+ SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle);
#ifdef USE_OPENGL_RENDERER
if (android::uirenderer::Caches::hasInstance()) {
- return android::uirenderer::Caches::getInstance().resourceCache.recycle(bitmap);
+ bool result;
+ result = android::uirenderer::Caches::getInstance().resourceCache.recycle(bitmap);
+ return result ? JNI_TRUE : JNI_FALSE;
}
#endif // USE_OPENGL_RENDERER
bitmap->setPixels(NULL, NULL);
- return true;
+ return JNI_TRUE;
}
-static void Bitmap_reconfigure(JNIEnv* env, jobject clazz, jint bitmapInt,
- int width, int height, SkBitmap::Config config, int allocSize) {
+static void Bitmap_reconfigure(JNIEnv* env, jobject clazz, jlong bitmapHandle,
+ jint width, jint height, jint configHandle, jint allocSize) {
+ SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle);
+ SkBitmap::Config config = static_cast<SkBitmap::Config>(configHandle);
if (width * height * SkBitmap::ComputeBytesPerPixel(config) > allocSize) {
// done in native as there's no way to get BytesPerPixel in Java
doThrowIAE(env, "Bitmap not large enough to support new configuration");
return;
}
- SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapInt);
SkPixelRef* ref = bitmap->pixelRef();
SkSafeRef(ref);
bitmap->setConfig(config, width, height);
@@ -380,9 +388,10 @@ enum JavaEncodeFormat { kWEBP_JavaEncodeFormat = 2
};
-static bool Bitmap_compress(JNIEnv* env, jobject clazz, SkBitmap* bitmap,
- int format, int quality,
- jobject jstream, jbyteArray jstorage) {
+static jboolean Bitmap_compress(JNIEnv* env, jobject clazz, jlong bitmapHandle,
+ jint format, jint quality,
+ jobject jstream, jbyteArray jstorage) {
+ SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle);
SkImageEncoder::Type fm;
switch (format) {
@@ -396,7 +405,7 @@ static bool Bitmap_compress(JNIEnv* env, jobject clazz, SkBitmap* bitmap, fm = SkImageEncoder::kWEBP_Type;
break;
default:
- return false;
+ return JNI_FALSE;
}
bool success = false;
@@ -404,12 +413,12 @@ static bool Bitmap_compress(JNIEnv* env, jobject clazz, SkBitmap* bitmap, SkAutoLockPixels alp(*bitmap);
if (NULL == bitmap->getPixels()) {
- return false;
+ return JNI_FALSE;
}
SkWStream* strm = CreateJavaOutputStreamAdaptor(env, jstream, jstorage);
if (NULL == strm) {
- return false;
+ return JNI_FALSE;
}
SkImageEncoder* encoder = SkImageEncoder::Create(fm);
@@ -419,31 +428,37 @@ static bool Bitmap_compress(JNIEnv* env, jobject clazz, SkBitmap* bitmap, }
delete strm;
}
- return success;
+ return success ? JNI_TRUE : JNI_FALSE;
}
-static void Bitmap_erase(JNIEnv* env, jobject, SkBitmap* bitmap, jint color) {
+static void Bitmap_erase(JNIEnv* env, jobject, jlong bitmapHandle, jint color) {
+ SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle);
bitmap->eraseColor(color);
}
-static int Bitmap_rowBytes(JNIEnv* env, jobject, SkBitmap* bitmap) {
- return bitmap->rowBytes();
+static jint Bitmap_rowBytes(JNIEnv* env, jobject, jlong bitmapHandle) {
+ SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle);
+ return static_cast<jint>(bitmap->rowBytes());
}
-static int Bitmap_config(JNIEnv* env, jobject, SkBitmap* bitmap) {
- return bitmap->config();
+static jint Bitmap_config(JNIEnv* env, jobject, jlong bitmapHandle) {
+ SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle);
+ return static_cast<jint>(bitmap->config());
}
-static int Bitmap_getGenerationId(JNIEnv* env, jobject, SkBitmap* bitmap) {
- return bitmap->getGenerationID();
+static jint Bitmap_getGenerationId(JNIEnv* env, jobject, jlong bitmapHandle) {
+ SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle);
+ return static_cast<jint>(bitmap->getGenerationID());
}
-static jboolean Bitmap_hasAlpha(JNIEnv* env, jobject, SkBitmap* bitmap) {
- return !bitmap->isOpaque();
+static jboolean Bitmap_hasAlpha(JNIEnv* env, jobject, jlong bitmapHandle) {
+ SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle);
+ return !bitmap->isOpaque() ? JNI_TRUE : JNI_FALSE;
}
-static void Bitmap_setAlphaAndPremultiplied(JNIEnv* env, jobject, SkBitmap* bitmap,
+static void Bitmap_setAlphaAndPremultiplied(JNIEnv* env, jobject, jlong bitmapHandle,
jboolean hasAlpha, jboolean isPremul) {
+ SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle);
if (!hasAlpha) {
bitmap->setAlphaType(kOpaque_SkAlphaType);
} else if (isPremul) {
@@ -451,14 +466,17 @@ static void Bitmap_setAlphaAndPremultiplied(JNIEnv* env, jobject, SkBitmap* bitm } else {
bitmap->setAlphaType(kUnpremul_SkAlphaType);
}
+ bitmap->setIsOpaque(!hasAlpha);
}
-static jboolean Bitmap_hasMipMap(JNIEnv* env, jobject, SkBitmap* bitmap) {
- return bitmap->hasHardwareMipMap();
+static jboolean Bitmap_hasMipMap(JNIEnv* env, jobject, jlong bitmapHandle) {
+ SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle);
+ return bitmap->hasHardwareMipMap() ? JNI_TRUE : JNI_FALSE;
}
-static void Bitmap_setHasMipMap(JNIEnv* env, jobject, SkBitmap* bitmap,
+static void Bitmap_setHasMipMap(JNIEnv* env, jobject, jlong bitmapHandle,
jboolean hasMipMap) {
+ SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle);
bitmap->setHasHardwareMipMap(hasMipMap);
}
@@ -532,12 +550,13 @@ static jobject Bitmap_createFromParcel(JNIEnv* env, jobject, jobject parcel) { }
static jboolean Bitmap_writeToParcel(JNIEnv* env, jobject,
- const SkBitmap* bitmap,
+ jlong bitmapHandle,
jboolean isMutable, jint density,
jobject parcel) {
+ const SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle);
if (parcel == NULL) {
SkDebugf("------- writeToParcel null parcel\n");
- return false;
+ return JNI_FALSE;
}
android::Parcel* p = android::parcelForJavaObject(env, parcel);
@@ -568,7 +587,7 @@ static jboolean Bitmap_writeToParcel(JNIEnv* env, jobject, android::status_t status = p->writeBlob(size, &blob);
if (status) {
doThrowRE(env, "Could not write bitmap to parcel blob.");
- return false;
+ return JNI_FALSE;
}
bitmap->lockPixels();
@@ -581,12 +600,14 @@ static jboolean Bitmap_writeToParcel(JNIEnv* env, jobject, bitmap->unlockPixels();
blob.release();
- return true;
+ return JNI_TRUE;
}
static jobject Bitmap_extractAlpha(JNIEnv* env, jobject clazz,
- const SkBitmap* src, const SkPaint* paint,
+ jlong srcHandle, jlong paintHandle,
jintArray offsetXY) {
+ const SkBitmap* src = reinterpret_cast<SkBitmap*>(srcHandle);
+ const SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle);
SkIPoint offset;
SkBitmap* dst = new SkBitmap;
JavaPixelAllocator allocator(env);
@@ -612,8 +633,9 @@ static jobject Bitmap_extractAlpha(JNIEnv* env, jobject clazz, ///////////////////////////////////////////////////////////////////////////////
-static int Bitmap_getPixel(JNIEnv* env, jobject, const SkBitmap* bitmap,
- int x, int y, bool isPremultiplied) {
+static jint Bitmap_getPixel(JNIEnv* env, jobject, jlong bitmapHandle,
+ jint x, jint y, jboolean isPremultiplied) {
+ const SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle);
SkAutoLockPixels alp(*bitmap);
ToColorProc proc = ChooseToColorProc(*bitmap, isPremultiplied);
@@ -627,12 +649,13 @@ static int Bitmap_getPixel(JNIEnv* env, jobject, const SkBitmap* bitmap, SkColor dst[1];
proc(dst, src, 1, bitmap->getColorTable());
- return dst[0];
+ return static_cast<jint>(dst[0]);
}
-static void Bitmap_getPixels(JNIEnv* env, jobject, const SkBitmap* bitmap,
- jintArray pixelArray, int offset, int stride,
- int x, int y, int width, int height, bool isPremultiplied) {
+static void Bitmap_getPixels(JNIEnv* env, jobject, jlong bitmapHandle,
+ jintArray pixelArray, jint offset, jint stride,
+ jint x, jint y, jint width, jint height, jboolean isPremultiplied) {
+ const SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle);
SkAutoLockPixels alp(*bitmap);
ToColorProc proc = ChooseToColorProc(*bitmap, isPremultiplied);
@@ -657,8 +680,10 @@ static void Bitmap_getPixels(JNIEnv* env, jobject, const SkBitmap* bitmap, ///////////////////////////////////////////////////////////////////////////////
-static void Bitmap_setPixel(JNIEnv* env, jobject, const SkBitmap* bitmap,
- int x, int y, SkColor color, bool isPremultiplied) {
+static void Bitmap_setPixel(JNIEnv* env, jobject, jlong bitmapHandle,
+ jint x, jint y, jint colorHandle, jboolean isPremultiplied) {
+ const SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle);
+ SkColor color = static_cast<SkColor>(colorHandle);
SkAutoLockPixels alp(*bitmap);
if (NULL == bitmap->getPixels()) {
return;
@@ -673,15 +698,17 @@ static void Bitmap_setPixel(JNIEnv* env, jobject, const SkBitmap* bitmap, bitmap->notifyPixelsChanged();
}
-static void Bitmap_setPixels(JNIEnv* env, jobject, const SkBitmap* bitmap,
- jintArray pixelArray, int offset, int stride,
- int x, int y, int width, int height, bool isPremultiplied) {
+static void Bitmap_setPixels(JNIEnv* env, jobject, jlong bitmapHandle,
+ jintArray pixelArray, jint offset, jint stride,
+ jint x, jint y, jint width, jint height, jboolean isPremultiplied) {
+ const SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle);
GraphicsJNI::SetPixels(env, pixelArray, offset, stride,
x, y, width, height, *bitmap, isPremultiplied);
}
static void Bitmap_copyPixelsToBuffer(JNIEnv* env, jobject,
- const SkBitmap* bitmap, jobject jbuffer) {
+ jlong bitmapHandle, jobject jbuffer) {
+ const SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle);
SkAutoLockPixels alp(*bitmap);
const void* src = bitmap->getPixels();
@@ -694,7 +721,8 @@ static void Bitmap_copyPixelsToBuffer(JNIEnv* env, jobject, }
static void Bitmap_copyPixelsFromBuffer(JNIEnv* env, jobject,
- const SkBitmap* bitmap, jobject jbuffer) {
+ jlong bitmapHandle, jobject jbuffer) {
+ SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle);
SkAutoLockPixels alp(*bitmap);
void* dst = bitmap->getPixels();
@@ -706,12 +734,14 @@ static void Bitmap_copyPixelsFromBuffer(JNIEnv* env, jobject, }
}
-static bool Bitmap_sameAs(JNIEnv* env, jobject, const SkBitmap* bm0,
- const SkBitmap* bm1) {
+static jboolean Bitmap_sameAs(JNIEnv* env, jobject, jlong bm0Handle,
+ jlong bm1Handle) {
+ const SkBitmap* bm0 = reinterpret_cast<SkBitmap*>(bm0Handle);
+ const SkBitmap* bm1 = reinterpret_cast<SkBitmap*>(bm1Handle);
if (bm0->width() != bm1->width() ||
bm0->height() != bm1->height() ||
bm0->config() != bm1->config()) {
- return false;
+ return JNI_FALSE;
}
SkAutoLockPixels alp0(*bm0);
@@ -719,24 +749,24 @@ static bool Bitmap_sameAs(JNIEnv* env, jobject, const SkBitmap* bm0, // if we can't load the pixels, return false
if (NULL == bm0->getPixels() || NULL == bm1->getPixels()) {
- return false;
+ return JNI_FALSE;
}
if (bm0->config() == SkBitmap::kIndex8_Config) {
SkColorTable* ct0 = bm0->getColorTable();
SkColorTable* ct1 = bm1->getColorTable();
if (NULL == ct0 || NULL == ct1) {
- return false;
+ return JNI_FALSE;
}
if (ct0->count() != ct1->count()) {
- return false;
+ return JNI_FALSE;
}
SkAutoLockColors alc0(ct0);
SkAutoLockColors alc1(ct1);
const size_t size = ct0->count() * sizeof(SkPMColor);
if (memcmp(alc0.colors(), alc1.colors(), size) != 0) {
- return false;
+ return JNI_FALSE;
}
}
@@ -747,13 +777,14 @@ static bool Bitmap_sameAs(JNIEnv* env, jobject, const SkBitmap* bm0, const size_t size = bm0->width() * bm0->bytesPerPixel();
for (int y = 0; y < h; y++) {
if (memcmp(bm0->getAddr(0, y), bm1->getAddr(0, y), size) != 0) {
- return false;
+ return JNI_FALSE;
}
}
- return true;
+ return JNI_TRUE;
}
-static void Bitmap_prepareToDraw(JNIEnv* env, jobject, SkBitmap* bitmap) {
+static void Bitmap_prepareToDraw(JNIEnv* env, jobject, jlong bitmapHandle) {
+ SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle);
bitmap->lockPixels();
bitmap->unlockPixels();
}
@@ -765,38 +796,38 @@ static void Bitmap_prepareToDraw(JNIEnv* env, jobject, SkBitmap* bitmap) { static JNINativeMethod gBitmapMethods[] = {
{ "nativeCreate", "([IIIIIIZ)Landroid/graphics/Bitmap;",
(void*)Bitmap_creator },
- { "nativeCopy", "(IIZ)Landroid/graphics/Bitmap;",
+ { "nativeCopy", "(JIZ)Landroid/graphics/Bitmap;",
(void*)Bitmap_copy },
- { "nativeDestructor", "(I)V", (void*)Bitmap_destructor },
- { "nativeRecycle", "(I)Z", (void*)Bitmap_recycle },
- { "nativeReconfigure", "(IIIII)V", (void*)Bitmap_reconfigure },
- { "nativeCompress", "(IIILjava/io/OutputStream;[B)Z",
+ { "nativeDestructor", "(J)V", (void*)Bitmap_destructor },
+ { "nativeRecycle", "(J)Z", (void*)Bitmap_recycle },
+ { "nativeReconfigure", "(JIIII)V", (void*)Bitmap_reconfigure },
+ { "nativeCompress", "(JIILjava/io/OutputStream;[B)Z",
(void*)Bitmap_compress },
- { "nativeErase", "(II)V", (void*)Bitmap_erase },
- { "nativeRowBytes", "(I)I", (void*)Bitmap_rowBytes },
- { "nativeConfig", "(I)I", (void*)Bitmap_config },
- { "nativeHasAlpha", "(I)Z", (void*)Bitmap_hasAlpha },
- { "nativeSetAlphaAndPremultiplied", "(IZZ)V", (void*)Bitmap_setAlphaAndPremultiplied},
- { "nativeHasMipMap", "(I)Z", (void*)Bitmap_hasMipMap },
- { "nativeSetHasMipMap", "(IZ)V", (void*)Bitmap_setHasMipMap },
+ { "nativeErase", "(JI)V", (void*)Bitmap_erase },
+ { "nativeRowBytes", "(J)I", (void*)Bitmap_rowBytes },
+ { "nativeConfig", "(J)I", (void*)Bitmap_config },
+ { "nativeHasAlpha", "(J)Z", (void*)Bitmap_hasAlpha },
+ { "nativeSetAlphaAndPremultiplied", "(JZZ)V", (void*)Bitmap_setAlphaAndPremultiplied},
+ { "nativeHasMipMap", "(J)Z", (void*)Bitmap_hasMipMap },
+ { "nativeSetHasMipMap", "(JZ)V", (void*)Bitmap_setHasMipMap },
{ "nativeCreateFromParcel",
"(Landroid/os/Parcel;)Landroid/graphics/Bitmap;",
(void*)Bitmap_createFromParcel },
- { "nativeWriteToParcel", "(IZILandroid/os/Parcel;)Z",
+ { "nativeWriteToParcel", "(JZILandroid/os/Parcel;)Z",
(void*)Bitmap_writeToParcel },
- { "nativeExtractAlpha", "(II[I)Landroid/graphics/Bitmap;",
+ { "nativeExtractAlpha", "(JJ[I)Landroid/graphics/Bitmap;",
(void*)Bitmap_extractAlpha },
- { "nativeGenerationId", "(I)I", (void*)Bitmap_getGenerationId },
- { "nativeGetPixel", "(IIIZ)I", (void*)Bitmap_getPixel },
- { "nativeGetPixels", "(I[IIIIIIIZ)V", (void*)Bitmap_getPixels },
- { "nativeSetPixel", "(IIIIZ)V", (void*)Bitmap_setPixel },
- { "nativeSetPixels", "(I[IIIIIIIZ)V", (void*)Bitmap_setPixels },
- { "nativeCopyPixelsToBuffer", "(ILjava/nio/Buffer;)V",
+ { "nativeGenerationId", "(J)I", (void*)Bitmap_getGenerationId },
+ { "nativeGetPixel", "(JIIZ)I", (void*)Bitmap_getPixel },
+ { "nativeGetPixels", "(J[IIIIIIIZ)V", (void*)Bitmap_getPixels },
+ { "nativeSetPixel", "(JIIIZ)V", (void*)Bitmap_setPixel },
+ { "nativeSetPixels", "(J[IIIIIIIZ)V", (void*)Bitmap_setPixels },
+ { "nativeCopyPixelsToBuffer", "(JLjava/nio/Buffer;)V",
(void*)Bitmap_copyPixelsToBuffer },
- { "nativeCopyPixelsFromBuffer", "(ILjava/nio/Buffer;)V",
+ { "nativeCopyPixelsFromBuffer", "(JLjava/nio/Buffer;)V",
(void*)Bitmap_copyPixelsFromBuffer },
- { "nativeSameAs", "(II)Z", (void*)Bitmap_sameAs },
- { "nativePrepareToDraw", "(I)V", (void*)Bitmap_prepareToDraw },
+ { "nativeSameAs", "(JJ)Z", (void*)Bitmap_sameAs },
+ { "nativePrepareToDraw", "(J)V", (void*)Bitmap_prepareToDraw },
};
#define kClassPathName "android/graphics/Bitmap"
diff --git a/core/jni/android/graphics/BitmapFactory.cpp b/core/jni/android/graphics/BitmapFactory.cpp index d042ce9..3e1f26a 100644 --- a/core/jni/android/graphics/BitmapFactory.cpp +++ b/core/jni/android/graphics/BitmapFactory.cpp @@ -273,7 +273,7 @@ static jobject doDecode(JNIEnv* env, SkStreamRewindable* stream, jobject padding SkBitmap* outputBitmap = NULL; unsigned int existingBufferSize = 0; if (javaBitmap != NULL) { - outputBitmap = (SkBitmap*) env->GetIntField(javaBitmap, gBitmap_nativeBitmapFieldID); + outputBitmap = (SkBitmap*) env->GetLongField(javaBitmap, gBitmap_nativeBitmapFieldID); if (outputBitmap->isImmutable()) { ALOGW("Unable to reuse an immutable bitmap as an image decoder target."); javaBitmap = NULL; @@ -532,7 +532,7 @@ static jobject nativeDecodeFileDescriptor(JNIEnv* env, jobject clazz, jobject fi return doDecode(env, stream, padding, bitmapFactoryOptions, weOwnTheFD); } -static jobject nativeDecodeAsset(JNIEnv* env, jobject clazz, jint native_asset, +static jobject nativeDecodeAsset(JNIEnv* env, jobject clazz, jlong native_asset, jobject padding, jobject options) { SkStreamRewindable* stream; @@ -557,7 +557,7 @@ static jobject nativeDecodeAsset(JNIEnv* env, jobject clazz, jint native_asset, } static jobject nativeDecodeByteArray(JNIEnv* env, jobject, jbyteArray byteArray, - int offset, int length, jobject options) { + jint offset, jint length, jobject options) { /* If optionsShareable() we could decide to just wrap the java array and share it, but that means adding a globalref to the java array object @@ -594,7 +594,7 @@ static JNINativeMethod gMethods[] = { }, { "nativeDecodeAsset", - "(ILandroid/graphics/Rect;Landroid/graphics/BitmapFactory$Options;)Landroid/graphics/Bitmap;", + "(JLandroid/graphics/Rect;Landroid/graphics/BitmapFactory$Options;)Landroid/graphics/Bitmap;", (void*)nativeDecodeAsset }, @@ -647,7 +647,7 @@ int register_android_graphics_BitmapFactory(JNIEnv* env) { jclass bitmap_class = env->FindClass("android/graphics/Bitmap"); SkASSERT(bitmap_class); - gBitmap_nativeBitmapFieldID = getFieldIDCheck(env, bitmap_class, "mNativeBitmap", "I"); + gBitmap_nativeBitmapFieldID = getFieldIDCheck(env, bitmap_class, "mNativeBitmap", "J"); gBitmap_layoutBoundsFieldID = getFieldIDCheck(env, bitmap_class, "mLayoutBounds", "[I"); int ret = AndroidRuntime::registerNativeMethods(env, "android/graphics/BitmapFactory$Options", diff --git a/core/jni/android/graphics/Camera.cpp b/core/jni/android/graphics/Camera.cpp index 5176d9a..54d448e 100644 --- a/core/jni/android/graphics/Camera.cpp +++ b/core/jni/android/graphics/Camera.cpp @@ -7,84 +7,102 @@ static jfieldID gNativeInstanceFieldID; static void Camera_constructor(JNIEnv* env, jobject obj) { Sk3DView* view = new Sk3DView; - env->SetIntField(obj, gNativeInstanceFieldID, (int)view); + env->SetLongField(obj, gNativeInstanceFieldID, reinterpret_cast<jlong>(view)); } static void Camera_destructor(JNIEnv* env, jobject obj) { - delete (Sk3DView*)env->GetIntField(obj, gNativeInstanceFieldID); + jlong viewHandle = env->GetLongField(obj, gNativeInstanceFieldID); + Sk3DView* view = reinterpret_cast<Sk3DView*>(viewHandle); + delete view; } static void Camera_save(JNIEnv* env, jobject obj) { - Sk3DView* v = (Sk3DView*)env->GetIntField(obj, gNativeInstanceFieldID); + jlong viewHandle = env->GetLongField(obj, gNativeInstanceFieldID); + Sk3DView* v = reinterpret_cast<Sk3DView*>(viewHandle); v->save(); } static void Camera_restore(JNIEnv* env, jobject obj) { - Sk3DView* v = (Sk3DView*)env->GetIntField(obj, gNativeInstanceFieldID); + jlong viewHandle = env->GetLongField(obj, gNativeInstanceFieldID); + Sk3DView* v = reinterpret_cast<Sk3DView*>(viewHandle); v->restore(); } static void Camera_translate(JNIEnv* env, jobject obj, - float dx, float dy, float dz) { - Sk3DView* v = (Sk3DView*)env->GetIntField(obj, gNativeInstanceFieldID); + jfloat dx, jfloat dy, jfloat dz) { + jlong viewHandle = env->GetLongField(obj, gNativeInstanceFieldID); + Sk3DView* v = reinterpret_cast<Sk3DView*>(viewHandle); v->translate(SkFloatToScalar(dx), SkFloatToScalar(dy), SkFloatToScalar(dz)); } -static void Camera_rotateX(JNIEnv* env, jobject obj, float degrees) { - Sk3DView* v = (Sk3DView*)env->GetIntField(obj, gNativeInstanceFieldID); +static void Camera_rotateX(JNIEnv* env, jobject obj, jfloat degrees) { + jlong viewHandle = env->GetLongField(obj, gNativeInstanceFieldID); + Sk3DView* v = reinterpret_cast<Sk3DView*>(viewHandle); v->rotateX(SkFloatToScalar(degrees)); } -static void Camera_rotateY(JNIEnv* env, jobject obj, float degrees) { - Sk3DView* v = (Sk3DView*)env->GetIntField(obj, gNativeInstanceFieldID); +static void Camera_rotateY(JNIEnv* env, jobject obj, jfloat degrees) { + jlong viewHandle = env->GetLongField(obj, gNativeInstanceFieldID); + Sk3DView* v = reinterpret_cast<Sk3DView*>(viewHandle); v->rotateY(SkFloatToScalar(degrees)); } -static void Camera_rotateZ(JNIEnv* env, jobject obj, float degrees) { - Sk3DView* v = (Sk3DView*)env->GetIntField(obj, gNativeInstanceFieldID); +static void Camera_rotateZ(JNIEnv* env, jobject obj, jfloat degrees) { + jlong viewHandle = env->GetLongField(obj, gNativeInstanceFieldID); + Sk3DView* v = reinterpret_cast<Sk3DView*>(viewHandle); v->rotateZ(SkFloatToScalar(degrees)); } static void Camera_rotate(JNIEnv* env, jobject obj, jfloat x, jfloat y, jfloat z) { - Sk3DView* v = (Sk3DView*)env->GetIntField(obj, gNativeInstanceFieldID); + jlong viewHandle = env->GetLongField(obj, gNativeInstanceFieldID); + Sk3DView* v = reinterpret_cast<Sk3DView*>(viewHandle); v->rotateX(SkFloatToScalar(x)); v->rotateY(SkFloatToScalar(y)); v->rotateZ(SkFloatToScalar(z)); } static void Camera_setLocation(JNIEnv* env, jobject obj, jfloat x, jfloat y, jfloat z) { - Sk3DView* v = (Sk3DView*)env->GetIntField(obj, gNativeInstanceFieldID); + jlong viewHandle = env->GetLongField(obj, gNativeInstanceFieldID); + Sk3DView* v = reinterpret_cast<Sk3DView*>(viewHandle); v->setCameraLocation(SkFloatToScalar(x), SkFloatToScalar(y), SkFloatToScalar(z)); } static jfloat Camera_getLocationX(JNIEnv* env, jobject obj) { - Sk3DView* v = (Sk3DView*)env->GetIntField(obj, gNativeInstanceFieldID); + jlong viewHandle = env->GetLongField(obj, gNativeInstanceFieldID); + Sk3DView* v = reinterpret_cast<Sk3DView*>(viewHandle); return SkScalarToFloat(v->getCameraLocationX()); } static jfloat Camera_getLocationY(JNIEnv* env, jobject obj) { - Sk3DView* v = (Sk3DView*)env->GetIntField(obj, gNativeInstanceFieldID); + jlong viewHandle = env->GetLongField(obj, gNativeInstanceFieldID); + Sk3DView* v = reinterpret_cast<Sk3DView*>(viewHandle); return SkScalarToFloat(v->getCameraLocationY()); } static jfloat Camera_getLocationZ(JNIEnv* env, jobject obj) { - Sk3DView* v = (Sk3DView*)env->GetIntField(obj, gNativeInstanceFieldID); + jlong viewHandle = env->GetLongField(obj, gNativeInstanceFieldID); + Sk3DView* v = reinterpret_cast<Sk3DView*>(viewHandle); return SkScalarToFloat(v->getCameraLocationZ()); } -static void Camera_getMatrix(JNIEnv* env, jobject obj, int native_matrix) { - Sk3DView* v = (Sk3DView*)env->GetIntField(obj, gNativeInstanceFieldID); - v->getMatrix((SkMatrix*)native_matrix); +static void Camera_getMatrix(JNIEnv* env, jobject obj, jlong matrixHandle) { + SkMatrix* native_matrix = reinterpret_cast<SkMatrix*>(matrixHandle); + jlong viewHandle = env->GetLongField(obj, gNativeInstanceFieldID); + Sk3DView* v = reinterpret_cast<Sk3DView*>(viewHandle); + v->getMatrix(native_matrix); } -static void Camera_applyToCanvas(JNIEnv* env, jobject obj, int native_canvas) { - Sk3DView* v = (Sk3DView*)env->GetIntField(obj, gNativeInstanceFieldID); +static void Camera_applyToCanvas(JNIEnv* env, jobject obj, jlong canvasHandle) { + SkCanvas* native_canvas = reinterpret_cast<SkCanvas*>(canvasHandle); + jlong viewHandle = env->GetLongField(obj, gNativeInstanceFieldID); + Sk3DView* v = reinterpret_cast<Sk3DView*>(viewHandle); v->applyToCanvas((SkCanvas*)native_canvas); } -static float Camera_dotWithNormal(JNIEnv* env, jobject obj, - float x, float y, float z) { - Sk3DView* v = (Sk3DView*)env->GetIntField(obj, gNativeInstanceFieldID); +static jfloat Camera_dotWithNormal(JNIEnv* env, jobject obj, + jfloat x, jfloat y, jfloat z) { + jlong viewHandle = env->GetLongField(obj, gNativeInstanceFieldID); + Sk3DView* v = reinterpret_cast<Sk3DView*>(viewHandle); SkScalar dot = v->dotWithNormal(SkFloatToScalar(x), SkFloatToScalar(y), SkFloatToScalar(z)); return SkScalarToFloat(dot); @@ -111,8 +129,8 @@ static JNINativeMethod gCameraMethods[] = { { "getLocationX", "()F", (void*)Camera_getLocationX }, { "getLocationY", "()F", (void*)Camera_getLocationY }, { "getLocationZ", "()F", (void*)Camera_getLocationZ }, - { "nativeGetMatrix", "(I)V", (void*)Camera_getMatrix }, - { "nativeApplyToCanvas", "(I)V", (void*)Camera_applyToCanvas }, + { "nativeGetMatrix", "(J)V", (void*)Camera_getMatrix }, + { "nativeApplyToCanvas", "(J)V", (void*)Camera_applyToCanvas }, { "dotWithNormal", "(FFF)F", (void*)Camera_dotWithNormal } }; @@ -121,7 +139,7 @@ int register_android_graphics_Camera(JNIEnv* env) { if (clazz == 0) { return -1; } - gNativeInstanceFieldID = env->GetFieldID(clazz, "native_instance", "I"); + gNativeInstanceFieldID = env->GetFieldID(clazz, "native_instance", "J"); if (gNativeInstanceFieldID == 0) { return -1; } diff --git a/core/jni/android/graphics/Canvas.cpp b/core/jni/android/graphics/Canvas.cpp index 9a00d53..2cb2812 100644 --- a/core/jni/android/graphics/Canvas.cpp +++ b/core/jni/android/graphics/Canvas.cpp @@ -44,13 +44,13 @@ static uint32_t get_thread_msec() { #if defined(HAVE_POSIX_CLOCKS) struct timespec tm; - + clock_gettime(CLOCK_THREAD_CPUTIME_ID, &tm); - + return tm.tv_sec * 1000LL + tm.tv_nsec / 1000000; #else struct timeval tv; - + gettimeofday(&tv, NULL); return tv.tv_sec * 1000LL + tv.tv_usec / 1000; #endif @@ -76,23 +76,27 @@ private: class SkCanvasGlue { public: - static void finalizer(JNIEnv* env, jobject clazz, SkCanvas* canvas) { + static void finalizer(JNIEnv* env, jobject clazz, jlong canvasHandle) { + SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle); canvas->unref(); } - static SkCanvas* initRaster(JNIEnv* env, jobject, SkBitmap* bitmap) { + static jlong initRaster(JNIEnv* env, jobject, jlong bitmapHandle) { + SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle); if (bitmap) { - return new SkCanvas(*bitmap); + return reinterpret_cast<jlong>(new SkCanvas(*bitmap)); } else { // Create an empty bitmap device to prevent callers from crashing // if they attempt to draw into this canvas. SkBitmap emptyBitmap; - return new SkCanvas(emptyBitmap); + return reinterpret_cast<jlong>(new SkCanvas(emptyBitmap)); } } - + static void copyCanvasState(JNIEnv* env, jobject clazz, - SkCanvas* srcCanvas, SkCanvas* dstCanvas) { + jlong srcCanvasHandle, jlong dstCanvasHandle) { + SkCanvas* srcCanvas = reinterpret_cast<SkCanvas*>(srcCanvasHandle); + SkCanvas* dstCanvas = reinterpret_cast<SkCanvas*>(dstCanvasHandle); if (srcCanvas && dstCanvas) { dstCanvas->setMatrix(srcCanvas->getTotalMatrix()); if (NULL != srcCanvas->getDevice() && NULL != dstCanvas->getDevice()) { @@ -116,73 +120,89 @@ public: static jboolean isOpaque(JNIEnv* env, jobject jcanvas) { NPE_CHECK_RETURN_ZERO(env, jcanvas); SkCanvas* canvas = GraphicsJNI::getNativeCanvas(env, jcanvas); - return canvas->getDevice()->accessBitmap(false).isOpaque(); + bool result = canvas->getDevice()->accessBitmap(false).isOpaque(); + return result ? JNI_TRUE : JNI_FALSE; } - - static int getWidth(JNIEnv* env, jobject jcanvas) { + + static jint getWidth(JNIEnv* env, jobject jcanvas) { NPE_CHECK_RETURN_ZERO(env, jcanvas); SkCanvas* canvas = GraphicsJNI::getNativeCanvas(env, jcanvas); - return canvas->getDevice()->accessBitmap(false).width(); + int width = canvas->getDevice()->accessBitmap(false).width(); + return static_cast<jint>(width); } - - static int getHeight(JNIEnv* env, jobject jcanvas) { + + static jint getHeight(JNIEnv* env, jobject jcanvas) { NPE_CHECK_RETURN_ZERO(env, jcanvas); SkCanvas* canvas = GraphicsJNI::getNativeCanvas(env, jcanvas); - return canvas->getDevice()->accessBitmap(false).height(); + int height = canvas->getDevice()->accessBitmap(false).height(); + return static_cast<jint>(height); } - static int saveAll(JNIEnv* env, jobject jcanvas) { + static jint saveAll(JNIEnv* env, jobject jcanvas) { NPE_CHECK_RETURN_ZERO(env, jcanvas); - return GraphicsJNI::getNativeCanvas(env, jcanvas)->save(); + int result = GraphicsJNI::getNativeCanvas(env, jcanvas)->save(); + return static_cast<jint>(result); } - - static int save(JNIEnv* env, jobject jcanvas, SkCanvas::SaveFlags flags) { + + static jint save(JNIEnv* env, jobject jcanvas, jint flagsHandle) { + SkCanvas::SaveFlags flags = static_cast<SkCanvas::SaveFlags>(flagsHandle); NPE_CHECK_RETURN_ZERO(env, jcanvas); - return GraphicsJNI::getNativeCanvas(env, jcanvas)->save(flags); + int result = GraphicsJNI::getNativeCanvas(env, jcanvas)->save(flags); + return static_cast<jint>(result); } - - static int saveLayer(JNIEnv* env, jobject, SkCanvas* canvas, jobject bounds, - SkPaint* paint, int flags) { + + static jint saveLayer(JNIEnv* env, jobject, jlong canvasHandle, jobject bounds, + jlong paintHandle, jint flags) { + SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle); + SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); SkRect* bounds_ = NULL; SkRect storage; if (bounds != NULL) { GraphicsJNI::jrectf_to_rect(env, bounds, &storage); bounds_ = &storage; } - return canvas->saveLayer(bounds_, paint, (SkCanvas::SaveFlags)flags); + return canvas->saveLayer(bounds_, paint, static_cast<SkCanvas::SaveFlags>(flags)); } - - static int saveLayer4F(JNIEnv* env, jobject, SkCanvas* canvas, + + static jint saveLayer4F(JNIEnv* env, jobject, jlong canvasHandle, jfloat l, jfloat t, jfloat r, jfloat b, - SkPaint* paint, int flags) { + jlong paintHandle, jint flags) { + SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle); + SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); SkRect bounds; bounds.set(SkFloatToScalar(l), SkFloatToScalar(t), SkFloatToScalar(r), SkFloatToScalar(b)); - return canvas->saveLayer(&bounds, paint, (SkCanvas::SaveFlags)flags); + int result = canvas->saveLayer(&bounds, paint, + static_cast<SkCanvas::SaveFlags>(flags)); + return static_cast<jint>(result); } - - static int saveLayerAlpha(JNIEnv* env, jobject, SkCanvas* canvas, - jobject bounds, int alpha, int flags) { + + static jint saveLayerAlpha(JNIEnv* env, jobject, jlong canvasHandle, + jobject bounds, jint alpha, jint flags) { + SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle); SkRect* bounds_ = NULL; SkRect storage; if (bounds != NULL) { GraphicsJNI::jrectf_to_rect(env, bounds, &storage); bounds_ = &storage; } - return canvas->saveLayerAlpha(bounds_, alpha, - (SkCanvas::SaveFlags)flags); + int result = canvas->saveLayerAlpha(bounds_, alpha, + static_cast<SkCanvas::SaveFlags>(flags)); + return static_cast<jint>(result); } - - static int saveLayerAlpha4F(JNIEnv* env, jobject, SkCanvas* canvas, + + static jint saveLayerAlpha4F(JNIEnv* env, jobject, jlong canvasHandle, jfloat l, jfloat t, jfloat r, jfloat b, - int alpha, int flags) { + jint alpha, jint flags) { + SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle); SkRect bounds; bounds.set(SkFloatToScalar(l), SkFloatToScalar(t), SkFloatToScalar(r), SkFloatToScalar(b)); - return canvas->saveLayerAlpha(&bounds, alpha, - (SkCanvas::SaveFlags)flags); + int result = canvas->saveLayerAlpha(&bounds, alpha, + static_cast<SkCanvas::SaveFlags>(flags)); + return static_cast<jint>(result); } - + static void restore(JNIEnv* env, jobject jcanvas) { NPE_CHECK_RETURN_VOID(env, jcanvas); SkCanvas* canvas = GraphicsJNI::getNativeCanvas(env, jcanvas); @@ -192,13 +212,14 @@ public: } canvas->restore(); } - - static int getSaveCount(JNIEnv* env, jobject jcanvas) { + + static jint getSaveCount(JNIEnv* env, jobject jcanvas) { NPE_CHECK_RETURN_ZERO(env, jcanvas); - return GraphicsJNI::getNativeCanvas(env, jcanvas)->getSaveCount(); + int result = GraphicsJNI::getNativeCanvas(env, jcanvas)->getSaveCount(); + return static_cast<jint>(result); } - - static void restoreToCount(JNIEnv* env, jobject jcanvas, int restoreCount) { + + static void restoreToCount(JNIEnv* env, jobject jcanvas, jint restoreCount) { NPE_CHECK_RETURN_VOID(env, jcanvas); SkCanvas* canvas = GraphicsJNI::getNativeCanvas(env, jcanvas); if (restoreCount < 1) { @@ -207,48 +228,52 @@ public: } canvas->restoreToCount(restoreCount); } - + static void translate(JNIEnv* env, jobject jcanvas, jfloat dx, jfloat dy) { NPE_CHECK_RETURN_VOID(env, jcanvas); SkScalar dx_ = SkFloatToScalar(dx); SkScalar dy_ = SkFloatToScalar(dy); (void)GraphicsJNI::getNativeCanvas(env, jcanvas)->translate(dx_, dy_); } - + static void scale__FF(JNIEnv* env, jobject jcanvas, jfloat sx, jfloat sy) { NPE_CHECK_RETURN_VOID(env, jcanvas); SkScalar sx_ = SkFloatToScalar(sx); SkScalar sy_ = SkFloatToScalar(sy); (void)GraphicsJNI::getNativeCanvas(env, jcanvas)->scale(sx_, sy_); } - + static void rotate__F(JNIEnv* env, jobject jcanvas, jfloat degrees) { NPE_CHECK_RETURN_VOID(env, jcanvas); SkScalar degrees_ = SkFloatToScalar(degrees); (void)GraphicsJNI::getNativeCanvas(env, jcanvas)->rotate(degrees_); } - + static void skew__FF(JNIEnv* env, jobject jcanvas, jfloat sx, jfloat sy) { NPE_CHECK_RETURN_VOID(env, jcanvas); SkScalar sx_ = SkFloatToScalar(sx); SkScalar sy_ = SkFloatToScalar(sy); (void)GraphicsJNI::getNativeCanvas(env, jcanvas)->skew(sx_, sy_); } - - static void concat(JNIEnv* env, jobject, SkCanvas* canvas, - const SkMatrix* matrix) { + + static void concat(JNIEnv* env, jobject, jlong canvasHandle, + jlong matrixHandle) { + SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle); + const SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle); canvas->concat(*matrix); } - - static void setMatrix(JNIEnv* env, jobject, SkCanvas* canvas, - const SkMatrix* matrix) { + + static void setMatrix(JNIEnv* env, jobject, jlong canvasHandle, + jlong matrixHandle) { + SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle); + const SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle); if (NULL == matrix) { canvas->resetMatrix(); } else { canvas->setMatrix(*matrix); } } - + static jboolean clipRect_FFFF(JNIEnv* env, jobject jcanvas, jfloat left, jfloat top, jfloat right, jfloat bottom) { NPE_CHECK_RETURN_ZERO(env, jcanvas); @@ -256,122 +281,149 @@ public: r.set(SkFloatToScalar(left), SkFloatToScalar(top), SkFloatToScalar(right), SkFloatToScalar(bottom)); SkCanvas* c = GraphicsJNI::getNativeCanvas(env, jcanvas); - return c->clipRect(r); + bool result = c->clipRect(r); + return result ? JNI_TRUE : JNI_FALSE; } - + static jboolean clipRect_IIII(JNIEnv* env, jobject jcanvas, jint left, jint top, jint right, jint bottom) { NPE_CHECK_RETURN_ZERO(env, jcanvas); SkRect r; r.set(SkIntToScalar(left), SkIntToScalar(top), SkIntToScalar(right), SkIntToScalar(bottom)); - return GraphicsJNI::getNativeCanvas(env, jcanvas)->clipRect(r); + bool result = GraphicsJNI::getNativeCanvas(env, jcanvas)->clipRect(r); + return result ? JNI_TRUE : JNI_FALSE; } - + static jboolean clipRect_RectF(JNIEnv* env, jobject jcanvas, jobject rectf) { NPE_CHECK_RETURN_ZERO(env, jcanvas); NPE_CHECK_RETURN_ZERO(env, rectf); SkCanvas* c = GraphicsJNI::getNativeCanvas(env, jcanvas); SkRect tmp; - return c->clipRect(*GraphicsJNI::jrectf_to_rect(env, rectf, &tmp)); + bool result = c->clipRect(*GraphicsJNI::jrectf_to_rect(env, rectf, &tmp)); + return result ? JNI_TRUE : JNI_FALSE; } - + static jboolean clipRect_Rect(JNIEnv* env, jobject jcanvas, jobject rect) { NPE_CHECK_RETURN_ZERO(env, jcanvas); NPE_CHECK_RETURN_ZERO(env, rect); SkCanvas* c = GraphicsJNI::getNativeCanvas(env, jcanvas); SkRect tmp; - return c->clipRect(*GraphicsJNI::jrect_to_rect(env, rect, &tmp)); + bool result = c->clipRect(*GraphicsJNI::jrect_to_rect(env, rect, &tmp)); + return result ? JNI_TRUE : JNI_FALSE; + } - - static jboolean clipRect(JNIEnv* env, jobject, SkCanvas* canvas, - float left, float top, float right, float bottom, - int op) { + + static jboolean clipRect(JNIEnv* env, jobject, jlong canvasHandle, + jfloat left, jfloat top, jfloat right, jfloat bottom, + jint op) { SkRect rect; + SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle); rect.set(SkFloatToScalar(left), SkFloatToScalar(top), SkFloatToScalar(right), SkFloatToScalar(bottom)); - return canvas->clipRect(rect, (SkRegion::Op)op); + bool result = canvas->clipRect(rect, static_cast<SkRegion::Op>(op)); + return result ? JNI_TRUE : JNI_FALSE; + } - - static jboolean clipPath(JNIEnv* env, jobject, SkCanvas* canvas, - SkPath* path, int op) { - return canvas->clipPath(*path, (SkRegion::Op)op); + + static jboolean clipPath(JNIEnv* env, jobject, jlong canvasHandle, + SkPath* path, jint op) { + SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle); + bool result = canvas->clipPath(*path, static_cast<SkRegion::Op>(op)); + return result ? JNI_TRUE : JNI_FALSE; } - - static jboolean clipRegion(JNIEnv* env, jobject, SkCanvas* canvas, - SkRegion* deviceRgn, int op) { - return canvas->clipRegion(*deviceRgn, (SkRegion::Op)op); + + static jboolean clipRegion(JNIEnv* env, jobject, jlong canvasHandle, + jlong deviceRgnHandle, jint op) { + SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle); + SkRegion* deviceRgn = reinterpret_cast<SkRegion*>(deviceRgnHandle); + bool result = canvas->clipRegion(*deviceRgn, static_cast<SkRegion::Op>(op)); + return result ? JNI_TRUE : JNI_FALSE; } - - static void setDrawFilter(JNIEnv* env, jobject, SkCanvas* canvas, + + static void setDrawFilter(JNIEnv* env, jobject, jlong canvasHandle, SkDrawFilter* filter) { + SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle); canvas->setDrawFilter(filter); } - - static jboolean quickReject__RectF(JNIEnv* env, jobject, SkCanvas* canvas, + + static jboolean quickReject__RectF(JNIEnv* env, jobject, jlong canvasHandle, jobject rect) { + SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle); SkRect rect_; GraphicsJNI::jrectf_to_rect(env, rect, &rect_); return canvas->quickReject(rect_); } - static jboolean quickReject__Path(JNIEnv* env, jobject, SkCanvas* canvas, + static jboolean quickReject__Path(JNIEnv* env, jobject, jlong canvasHandle, SkPath* path) { - return canvas->quickReject(*path); + SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle); + bool result = canvas->quickReject(*path); + return result ? JNI_TRUE : JNI_FALSE; } - static jboolean quickReject__FFFF(JNIEnv* env, jobject, SkCanvas* canvas, + static jboolean quickReject__FFFF(JNIEnv* env, jobject, jlong canvasHandle, jfloat left, jfloat top, jfloat right, jfloat bottom) { + SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle); SkRect r; r.set(SkFloatToScalar(left), SkFloatToScalar(top), SkFloatToScalar(right), SkFloatToScalar(bottom)); - return canvas->quickReject(r); + bool result = canvas->quickReject(r); + return result ? JNI_TRUE : JNI_FALSE; } - - static void drawRGB(JNIEnv* env, jobject, SkCanvas* canvas, + + static void drawRGB(JNIEnv* env, jobject, jlong canvasHandle, jint r, jint g, jint b) { + SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle); canvas->drawARGB(0xFF, r, g, b); } - - static void drawARGB(JNIEnv* env, jobject, SkCanvas* canvas, + + static void drawARGB(JNIEnv* env, jobject, jlong canvasHandle, jint a, jint r, jint g, jint b) { + SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle); canvas->drawARGB(a, r, g, b); } - - static void drawColor__I(JNIEnv* env, jobject, SkCanvas* canvas, + + static void drawColor__I(JNIEnv* env, jobject, jlong canvasHandle, jint color) { + SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle); canvas->drawColor(color); } - - static void drawColor__II(JNIEnv* env, jobject, SkCanvas* canvas, - jint color, SkPorterDuff::Mode mode) { + + static void drawColor__II(JNIEnv* env, jobject, jlong canvasHandle, + jint color, jint modeHandle) { + SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle); + SkPorterDuff::Mode mode = static_cast<SkPorterDuff::Mode>(modeHandle); canvas->drawColor(color, SkPorterDuff::ToXfermodeMode(mode)); } - - static void drawPaint(JNIEnv* env, jobject, SkCanvas* canvas, - SkPaint* paint) { + + static void drawPaint(JNIEnv* env, jobject, jlong canvasHandle, + jlong paintHandle) { + SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle); + SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); canvas->drawPaint(*paint); } - + static void doPoints(JNIEnv* env, jobject jcanvas, jfloatArray jptsArray, jint offset, jint count, jobject jpaint, - SkCanvas::PointMode mode) { + jint modeHandle) { NPE_CHECK_RETURN_VOID(env, jcanvas); NPE_CHECK_RETURN_VOID(env, jptsArray); NPE_CHECK_RETURN_VOID(env, jpaint); + SkCanvas::PointMode mode = static_cast<SkCanvas::PointMode>(modeHandle); SkCanvas* canvas = GraphicsJNI::getNativeCanvas(env, jcanvas); const SkPaint& paint = *GraphicsJNI::getNativePaint(env, jpaint); - + AutoJavaFloatArray autoPts(env, jptsArray); float* floats = autoPts.ptr(); const int length = autoPts.length(); - + if ((offset | count) < 0 || offset + count > length) { doThrowAIOOBE(env); return; } - + // now convert the floats into SkPoints count >>= 1; // now it is the number of points SkAutoSTMalloc<32, SkPoint> storage(count); @@ -380,98 +432,118 @@ public: for (int i = 0; i < count; i++) { pts[i].set(SkFloatToScalar(src[0]), SkFloatToScalar(src[1])); src += 2; - } + } canvas->drawPoints(mode, count, pts, paint); } - + static void drawPoints(JNIEnv* env, jobject jcanvas, jfloatArray jptsArray, jint offset, jint count, jobject jpaint) { doPoints(env, jcanvas, jptsArray, offset, count, jpaint, SkCanvas::kPoints_PointMode); } - + static void drawLines(JNIEnv* env, jobject jcanvas, jfloatArray jptsArray, jint offset, jint count, jobject jpaint) { doPoints(env, jcanvas, jptsArray, offset, count, jpaint, SkCanvas::kLines_PointMode); } - - static void drawPoint(JNIEnv* env, jobject jcanvas, float x, float y, + + static void drawPoint(JNIEnv* env, jobject jcanvas, jfloat x, jfloat y, jobject jpaint) { NPE_CHECK_RETURN_VOID(env, jcanvas); NPE_CHECK_RETURN_VOID(env, jpaint); SkCanvas* canvas = GraphicsJNI::getNativeCanvas(env, jcanvas); const SkPaint& paint = *GraphicsJNI::getNativePaint(env, jpaint); - + canvas->drawPoint(SkFloatToScalar(x), SkFloatToScalar(y), paint); } - - static void drawLine__FFFFPaint(JNIEnv* env, jobject, SkCanvas* canvas, + + static void drawLine__FFFFPaint(JNIEnv* env, jobject, jlong canvasHandle, jfloat startX, jfloat startY, jfloat stopX, - jfloat stopY, SkPaint* paint) { + jfloat stopY, jlong paintHandle) { + SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle); + SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); canvas->drawLine(SkFloatToScalar(startX), SkFloatToScalar(startY), SkFloatToScalar(stopX), SkFloatToScalar(stopY), *paint); } - - static void drawRect__RectFPaint(JNIEnv* env, jobject, SkCanvas* canvas, - jobject rect, SkPaint* paint) { + + static void drawRect__RectFPaint(JNIEnv* env, jobject, jlong canvasHandle, + jobject rect, jlong paintHandle) { + SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle); + SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); SkRect rect_; GraphicsJNI::jrectf_to_rect(env, rect, &rect_); canvas->drawRect(rect_, *paint); } - - static void drawRect__FFFFPaint(JNIEnv* env, jobject, SkCanvas* canvas, + + static void drawRect__FFFFPaint(JNIEnv* env, jobject, jlong canvasHandle, jfloat left, jfloat top, jfloat right, - jfloat bottom, SkPaint* paint) { + jfloat bottom, jlong paintHandle) { + SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle); + SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); SkScalar left_ = SkFloatToScalar(left); SkScalar top_ = SkFloatToScalar(top); SkScalar right_ = SkFloatToScalar(right); SkScalar bottom_ = SkFloatToScalar(bottom); canvas->drawRectCoords(left_, top_, right_, bottom_, *paint); } - - static void drawOval(JNIEnv* env, jobject, SkCanvas* canvas, jobject joval, - SkPaint* paint) { + + static void drawOval(JNIEnv* env, jobject, jlong canvasHandle, jobject joval, + jlong paintHandle) { + SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle); + SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); SkRect oval; GraphicsJNI::jrectf_to_rect(env, joval, &oval); canvas->drawOval(oval, *paint); } - - static void drawCircle(JNIEnv* env, jobject, SkCanvas* canvas, jfloat cx, - jfloat cy, jfloat radius, SkPaint* paint) { + + static void drawCircle(JNIEnv* env, jobject, jlong canvasHandle, jfloat cx, + jfloat cy, jfloat radius, jlong paintHandle) { + SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle); + SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); canvas->drawCircle(SkFloatToScalar(cx), SkFloatToScalar(cy), SkFloatToScalar(radius), *paint); } - - static void drawArc(JNIEnv* env, jobject, SkCanvas* canvas, jobject joval, + + static void drawArc(JNIEnv* env, jobject, jlong canvasHandle, jobject joval, jfloat startAngle, jfloat sweepAngle, - jboolean useCenter, SkPaint* paint) { + jboolean useCenter, jlong paintHandle) { + SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle); + SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); SkRect oval; GraphicsJNI::jrectf_to_rect(env, joval, &oval); canvas->drawArc(oval, SkFloatToScalar(startAngle), SkFloatToScalar(sweepAngle), useCenter, *paint); } - - static void drawRoundRect(JNIEnv* env, jobject, SkCanvas* canvas, + + static void drawRoundRect(JNIEnv* env, jobject, jlong canvasHandle, jobject jrect, jfloat rx, jfloat ry, - SkPaint* paint) { + jlong paintHandle) { + SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle); + SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); SkRect rect; GraphicsJNI::jrectf_to_rect(env, jrect, &rect); canvas->drawRoundRect(rect, SkFloatToScalar(rx), SkFloatToScalar(ry), *paint); } - - static void drawPath(JNIEnv* env, jobject, SkCanvas* canvas, SkPath* path, - SkPaint* paint) { + + static void drawPath(JNIEnv* env, jobject, jlong canvasHandle, jlong pathHandle, + jlong paintHandle) { + SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle); + SkPath* path = reinterpret_cast<SkPath*>(pathHandle); + SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); canvas->drawPath(*path, *paint); } - + static void drawBitmap__BitmapFFPaint(JNIEnv* env, jobject jcanvas, - SkCanvas* canvas, SkBitmap* bitmap, + jlong canvasHandle, jlong bitmapHandle, jfloat left, jfloat top, - SkPaint* paint, jint canvasDensity, + jlong paintHandle, jint canvasDensity, jint screenDensity, jint bitmapDensity) { + SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle); + SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle); + SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); SkScalar left_ = SkFloatToScalar(left); SkScalar top_ = SkFloatToScalar(top); @@ -514,7 +586,7 @@ public: GraphicsJNI::jrect_to_irect(env, srcIRect, &src); srcPtr = &src; } - + if (screenDensity != 0 && screenDensity != bitmapDensity) { SkPaint filteredPaint; if (paint) { @@ -527,31 +599,39 @@ public: } } - static void drawBitmapRF(JNIEnv* env, jobject, SkCanvas* canvas, - SkBitmap* bitmap, jobject srcIRect, - jobject dstRectF, SkPaint* paint, + static void drawBitmapRF(JNIEnv* env, jobject, jlong canvasHandle, + jlong bitmapHandle, jobject srcIRect, + jobject dstRectF, jlong paintHandle, jint screenDensity, jint bitmapDensity) { + SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle); + SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle); + SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); SkRect dst; GraphicsJNI::jrectf_to_rect(env, dstRectF, &dst); doDrawBitmap(env, canvas, bitmap, srcIRect, dst, paint, screenDensity, bitmapDensity); } - - static void drawBitmapRR(JNIEnv* env, jobject, SkCanvas* canvas, - SkBitmap* bitmap, jobject srcIRect, - jobject dstRect, SkPaint* paint, + + static void drawBitmapRR(JNIEnv* env, jobject, jlong canvasHandle, + jlong bitmapHandle, jobject srcIRect, + jobject dstRect, jlong paintHandle, jint screenDensity, jint bitmapDensity) { + SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle); + SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle); + SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); SkRect dst; GraphicsJNI::jrect_to_rect(env, dstRect, &dst); doDrawBitmap(env, canvas, bitmap, srcIRect, dst, paint, screenDensity, bitmapDensity); } - - static void drawBitmapArray(JNIEnv* env, jobject, SkCanvas* canvas, - jintArray jcolors, int offset, int stride, - jfloat x, jfloat y, int width, int height, - jboolean hasAlpha, SkPaint* paint) + + static void drawBitmapArray(JNIEnv* env, jobject, jlong canvasHandle, + jintArray jcolors, jint offset, jint stride, + jfloat x, jfloat y, jint width, jint height, + jboolean hasAlpha, jlong paintHandle) { + SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle); + SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); SkBitmap bitmap; bitmap.setConfig(hasAlpha ? SkBitmap::kARGB_8888_Config : SkBitmap::kRGB_565_Config, width, height); @@ -567,24 +647,31 @@ public: canvas->drawBitmap(bitmap, SkFloatToScalar(x), SkFloatToScalar(y), paint); } - - static void drawBitmapMatrix(JNIEnv* env, jobject, SkCanvas* canvas, - const SkBitmap* bitmap, const SkMatrix* matrix, - const SkPaint* paint) { + + static void drawBitmapMatrix(JNIEnv* env, jobject, jlong canvasHandle, + jlong bitmapHandle, jlong matrixHandle, + jlong paintHandle) { + SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle); + const SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle); + const SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle); + const SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); canvas->drawBitmapMatrix(*bitmap, *matrix, paint); } - - static void drawBitmapMesh(JNIEnv* env, jobject, SkCanvas* canvas, - const SkBitmap* bitmap, int meshWidth, int meshHeight, - jfloatArray jverts, int vertIndex, jintArray jcolors, - int colorIndex, const SkPaint* paint) { + + static void drawBitmapMesh(JNIEnv* env, jobject, jlong canvasHandle, + jlong bitmapHandle, jint meshWidth, jint meshHeight, + jfloatArray jverts, jint vertIndex, jintArray jcolors, + jint colorIndex, jlong paintHandle) { + SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle); + const SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle); + const SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); const int ptCount = (meshWidth + 1) * (meshHeight + 1); const int indexCount = meshWidth * meshHeight * 6; AutoJavaFloatArray vertA(env, jverts, vertIndex + (ptCount << 1)); AutoJavaIntArray colorA(env, jcolors, colorIndex + ptCount); - + /* Our temp storage holds 2 or 3 arrays. texture points [ptCount * sizeof(SkPoint)] optionally vertex points [ptCount * sizeof(SkPoint)] if we need a @@ -623,7 +710,7 @@ public: const SkScalar h = SkIntToScalar(bitmap->height()); const SkScalar dx = w / meshWidth; const SkScalar dy = h / meshHeight; - + SkPoint* texsPtr = texs; SkScalar y = 0; for (int i = 0; i <= meshHeight; i++) { @@ -642,7 +729,7 @@ public: } SkASSERT(texsPtr - texs == ptCount); } - + // cons up indices { uint16_t* indexPtr = indices; @@ -690,13 +777,16 @@ public: indexCount, tmpPaint); } - static void drawVertices(JNIEnv* env, jobject, SkCanvas* canvas, - SkCanvas::VertexMode mode, int vertexCount, - jfloatArray jverts, int vertIndex, - jfloatArray jtexs, int texIndex, - jintArray jcolors, int colorIndex, - jshortArray jindices, int indexIndex, - int indexCount, const SkPaint* paint) { + static void drawVertices(JNIEnv* env, jobject, jlong canvasHandle, + jint modeHandle, jint vertexCount, + jfloatArray jverts, jint vertIndex, + jfloatArray jtexs, jint texIndex, + jintArray jcolors, jint colorIndex, + jshortArray jindices, jint indexIndex, + jint indexCount, jlong paintHandle) { + SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle); + SkCanvas::VertexMode mode = static_cast<SkCanvas::VertexMode>(modeHandle); + const SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); AutoJavaFloatArray vertA(env, jverts, vertIndex + vertexCount); AutoJavaFloatArray texA(env, jtexs, texIndex + vertexCount); @@ -718,7 +808,7 @@ public: count += ptCount; // += for texs } SkAutoMalloc storage(count * sizeof(SkPoint)); - verts = (SkPoint*)storage.get(); + verts = (SkPoint*)storage.get(); const float* src = vertA.ptr() + vertIndex; for (int i = 0; i < ptCount; i++) { verts[i].set(SkFloatToFixed(src[0]), SkFloatToFixed(src[1])); @@ -748,20 +838,26 @@ public: } - static void drawText___CIIFFIPaintTypeface(JNIEnv* env, jobject, SkCanvas* canvas, - jcharArray text, int index, int count, - jfloat x, jfloat y, int flags, SkPaint* paint, - TypefaceImpl *typeface) { + static void drawText___CIIFFIPaintTypeface(JNIEnv* env, jobject, jlong canvasHandle, + jcharArray text, jint index, jint count, + jfloat x, jfloat y, jint flags, + jlong paintHandle, jlong typefaceHandle) { + SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle); + SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); + TypefaceImpl* typeface = reinterpret_cast<TypefaceImpl*>(typefaceHandle); jchar* textArray = env->GetCharArrayElements(text, NULL); drawTextWithGlyphs(canvas, textArray + index, 0, count, x, y, flags, paint, typeface); env->ReleaseCharArrayElements(text, textArray, JNI_ABORT); } static void drawText__StringIIFFIPaintTypeface(JNIEnv* env, jobject, - SkCanvas* canvas, jstring text, - int start, int end, - jfloat x, jfloat y, int flags, SkPaint* paint, - TypefaceImpl *typeface) { + jlong canvasHandle, jstring text, + jint start, jint end, + jfloat x, jfloat y, jint flags, + jlong paintHandle, jlong typefaceHandle) { + SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle); + SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); + TypefaceImpl* typeface = reinterpret_cast<TypefaceImpl*>(typefaceHandle); const jchar* textArray = env->GetStringChars(text, NULL); drawTextWithGlyphs(canvas, textArray, start, end, x, y, flags, paint, typeface); env->ReleaseStringChars(text, textArray); @@ -898,10 +994,12 @@ static void doDrawTextDecorations(SkCanvas* canvas, jfloat x, jfloat y, jfloat l } static void drawTextRun___CIIIIFFIPaintTypeface( - JNIEnv* env, jobject, SkCanvas* canvas, jcharArray text, int index, - int count, int contextIndex, int contextCount, - jfloat x, jfloat y, int dirFlags, SkPaint* paint, - TypefaceImpl* typeface) { + JNIEnv* env, jobject, jlong canvasHandle, jcharArray text, jint index, + jint count, jint contextIndex, jint contextCount, + jfloat x, jfloat y, jint dirFlags, jlong paintHandle, jlong typefaceHandle) { + SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle); + SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); + TypefaceImpl* typeface = reinterpret_cast<TypefaceImpl*>(typefaceHandle); jchar* chars = env->GetCharArrayElements(text, NULL); drawTextWithGlyphs(canvas, chars + contextIndex, index - contextIndex, @@ -910,10 +1008,12 @@ static void doDrawTextDecorations(SkCanvas* canvas, jfloat x, jfloat y, jfloat l } static void drawTextRun__StringIIIIFFIPaintTypeface( - JNIEnv* env, jobject obj, SkCanvas* canvas, jstring text, jint start, + JNIEnv* env, jobject obj, jlong canvasHandle, jstring text, jint start, jint end, jint contextStart, jint contextEnd, - jfloat x, jfloat y, jint dirFlags, SkPaint* paint, - TypefaceImpl* typeface) { + jfloat x, jfloat y, jint dirFlags, jlong paintHandle, jlong typefaceHandle) { + SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle); + SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); + TypefaceImpl* typeface = reinterpret_cast<TypefaceImpl*>(typefaceHandle); jint count = end - start; jint contextCount = contextEnd - contextStart; @@ -923,9 +1023,11 @@ static void doDrawTextDecorations(SkCanvas* canvas, jfloat x, jfloat y, jfloat l env->ReleaseStringChars(text, chars); } - static void drawPosText___CII_FPaint(JNIEnv* env, jobject, SkCanvas* canvas, - jcharArray text, int index, int count, - jfloatArray pos, SkPaint* paint) { + static void drawPosText___CII_FPaint(JNIEnv* env, jobject, jlong canvasHandle, + jcharArray text, jint index, jint count, + jfloatArray pos, jlong paintHandle) { + SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle); + SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); jchar* textArray = text ? env->GetCharArrayElements(text, NULL) : NULL; jsize textCount = text ? env->GetArrayLength(text) : NULL; float* posArray = pos ? env->GetFloatArrayElements(pos, NULL) : NULL; @@ -936,12 +1038,12 @@ static void doDrawTextDecorations(SkCanvas* canvas, jfloat x, jfloat y, jfloat l posPtr[indx].fX = SkFloatToScalar(posArray[indx << 1]); posPtr[indx].fY = SkFloatToScalar(posArray[(indx << 1) + 1]); } - + SkPaint::TextEncoding encoding = paint->getTextEncoding(); paint->setTextEncoding(SkPaint::kUTF16_TextEncoding); canvas->drawPosText(textArray + index, count << 1, posPtr, *paint); paint->setTextEncoding(encoding); - + if (text) { env->ReleaseCharArrayElements(text, textArray, 0); } @@ -952,9 +1054,11 @@ static void doDrawTextDecorations(SkCanvas* canvas, jfloat x, jfloat y, jfloat l } static void drawPosText__String_FPaint(JNIEnv* env, jobject, - SkCanvas* canvas, jstring text, + jlong canvasHandle, jstring text, jfloatArray pos, - SkPaint* paint) { + jlong paintHandle) { + SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle); + SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); const void* text_ = text ? env->GetStringChars(text, NULL) : NULL; int byteLength = text ? env->GetStringLength(text) : 0; float* posArray = pos ? env->GetFloatArrayElements(pos, NULL) : NULL; @@ -981,8 +1085,11 @@ static void doDrawTextDecorations(SkCanvas* canvas, jfloat x, jfloat y, jfloat l } static void drawTextOnPath___CIIPathFFPaint(JNIEnv* env, jobject, - SkCanvas* canvas, jcharArray text, int index, int count, - SkPath* path, jfloat hOffset, jfloat vOffset, jint bidiFlags, SkPaint* paint) { + jlong canvasHandle, jcharArray text, jint index, jint count, + jlong pathHandle, jfloat hOffset, jfloat vOffset, jint bidiFlags, jlong paintHandle) { + SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle); + SkPath* path = reinterpret_cast<SkPath*>(pathHandle); + SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); jchar* textArray = env->GetCharArrayElements(text, NULL); TextLayout::drawTextOnPath(paint, textArray + index, count, bidiFlags, hOffset, vOffset, @@ -991,8 +1098,11 @@ static void doDrawTextDecorations(SkCanvas* canvas, jfloat x, jfloat y, jfloat l } static void drawTextOnPath__StringPathFFPaint(JNIEnv* env, jobject, - SkCanvas* canvas, jstring text, SkPath* path, - jfloat hOffset, jfloat vOffset, jint bidiFlags, SkPaint* paint) { + jlong canvasHandle, jstring text, jlong pathHandle, + jfloat hOffset, jfloat vOffset, jint bidiFlags, jlong paintHandle) { + SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle); + SkPath* path = reinterpret_cast<SkPath*>(pathHandle); + SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); const jchar* text_ = env->GetStringChars(text, NULL); int count = env->GetStringLength(text); TextLayout::drawTextOnPath(paint, text_, count, bidiFlags, hOffset, vOffset, @@ -1027,8 +1137,9 @@ static void doDrawTextDecorations(SkCanvas* canvas, jfloat x, jfloat y, jfloat l return true; } - static bool getClipBounds(JNIEnv* env, jobject, SkCanvas* canvas, - jobject bounds) { + static jboolean getClipBounds(JNIEnv* env, jobject, jlong canvasHandle, + jobject bounds) { + SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle); SkRect r; SkIRect ir; bool result = getHardClipBounds(canvas, &r); @@ -1039,30 +1150,32 @@ static void doDrawTextDecorations(SkCanvas* canvas, jfloat x, jfloat y, jfloat l r.round(&ir); (void)GraphicsJNI::irect_to_jrect(ir, env, bounds); - return result; + return result ? JNI_TRUE : JNI_FALSE; } - static void getCTM(JNIEnv* env, jobject, SkCanvas* canvas, - SkMatrix* matrix) { + static void getCTM(JNIEnv* env, jobject, jlong canvasHandle, + jlong matrixHandle) { + SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle); + SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle); *matrix = canvas->getTotalMatrix(); } }; static JNINativeMethod gCanvasMethods[] = { - {"finalizer", "(I)V", (void*) SkCanvasGlue::finalizer}, - {"initRaster","(I)I", (void*) SkCanvasGlue::initRaster}, - {"copyNativeCanvasState","(II)V", (void*) SkCanvasGlue::copyCanvasState}, + {"finalizer", "(J)V", (void*) SkCanvasGlue::finalizer}, + {"initRaster","(J)J", (void*) SkCanvasGlue::initRaster}, + {"copyNativeCanvasState","(JJ)V", (void*) SkCanvasGlue::copyCanvasState}, {"isOpaque","()Z", (void*) SkCanvasGlue::isOpaque}, {"getWidth","()I", (void*) SkCanvasGlue::getWidth}, {"getHeight","()I", (void*) SkCanvasGlue::getHeight}, {"save","()I", (void*) SkCanvasGlue::saveAll}, {"save","(I)I", (void*) SkCanvasGlue::save}, - {"native_saveLayer","(ILandroid/graphics/RectF;II)I", + {"native_saveLayer","(JLandroid/graphics/RectF;JI)I", (void*) SkCanvasGlue::saveLayer}, - {"native_saveLayer","(IFFFFII)I", (void*) SkCanvasGlue::saveLayer4F}, - {"native_saveLayerAlpha","(ILandroid/graphics/RectF;II)I", + {"native_saveLayer","(JFFFFJI)I", (void*) SkCanvasGlue::saveLayer4F}, + {"native_saveLayerAlpha","(JLandroid/graphics/RectF;II)I", (void*) SkCanvasGlue::saveLayerAlpha}, - {"native_saveLayerAlpha","(IFFFFII)I", + {"native_saveLayerAlpha","(JFFFFII)I", (void*) SkCanvasGlue::saveLayerAlpha4F}, {"restore","()V", (void*) SkCanvasGlue::restore}, {"getSaveCount","()I", (void*) SkCanvasGlue::getSaveCount}, @@ -1071,77 +1184,77 @@ static JNINativeMethod gCanvasMethods[] = { {"scale","(FF)V", (void*) SkCanvasGlue::scale__FF}, {"rotate","(F)V", (void*) SkCanvasGlue::rotate__F}, {"skew","(FF)V", (void*) SkCanvasGlue::skew__FF}, - {"native_concat","(II)V", (void*) SkCanvasGlue::concat}, - {"native_setMatrix","(II)V", (void*) SkCanvasGlue::setMatrix}, + {"native_concat","(JJ)V", (void*) SkCanvasGlue::concat}, + {"native_setMatrix","(JJ)V", (void*) SkCanvasGlue::setMatrix}, {"clipRect","(FFFF)Z", (void*) SkCanvasGlue::clipRect_FFFF}, {"clipRect","(IIII)Z", (void*) SkCanvasGlue::clipRect_IIII}, {"clipRect","(Landroid/graphics/RectF;)Z", (void*) SkCanvasGlue::clipRect_RectF}, {"clipRect","(Landroid/graphics/Rect;)Z", (void*) SkCanvasGlue::clipRect_Rect}, - {"native_clipRect","(IFFFFI)Z", (void*) SkCanvasGlue::clipRect}, - {"native_clipPath","(III)Z", (void*) SkCanvasGlue::clipPath}, - {"native_clipRegion","(III)Z", (void*) SkCanvasGlue::clipRegion}, - {"nativeSetDrawFilter", "(II)V", (void*) SkCanvasGlue::setDrawFilter}, - {"native_getClipBounds","(ILandroid/graphics/Rect;)Z", + {"native_clipRect","(JFFFFI)Z", (void*) SkCanvasGlue::clipRect}, + {"native_clipPath","(JJI)Z", (void*) SkCanvasGlue::clipPath}, + {"native_clipRegion","(JJI)Z", (void*) SkCanvasGlue::clipRegion}, + {"nativeSetDrawFilter", "(JJ)V", (void*) SkCanvasGlue::setDrawFilter}, + {"native_getClipBounds","(JLandroid/graphics/Rect;)Z", (void*) SkCanvasGlue::getClipBounds}, - {"native_getCTM", "(II)V", (void*)SkCanvasGlue::getCTM}, - {"native_quickReject","(ILandroid/graphics/RectF;)Z", + {"native_getCTM", "(JJ)V", (void*)SkCanvasGlue::getCTM}, + {"native_quickReject","(JLandroid/graphics/RectF;)Z", (void*) SkCanvasGlue::quickReject__RectF}, - {"native_quickReject","(II)Z", (void*) SkCanvasGlue::quickReject__Path}, - {"native_quickReject","(IFFFF)Z", (void*)SkCanvasGlue::quickReject__FFFF}, - {"native_drawRGB","(IIII)V", (void*) SkCanvasGlue::drawRGB}, - {"native_drawARGB","(IIIII)V", (void*) SkCanvasGlue::drawARGB}, - {"native_drawColor","(II)V", (void*) SkCanvasGlue::drawColor__I}, - {"native_drawColor","(III)V", (void*) SkCanvasGlue::drawColor__II}, - {"native_drawPaint","(II)V", (void*) SkCanvasGlue::drawPaint}, + {"native_quickReject","(JJ)Z", (void*) SkCanvasGlue::quickReject__Path}, + {"native_quickReject","(JFFFF)Z", (void*)SkCanvasGlue::quickReject__FFFF}, + {"native_drawRGB","(JIII)V", (void*) SkCanvasGlue::drawRGB}, + {"native_drawARGB","(JIIII)V", (void*) SkCanvasGlue::drawARGB}, + {"native_drawColor","(JI)V", (void*) SkCanvasGlue::drawColor__I}, + {"native_drawColor","(JII)V", (void*) SkCanvasGlue::drawColor__II}, + {"native_drawPaint","(JJ)V", (void*) SkCanvasGlue::drawPaint}, {"drawPoint", "(FFLandroid/graphics/Paint;)V", (void*) SkCanvasGlue::drawPoint}, {"drawPoints", "([FIILandroid/graphics/Paint;)V", (void*) SkCanvasGlue::drawPoints}, {"drawLines", "([FIILandroid/graphics/Paint;)V", (void*) SkCanvasGlue::drawLines}, - {"native_drawLine","(IFFFFI)V", (void*) SkCanvasGlue::drawLine__FFFFPaint}, - {"native_drawRect","(ILandroid/graphics/RectF;I)V", + {"native_drawLine","(JFFFFJ)V", (void*) SkCanvasGlue::drawLine__FFFFPaint}, + {"native_drawRect","(JLandroid/graphics/RectF;J)V", (void*) SkCanvasGlue::drawRect__RectFPaint}, - {"native_drawRect","(IFFFFI)V", (void*) SkCanvasGlue::drawRect__FFFFPaint}, - {"native_drawOval","(ILandroid/graphics/RectF;I)V", + {"native_drawRect","(JFFFFJ)V", (void*) SkCanvasGlue::drawRect__FFFFPaint}, + {"native_drawOval","(JLandroid/graphics/RectF;J)V", (void*) SkCanvasGlue::drawOval}, - {"native_drawCircle","(IFFFI)V", (void*) SkCanvasGlue::drawCircle}, - {"native_drawArc","(ILandroid/graphics/RectF;FFZI)V", + {"native_drawCircle","(JFFFJ)V", (void*) SkCanvasGlue::drawCircle}, + {"native_drawArc","(JLandroid/graphics/RectF;FFZJ)V", (void*) SkCanvasGlue::drawArc}, - {"native_drawRoundRect","(ILandroid/graphics/RectF;FFI)V", + {"native_drawRoundRect","(JLandroid/graphics/RectF;FFJ)V", (void*) SkCanvasGlue::drawRoundRect}, - {"native_drawPath","(III)V", (void*) SkCanvasGlue::drawPath}, - {"native_drawBitmap","(IIFFIIII)V", + {"native_drawPath","(JJJ)V", (void*) SkCanvasGlue::drawPath}, + {"native_drawBitmap","(JJFFJIII)V", (void*) SkCanvasGlue::drawBitmap__BitmapFFPaint}, - {"native_drawBitmap","(IILandroid/graphics/Rect;Landroid/graphics/RectF;III)V", + {"native_drawBitmap","(JJLandroid/graphics/Rect;Landroid/graphics/RectF;JII)V", (void*) SkCanvasGlue::drawBitmapRF}, - {"native_drawBitmap","(IILandroid/graphics/Rect;Landroid/graphics/Rect;III)V", + {"native_drawBitmap","(JJLandroid/graphics/Rect;Landroid/graphics/Rect;JII)V", (void*) SkCanvasGlue::drawBitmapRR}, - {"native_drawBitmap", "(I[IIIFFIIZI)V", + {"native_drawBitmap", "(J[IIIFFIIZJ)V", (void*)SkCanvasGlue::drawBitmapArray}, - {"nativeDrawBitmapMatrix", "(IIII)V", + {"nativeDrawBitmapMatrix", "(JJJJ)V", (void*)SkCanvasGlue::drawBitmapMatrix}, - {"nativeDrawBitmapMesh", "(IIII[FI[III)V", + {"nativeDrawBitmapMesh", "(JJII[FI[IIJ)V", (void*)SkCanvasGlue::drawBitmapMesh}, - {"nativeDrawVertices", "(III[FI[FI[II[SIII)V", + {"nativeDrawVertices", "(JII[FI[FI[II[SIIJ)V", (void*)SkCanvasGlue::drawVertices}, - {"native_drawText","(I[CIIFFIII)V", + {"native_drawText","(J[CIIFFIJJ)V", (void*) SkCanvasGlue::drawText___CIIFFIPaintTypeface}, - {"native_drawText","(ILjava/lang/String;IIFFIII)V", + {"native_drawText","(JLjava/lang/String;IIFFIJJ)V", (void*) SkCanvasGlue::drawText__StringIIFFIPaintTypeface}, - {"native_drawTextRun","(I[CIIIIFFIII)V", + {"native_drawTextRun","(J[CIIIIFFIJJ)V", (void*) SkCanvasGlue::drawTextRun___CIIIIFFIPaintTypeface}, - {"native_drawTextRun","(ILjava/lang/String;IIIIFFIII)V", + {"native_drawTextRun","(JLjava/lang/String;IIIIFFIJJ)V", (void*) SkCanvasGlue::drawTextRun__StringIIIIFFIPaintTypeface}, - {"native_drawPosText","(I[CII[FI)V", + {"native_drawPosText","(J[CII[FJ)V", (void*) SkCanvasGlue::drawPosText___CII_FPaint}, - {"native_drawPosText","(ILjava/lang/String;[FI)V", + {"native_drawPosText","(JLjava/lang/String;[FJ)V", (void*) SkCanvasGlue::drawPosText__String_FPaint}, - {"native_drawTextOnPath","(I[CIIIFFII)V", + {"native_drawTextOnPath","(J[CIIJFFIJ)V", (void*) SkCanvasGlue::drawTextOnPath___CIIPathFFPaint}, - {"native_drawTextOnPath","(ILjava/lang/String;IFFII)V", + {"native_drawTextOnPath","(JLjava/lang/String;JFFIJ)V", (void*) SkCanvasGlue::drawTextOnPath__StringPathFFPaint}, {"freeCaches", "()V", (void*) SkCanvasGlue::freeCaches}, @@ -1162,7 +1275,7 @@ int register_android_graphics_Canvas(JNIEnv* env) { int result; REG(env, "android/graphics/Canvas", gCanvasMethods); - + return result; } diff --git a/core/jni/android/graphics/ColorFilter.cpp b/core/jni/android/graphics/ColorFilter.cpp index 26169e7..da40acf 100644 --- a/core/jni/android/graphics/ColorFilter.cpp +++ b/core/jni/android/graphics/ColorFilter.cpp @@ -32,7 +32,9 @@ using namespace uirenderer; class SkColorFilterGlue { public: - static void finalizer(JNIEnv* env, jobject clazz, SkColorFilter* obj, SkiaColorFilter* f) { + static void finalizer(JNIEnv* env, jobject clazz, jlong objHandle, jlong fHandle) { + SkColorFilter* obj = reinterpret_cast<SkColorFilter *>(objHandle); + SkiaColorFilter* f = reinterpret_cast<SkiaColorFilter *>(fHandle); if (obj) SkSafeUnref(obj); // f == NULL when not !USE_OPENGL_RENDERER, so no need to delete outside the ifdef #ifdef USE_OPENGL_RENDERER @@ -44,26 +46,30 @@ public: #endif } - static SkiaColorFilter* glCreatePorterDuffFilter(JNIEnv* env, jobject, SkColorFilter *skFilter, - jint srcColor, SkPorterDuff::Mode mode) { + static jlong glCreatePorterDuffFilter(JNIEnv* env, jobject, jlong skFilterHandle, + jint srcColor, jint modeHandle) { + SkColorFilter *skFilter = reinterpret_cast<SkColorFilter *>(skFilterHandle); + SkPorterDuff::Mode mode = static_cast<SkPorterDuff::Mode>(modeHandle); #ifdef USE_OPENGL_RENDERER - return new SkiaBlendFilter(skFilter, srcColor, SkPorterDuff::ToXfermodeMode(mode)); + return reinterpret_cast<jlong>(new SkiaBlendFilter(skFilter, srcColor, SkPorterDuff::ToXfermodeMode(mode))); #else return NULL; #endif } - static SkiaColorFilter* glCreateLightingFilter(JNIEnv* env, jobject, SkColorFilter *skFilter, + static jlong glCreateLightingFilter(JNIEnv* env, jobject, jlong skFilterHandle, jint mul, jint add) { + SkColorFilter *skFilter = reinterpret_cast<SkColorFilter *>(skFilterHandle); #ifdef USE_OPENGL_RENDERER - return new SkiaLightingFilter(skFilter, mul, add); + return reinterpret_cast<jlong>(new SkiaLightingFilter(skFilter, mul, add)); #else return NULL; #endif } - static SkiaColorFilter* glCreateColorMatrixFilter(JNIEnv* env, jobject, SkColorFilter *skFilter, + static jlong glCreateColorMatrixFilter(JNIEnv* env, jobject, jlong skFilterHandle, jfloatArray jarray) { + SkColorFilter *skFilter = reinterpret_cast<SkColorFilter *>(skFilterHandle); #ifdef USE_OPENGL_RENDERER AutoJavaFloatArray autoArray(env, jarray, 20); const float* src = autoArray.ptr(); @@ -80,22 +86,23 @@ public: colorVector[2] = src[14]; colorVector[3] = src[19]; - return new SkiaColorMatrixFilter(skFilter, colorMatrix, colorVector); + return reinterpret_cast<jlong>(new SkiaColorMatrixFilter(skFilter, colorMatrix, colorVector)); #else return NULL; #endif } - static SkColorFilter* CreatePorterDuffFilter(JNIEnv* env, jobject, jint srcColor, - SkPorterDuff::Mode mode) { - return SkColorFilter::CreateModeFilter(srcColor, SkPorterDuff::ToXfermodeMode(mode)); + static jlong CreatePorterDuffFilter(JNIEnv* env, jobject, jint srcColor, + jint modeHandle) { + SkPorterDuff::Mode mode = (SkPorterDuff::Mode) modeHandle; + return reinterpret_cast<jlong>(SkColorFilter::CreateModeFilter(srcColor, SkPorterDuff::ToXfermodeMode(mode))); } - static SkColorFilter* CreateLightingFilter(JNIEnv* env, jobject, jint mul, jint add) { - return SkColorFilter::CreateLightingFilter(mul, add); + static jlong CreateLightingFilter(JNIEnv* env, jobject, jint mul, jint add) { + return reinterpret_cast<jlong>(SkColorFilter::CreateLightingFilter(mul, add)); } - static SkColorFilter* CreateColorMatrixFilter(JNIEnv* env, jobject, jfloatArray jarray) { + static jlong CreateColorMatrixFilter(JNIEnv* env, jobject, jfloatArray jarray) { AutoJavaFloatArray autoArray(env, jarray, 20); const float* src = autoArray.ptr(); @@ -104,30 +111,30 @@ public: for (int i = 0; i < 20; i++) { array[i] = SkFloatToScalar(src[i]); } - return new SkColorMatrixFilter(array); + return reinterpret_cast<jlong>(new SkColorMatrixFilter(array)); #else - return new SkColorMatrixFilter(src); + return reinterpret_cast<jlong>(new SkColorMatrixFilter(src)); #endif } }; static JNINativeMethod colorfilter_methods[] = { - {"destroyFilter", "(II)V", (void*) SkColorFilterGlue::finalizer} + {"destroyFilter", "(JJ)V", (void*) SkColorFilterGlue::finalizer} }; static JNINativeMethod porterduff_methods[] = { - { "native_CreatePorterDuffFilter", "(II)I", (void*) SkColorFilterGlue::CreatePorterDuffFilter }, - { "nCreatePorterDuffFilter", "(III)I", (void*) SkColorFilterGlue::glCreatePorterDuffFilter } + { "native_CreatePorterDuffFilter", "(II)J", (void*) SkColorFilterGlue::CreatePorterDuffFilter }, + { "nCreatePorterDuffFilter", "(JII)J", (void*) SkColorFilterGlue::glCreatePorterDuffFilter } }; static JNINativeMethod lighting_methods[] = { - { "native_CreateLightingFilter", "(II)I", (void*) SkColorFilterGlue::CreateLightingFilter }, - { "nCreateLightingFilter", "(III)I", (void*) SkColorFilterGlue::glCreateLightingFilter }, + { "native_CreateLightingFilter", "(II)J", (void*) SkColorFilterGlue::CreateLightingFilter }, + { "nCreateLightingFilter", "(JII)J", (void*) SkColorFilterGlue::glCreateLightingFilter }, }; static JNINativeMethod colormatrix_methods[] = { - { "nativeColorMatrixFilter", "([F)I", (void*) SkColorFilterGlue::CreateColorMatrixFilter }, - { "nColorMatrixFilter", "(I[F)I", (void*) SkColorFilterGlue::glCreateColorMatrixFilter } + { "nativeColorMatrixFilter", "([F)J", (void*) SkColorFilterGlue::CreateColorMatrixFilter }, + { "nColorMatrixFilter", "(J[F)J", (void*) SkColorFilterGlue::glCreateColorMatrixFilter } }; #define REG(env, name, array) \ diff --git a/core/jni/android/graphics/DrawFilter.cpp b/core/jni/android/graphics/DrawFilter.cpp index 2f9fe7e..fbfa2ec 100644 --- a/core/jni/android/graphics/DrawFilter.cpp +++ b/core/jni/android/graphics/DrawFilter.cpp @@ -33,18 +33,20 @@ namespace android { class SkDrawFilterGlue { public: - static void finalizer(JNIEnv* env, jobject clazz, SkDrawFilter* obj) { + static void finalizer(JNIEnv* env, jobject clazz, jlong objHandle) { + SkDrawFilter* obj = reinterpret_cast<SkDrawFilter*>(objHandle); SkSafeUnref(obj); } - static SkDrawFilter* CreatePaintFlagsDF(JNIEnv* env, jobject clazz, - int clearFlags, int setFlags) { + static jlong CreatePaintFlagsDF(JNIEnv* env, jobject clazz, + jint clearFlags, jint setFlags) { // trim off any out-of-range bits clearFlags &= SkPaint::kAllFlags; setFlags &= SkPaint::kAllFlags; if (clearFlags | setFlags) { - return new SkPaintFlagsDrawFilter(clearFlags, setFlags); + SkDrawFilter* filter = new SkPaintFlagsDrawFilter(clearFlags, setFlags); + return reinterpret_cast<jlong>(filter); } else { return NULL; } @@ -52,11 +54,11 @@ public: }; static JNINativeMethod drawfilter_methods[] = { - {"nativeDestructor", "(I)V", (void*) SkDrawFilterGlue::finalizer} + {"nativeDestructor", "(J)V", (void*) SkDrawFilterGlue::finalizer} }; static JNINativeMethod paintflags_methods[] = { - {"nativeConstructor","(II)I", (void*) SkDrawFilterGlue::CreatePaintFlagsDF} + {"nativeConstructor","(II)J", (void*) SkDrawFilterGlue::CreatePaintFlagsDF} }; #define REG(env, name, array) \ diff --git a/core/jni/android/graphics/Graphics.cpp b/core/jni/android/graphics/Graphics.cpp index 2a2db57..66f9f3d 100644 --- a/core/jni/android/graphics/Graphics.cpp +++ b/core/jni/android/graphics/Graphics.cpp @@ -293,7 +293,8 @@ SkBitmap* GraphicsJNI::getNativeBitmap(JNIEnv* env, jobject bitmap) { SkASSERT(env); SkASSERT(bitmap); SkASSERT(env->IsInstanceOf(bitmap, gBitmap_class)); - SkBitmap* b = (SkBitmap*)env->GetIntField(bitmap, gBitmap_nativeInstanceID); + jlong bitmapHandle = env->GetLongField(bitmap, gBitmap_nativeInstanceID); + SkBitmap* b = reinterpret_cast<SkBitmap*>(bitmapHandle); SkASSERT(b); return b; } @@ -316,7 +317,8 @@ SkCanvas* GraphicsJNI::getNativeCanvas(JNIEnv* env, jobject canvas) { SkASSERT(env); SkASSERT(canvas); SkASSERT(env->IsInstanceOf(canvas, gCanvas_class)); - SkCanvas* c = (SkCanvas*)env->GetIntField(canvas, gCanvas_nativeInstanceID); + jlong canvasHandle = env->GetLongField(canvas, gCanvas_nativeInstanceID); + SkCanvas* c = reinterpret_cast<SkCanvas*>(canvasHandle); SkASSERT(c); return c; } @@ -325,7 +327,8 @@ SkPaint* GraphicsJNI::getNativePaint(JNIEnv* env, jobject paint) { SkASSERT(env); SkASSERT(paint); SkASSERT(env->IsInstanceOf(paint, gPaint_class)); - SkPaint* p = (SkPaint*)env->GetIntField(paint, gPaint_nativeInstanceID); + jlong paintHandle = env->GetLongField(paint, gPaint_nativeInstanceID); + SkPaint* p = reinterpret_cast<SkPaint*>(paintHandle); SkASSERT(p); return p; } @@ -335,7 +338,8 @@ SkPicture* GraphicsJNI::getNativePicture(JNIEnv* env, jobject picture) SkASSERT(env); SkASSERT(picture); SkASSERT(env->IsInstanceOf(picture, gPicture_class)); - SkPicture* p = (SkPicture*)env->GetIntField(picture, gPicture_nativeInstanceID); + jlong pictureHandle = env->GetLongField(picture, gPicture_nativeInstanceID); + SkPicture* p = reinterpret_cast<SkPicture*>(pictureHandle); SkASSERT(p); return p; } @@ -345,7 +349,8 @@ SkRegion* GraphicsJNI::getNativeRegion(JNIEnv* env, jobject region) SkASSERT(env); SkASSERT(region); SkASSERT(env->IsInstanceOf(region, gRegion_class)); - SkRegion* r = (SkRegion*)env->GetIntField(region, gRegion_nativeInstanceID); + jlong regionHandle = env->GetLongField(region, gRegion_nativeInstanceID); + SkRegion* r = reinterpret_cast<SkRegion*>(regionHandle); SkASSERT(r); return r; } @@ -377,7 +382,7 @@ jobject GraphicsJNI::createBitmap(JNIEnv* env, SkBitmap* bitmap, jbyteArray buff assert_premultiplied(*bitmap, isPremultiplied); jobject obj = env->NewObject(gBitmap_class, gBitmap_constructorMethodID, - static_cast<jint>(reinterpret_cast<uintptr_t>(bitmap)), buffer, + reinterpret_cast<jlong>(bitmap), buffer, bitmap->width(), bitmap->height(), density, isMutable, isPremultiplied, ninepatch, layoutbounds); hasException(env); // For the side effect of logging. @@ -421,7 +426,7 @@ jobject GraphicsJNI::createRegion(JNIEnv* env, SkRegion* region) { SkASSERT(region != NULL); jobject obj = env->NewObject(gRegion_class, gRegion_constructorMethodID, - static_cast<jint>(reinterpret_cast<uintptr_t>(region)), 0); + reinterpret_cast<jlong>(region), 0); hasException(env); // For the side effect of logging. return obj; } @@ -666,8 +671,8 @@ int register_android_graphics_Graphics(JNIEnv* env) gPointF_yFieldID = getFieldIDCheck(env, gPointF_class, "y", "F"); gBitmap_class = make_globalref(env, "android/graphics/Bitmap"); - gBitmap_nativeInstanceID = getFieldIDCheck(env, gBitmap_class, "mNativeBitmap", "I"); - gBitmap_constructorMethodID = env->GetMethodID(gBitmap_class, "<init>", "(I[BIIIZZ[B[I)V"); + gBitmap_nativeInstanceID = getFieldIDCheck(env, gBitmap_class, "mNativeBitmap", "J"); + gBitmap_constructorMethodID = env->GetMethodID(gBitmap_class, "<init>", "(J[BIIIZZ[B[I)V"); gBitmap_reinitMethodID = env->GetMethodID(gBitmap_class, "reinit", "(IIZ)V"); gBitmap_getAllocationByteCountMethodID = env->GetMethodID(gBitmap_class, "getAllocationByteCount", "()I"); gBitmapRegionDecoder_class = make_globalref(env, "android/graphics/BitmapRegionDecoder"); @@ -678,18 +683,18 @@ int register_android_graphics_Graphics(JNIEnv* env) "nativeInt", "I"); gCanvas_class = make_globalref(env, "android/graphics/Canvas"); - gCanvas_nativeInstanceID = getFieldIDCheck(env, gCanvas_class, "mNativeCanvas", "I"); + gCanvas_nativeInstanceID = getFieldIDCheck(env, gCanvas_class, "mNativeCanvas", "J"); gPaint_class = make_globalref(env, "android/graphics/Paint"); - gPaint_nativeInstanceID = getFieldIDCheck(env, gPaint_class, "mNativePaint", "I"); + gPaint_nativeInstanceID = getFieldIDCheck(env, gPaint_class, "mNativePaint", "J"); gPicture_class = make_globalref(env, "android/graphics/Picture"); - gPicture_nativeInstanceID = getFieldIDCheck(env, gPicture_class, "mNativePicture", "I"); + gPicture_nativeInstanceID = getFieldIDCheck(env, gPicture_class, "mNativePicture", "J"); gRegion_class = make_globalref(env, "android/graphics/Region"); - gRegion_nativeInstanceID = getFieldIDCheck(env, gRegion_class, "mNativeRegion", "I"); + gRegion_nativeInstanceID = getFieldIDCheck(env, gRegion_class, "mNativeRegion", "J"); gRegion_constructorMethodID = env->GetMethodID(gRegion_class, "<init>", - "(II)V"); + "(JI)V"); c = env->FindClass("java/lang/Byte"); gByte_class = (jclass) env->NewGlobalRef( diff --git a/core/jni/android/graphics/LayerRasterizer.cpp b/core/jni/android/graphics/LayerRasterizer.cpp index e5bc6f8..29e7db1 100644 --- a/core/jni/android/graphics/LayerRasterizer.cpp +++ b/core/jni/android/graphics/LayerRasterizer.cpp @@ -3,11 +3,13 @@ class SkLayerRasterizerGlue { public: - static SkRasterizer* create(JNIEnv* env, jobject) { - return new SkLayerRasterizer(); + static jlong create(JNIEnv* env, jobject) { + return reinterpret_cast<jlong>(new SkLayerRasterizer()); } - static void addLayer(JNIEnv* env, jobject, SkLayerRasterizer* layer, const SkPaint* paint, float dx, float dy) { + static void addLayer(JNIEnv* env, jobject, jlong layerHandle, jlong paintHandle, jfloat dx, jfloat dy) { + SkLayerRasterizer* layer = reinterpret_cast<SkLayerRasterizer *>(layerHandle); + const SkPaint* paint = reinterpret_cast<SkPaint *>(paintHandle); SkASSERT(layer); SkASSERT(paint); layer->addLayer(*paint, SkFloatToScalar(dx), SkFloatToScalar(dy)); @@ -19,8 +21,8 @@ public: #include <android_runtime/AndroidRuntime.h> static JNINativeMethod gLayerRasterizerMethods[] = { - { "nativeConstructor", "()I", (void*)SkLayerRasterizerGlue::create }, - { "nativeAddLayer", "(IIFF)V", (void*)SkLayerRasterizerGlue::addLayer } + { "nativeConstructor", "()J", (void*)SkLayerRasterizerGlue::create }, + { "nativeAddLayer", "(JJFF)V", (void*)SkLayerRasterizerGlue::addLayer } }; int register_android_graphics_LayerRasterizer(JNIEnv* env) diff --git a/core/jni/android/graphics/MaskFilter.cpp b/core/jni/android/graphics/MaskFilter.cpp index d954ddf..f331af7 100644 --- a/core/jni/android/graphics/MaskFilter.cpp +++ b/core/jni/android/graphics/MaskFilter.cpp @@ -13,18 +13,19 @@ static void ThrowIAE_IfNull(JNIEnv* env, void* ptr) { class SkMaskFilterGlue { public: - static void destructor(JNIEnv* env, jobject, SkMaskFilter* filter) { + static void destructor(JNIEnv* env, jobject, jlong filterHandle) { + SkMaskFilter* filter = reinterpret_cast<SkMaskFilter *>(filterHandle); SkSafeUnref(filter); } - static SkMaskFilter* createBlur(JNIEnv* env, jobject, float radius, int blurStyle) { + static jlong createBlur(JNIEnv* env, jobject, jfloat radius, jint blurStyle) { SkMaskFilter* filter = SkBlurMaskFilter::Create(SkFloatToScalar(radius), (SkBlurMaskFilter::BlurStyle)blurStyle); ThrowIAE_IfNull(env, filter); - return filter; + return reinterpret_cast<jlong>(filter); } - static SkMaskFilter* createEmboss(JNIEnv* env, jobject, jfloatArray dirArray, float ambient, float specular, float radius) { + static jlong createEmboss(JNIEnv* env, jobject, jfloatArray dirArray, jfloat ambient, jfloat specular, jfloat radius) { SkScalar direction[3]; AutoJavaFloatArray autoDir(env, dirArray, 3); @@ -38,39 +39,42 @@ public: SkFloatToScalar(specular), SkFloatToScalar(radius)); ThrowIAE_IfNull(env, filter); - return filter; + return reinterpret_cast<jlong>(filter); } - static SkMaskFilter* createTable(JNIEnv* env, jobject, jbyteArray jtable) { + static jlong createTable(JNIEnv* env, jobject, jbyteArray jtable) { AutoJavaByteArray autoTable(env, jtable, 256); - return new SkTableMaskFilter((const uint8_t*)autoTable.ptr()); + SkMaskFilter* filter = new SkTableMaskFilter((const uint8_t*)autoTable.ptr()); + return reinterpret_cast<jlong>(filter); } - static SkMaskFilter* createClipTable(JNIEnv* env, jobject, int min, int max) { - return SkTableMaskFilter::CreateClip(min, max); + static jlong createClipTable(JNIEnv* env, jobject, jint min, jint max) { + SkMaskFilter* filter = SkTableMaskFilter::CreateClip(min, max); + return reinterpret_cast<jlong>(filter); } - static SkMaskFilter* createGammaTable(JNIEnv* env, jobject, float gamma) { - return SkTableMaskFilter::CreateGamma(gamma); + static jlong createGammaTable(JNIEnv* env, jobject, jfloat gamma) { + SkMaskFilter* filter = SkTableMaskFilter::CreateGamma(gamma); + return reinterpret_cast<jlong>(filter); } }; static JNINativeMethod gMaskFilterMethods[] = { - { "nativeDestructor", "(I)V", (void*)SkMaskFilterGlue::destructor } + { "nativeDestructor", "(J)V", (void*)SkMaskFilterGlue::destructor } }; static JNINativeMethod gBlurMaskFilterMethods[] = { - { "nativeConstructor", "(FI)I", (void*)SkMaskFilterGlue::createBlur } + { "nativeConstructor", "(FI)J", (void*)SkMaskFilterGlue::createBlur } }; static JNINativeMethod gEmbossMaskFilterMethods[] = { - { "nativeConstructor", "([FFFF)I", (void*)SkMaskFilterGlue::createEmboss } + { "nativeConstructor", "([FFFF)J", (void*)SkMaskFilterGlue::createEmboss } }; static JNINativeMethod gTableMaskFilterMethods[] = { - { "nativeNewTable", "([B)I", (void*)SkMaskFilterGlue::createTable }, - { "nativeNewClip", "(II)I", (void*)SkMaskFilterGlue::createClipTable }, - { "nativeNewGamma", "(F)I", (void*)SkMaskFilterGlue::createGammaTable } + { "nativeNewTable", "([B)J", (void*)SkMaskFilterGlue::createTable }, + { "nativeNewClip", "(II)J", (void*)SkMaskFilterGlue::createClipTable }, + { "nativeNewGamma", "(F)J", (void*)SkMaskFilterGlue::createGammaTable } }; #include <android_runtime/AndroidRuntime.h> diff --git a/core/jni/android/graphics/Matrix.cpp b/core/jni/android/graphics/Matrix.cpp index 4bd59e7..6ae9fea 100644 --- a/core/jni/android/graphics/Matrix.cpp +++ b/core/jni/android/graphics/Matrix.cpp @@ -31,210 +31,237 @@ namespace android { class SkMatrixGlue { public: - static void finalizer(JNIEnv* env, jobject clazz, SkMatrix* obj) { + static void finalizer(JNIEnv* env, jobject clazz, jlong objHandle) { + SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); delete obj; } - static SkMatrix* create(JNIEnv* env, jobject clazz, const SkMatrix* src) { + static jlong create(JNIEnv* env, jobject clazz, jlong srcHandle) { + const SkMatrix* src = reinterpret_cast<SkMatrix*>(srcHandle); SkMatrix* obj = new SkMatrix(); if (src) *obj = *src; else obj->reset(); - return obj; + return reinterpret_cast<jlong>(obj); } - - static jboolean isIdentity(JNIEnv* env, jobject clazz, SkMatrix* obj) { - return obj->isIdentity(); + + static jboolean isIdentity(JNIEnv* env, jobject clazz, jlong objHandle) { + SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); + return obj->isIdentity() ? JNI_TRUE : JNI_FALSE; } - - static jboolean rectStaysRect(JNIEnv* env, jobject clazz, SkMatrix* obj) { - return obj->rectStaysRect(); + static jboolean rectStaysRect(JNIEnv* env, jobject clazz, jlong objHandle) { + SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); + return obj->rectStaysRect() ? JNI_TRUE : JNI_FALSE; } - - static void reset(JNIEnv* env, jobject clazz, SkMatrix* obj) { + static void reset(JNIEnv* env, jobject clazz, jlong objHandle) { + SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); obj->reset(); } - - static void set(JNIEnv* env, jobject clazz, SkMatrix* obj, SkMatrix* other) { + static void set(JNIEnv* env, jobject clazz, jlong objHandle, jlong otherHandle) { + SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); + SkMatrix* other = reinterpret_cast<SkMatrix*>(otherHandle); *obj = *other; } - - static void setTranslate(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat dx, jfloat dy) { + static void setTranslate(JNIEnv* env, jobject clazz, jlong objHandle, jfloat dx, jfloat dy) { + SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); SkScalar dx_ = SkFloatToScalar(dx); SkScalar dy_ = SkFloatToScalar(dy); obj->setTranslate(dx_, dy_); } - - static void setScale__FFFF(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat sx, jfloat sy, jfloat px, jfloat py) { + static void setScale__FFFF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat sx, jfloat sy, jfloat px, jfloat py) { + SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); SkScalar sx_ = SkFloatToScalar(sx); SkScalar sy_ = SkFloatToScalar(sy); SkScalar px_ = SkFloatToScalar(px); SkScalar py_ = SkFloatToScalar(py); obj->setScale(sx_, sy_, px_, py_); } - - static void setScale__FF(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat sx, jfloat sy) { + static void setScale__FF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat sx, jfloat sy) { + SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); SkScalar sx_ = SkFloatToScalar(sx); SkScalar sy_ = SkFloatToScalar(sy); obj->setScale(sx_, sy_); } - - static void setRotate__FFF(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat degrees, jfloat px, jfloat py) { + static void setRotate__FFF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat degrees, jfloat px, jfloat py) { + SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); SkScalar degrees_ = SkFloatToScalar(degrees); SkScalar px_ = SkFloatToScalar(px); SkScalar py_ = SkFloatToScalar(py); obj->setRotate(degrees_, px_, py_); } - - static void setRotate__F(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat degrees) { + static void setRotate__F(JNIEnv* env, jobject clazz, jlong objHandle, jfloat degrees) { + SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); SkScalar degrees_ = SkFloatToScalar(degrees); obj->setRotate(degrees_); } - - static void setSinCos__FFFF(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat sinValue, jfloat cosValue, jfloat px, jfloat py) { + static void setSinCos__FFFF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat sinValue, jfloat cosValue, jfloat px, jfloat py) { + SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); SkScalar sinValue_ = SkFloatToScalar(sinValue); SkScalar cosValue_ = SkFloatToScalar(cosValue); SkScalar px_ = SkFloatToScalar(px); SkScalar py_ = SkFloatToScalar(py); obj->setSinCos(sinValue_, cosValue_, px_, py_); } - - static void setSinCos__FF(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat sinValue, jfloat cosValue) { + static void setSinCos__FF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat sinValue, jfloat cosValue) { + SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); SkScalar sinValue_ = SkFloatToScalar(sinValue); SkScalar cosValue_ = SkFloatToScalar(cosValue); obj->setSinCos(sinValue_, cosValue_); } - - static void setSkew__FFFF(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat kx, jfloat ky, jfloat px, jfloat py) { + static void setSkew__FFFF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat kx, jfloat ky, jfloat px, jfloat py) { + SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); SkScalar kx_ = SkFloatToScalar(kx); SkScalar ky_ = SkFloatToScalar(ky); SkScalar px_ = SkFloatToScalar(px); SkScalar py_ = SkFloatToScalar(py); obj->setSkew(kx_, ky_, px_, py_); } - - static void setSkew__FF(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat kx, jfloat ky) { + static void setSkew__FF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat kx, jfloat ky) { + SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); SkScalar kx_ = SkFloatToScalar(kx); SkScalar ky_ = SkFloatToScalar(ky); obj->setSkew(kx_, ky_); } - - static jboolean setConcat(JNIEnv* env, jobject clazz, SkMatrix* obj, SkMatrix* a, SkMatrix* b) { - return obj->setConcat(*a, *b); + static jboolean setConcat(JNIEnv* env, jobject clazz, jlong objHandle, jlong aHandle, jlong bHandle) { + SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); + SkMatrix* a = reinterpret_cast<SkMatrix*>(aHandle); + SkMatrix* b = reinterpret_cast<SkMatrix*>(bHandle); + return obj->setConcat(*a, *b) ? JNI_TRUE : JNI_FALSE; } - - static jboolean preTranslate(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat dx, jfloat dy) { + + static jboolean preTranslate(JNIEnv* env, jobject clazz, jlong objHandle, jfloat dx, jfloat dy) { + SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); SkScalar dx_ = SkFloatToScalar(dx); SkScalar dy_ = SkFloatToScalar(dy); - return obj->preTranslate(dx_, dy_); + return obj->preTranslate(dx_, dy_) ? JNI_TRUE : JNI_FALSE; } - - static jboolean preScale__FFFF(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat sx, jfloat sy, jfloat px, jfloat py) { + + static jboolean preScale__FFFF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat sx, jfloat sy, jfloat px, jfloat py) { + SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); SkScalar sx_ = SkFloatToScalar(sx); SkScalar sy_ = SkFloatToScalar(sy); SkScalar px_ = SkFloatToScalar(px); SkScalar py_ = SkFloatToScalar(py); - return obj->preScale(sx_, sy_, px_, py_); + return obj->preScale(sx_, sy_, px_, py_) ? JNI_TRUE : JNI_FALSE; } - - static jboolean preScale__FF(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat sx, jfloat sy) { + + static jboolean preScale__FF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat sx, jfloat sy) { + SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); SkScalar sx_ = SkFloatToScalar(sx); SkScalar sy_ = SkFloatToScalar(sy); - return obj->preScale(sx_, sy_); + return obj->preScale(sx_, sy_) ? JNI_TRUE : JNI_FALSE; } - - static jboolean preRotate__FFF(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat degrees, jfloat px, jfloat py) { + + static jboolean preRotate__FFF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat degrees, jfloat px, jfloat py) { + SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); SkScalar degrees_ = SkFloatToScalar(degrees); SkScalar px_ = SkFloatToScalar(px); SkScalar py_ = SkFloatToScalar(py); - return obj->preRotate(degrees_, px_, py_); + return obj->preRotate(degrees_, px_, py_) ? JNI_TRUE : JNI_FALSE; } - - static jboolean preRotate__F(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat degrees) { + + static jboolean preRotate__F(JNIEnv* env, jobject clazz, jlong objHandle, jfloat degrees) { + SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); SkScalar degrees_ = SkFloatToScalar(degrees); - return obj->preRotate(degrees_); + return obj->preRotate(degrees_) ? JNI_TRUE : JNI_FALSE; } - - static jboolean preSkew__FFFF(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat kx, jfloat ky, jfloat px, jfloat py) { + + static jboolean preSkew__FFFF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat kx, jfloat ky, jfloat px, jfloat py) { + SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); SkScalar kx_ = SkFloatToScalar(kx); SkScalar ky_ = SkFloatToScalar(ky); SkScalar px_ = SkFloatToScalar(px); SkScalar py_ = SkFloatToScalar(py); - return obj->preSkew(kx_, ky_, px_, py_); + return obj->preSkew(kx_, ky_, px_, py_) ? JNI_TRUE : JNI_FALSE; } - - static jboolean preSkew__FF(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat kx, jfloat ky) { + + static jboolean preSkew__FF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat kx, jfloat ky) { + SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); SkScalar kx_ = SkFloatToScalar(kx); SkScalar ky_ = SkFloatToScalar(ky); - return obj->preSkew(kx_, ky_); + return obj->preSkew(kx_, ky_) ? JNI_TRUE : JNI_FALSE; } - - static jboolean preConcat(JNIEnv* env, jobject clazz, SkMatrix* obj, SkMatrix* other) { - return obj->preConcat(*other); + + static jboolean preConcat(JNIEnv* env, jobject clazz, jlong objHandle, jlong otherHandle) { + SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); + SkMatrix* other = reinterpret_cast<SkMatrix*>(otherHandle); + return obj->preConcat(*other) ? JNI_TRUE : JNI_FALSE; } - - static jboolean postTranslate(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat dx, jfloat dy) { + + static jboolean postTranslate(JNIEnv* env, jobject clazz, jlong objHandle, jfloat dx, jfloat dy) { + SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); SkScalar dx_ = SkFloatToScalar(dx); SkScalar dy_ = SkFloatToScalar(dy); - return obj->postTranslate(dx_, dy_); + return obj->postTranslate(dx_, dy_) ? JNI_TRUE : JNI_FALSE; } - - static jboolean postScale__FFFF(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat sx, jfloat sy, jfloat px, jfloat py) { + + static jboolean postScale__FFFF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat sx, jfloat sy, jfloat px, jfloat py) { + SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); SkScalar sx_ = SkFloatToScalar(sx); SkScalar sy_ = SkFloatToScalar(sy); SkScalar px_ = SkFloatToScalar(px); SkScalar py_ = SkFloatToScalar(py); - return obj->postScale(sx_, sy_, px_, py_); + return obj->postScale(sx_, sy_, px_, py_) ? JNI_TRUE : JNI_FALSE; } - - static jboolean postScale__FF(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat sx, jfloat sy) { + + static jboolean postScale__FF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat sx, jfloat sy) { + SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); SkScalar sx_ = SkFloatToScalar(sx); SkScalar sy_ = SkFloatToScalar(sy); - return obj->postScale(sx_, sy_); + return obj->postScale(sx_, sy_) ? JNI_TRUE : JNI_FALSE; } - - static jboolean postRotate__FFF(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat degrees, jfloat px, jfloat py) { + + static jboolean postRotate__FFF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat degrees, jfloat px, jfloat py) { + SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); SkScalar degrees_ = SkFloatToScalar(degrees); SkScalar px_ = SkFloatToScalar(px); SkScalar py_ = SkFloatToScalar(py); - return obj->postRotate(degrees_, px_, py_); + return obj->postRotate(degrees_, px_, py_) ? JNI_TRUE : JNI_FALSE; } - - static jboolean postRotate__F(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat degrees) { + + static jboolean postRotate__F(JNIEnv* env, jobject clazz, jlong objHandle, jfloat degrees) { + SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); SkScalar degrees_ = SkFloatToScalar(degrees); - return obj->postRotate(degrees_); + return obj->postRotate(degrees_) ? JNI_TRUE : JNI_FALSE; } - - static jboolean postSkew__FFFF(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat kx, jfloat ky, jfloat px, jfloat py) { + + static jboolean postSkew__FFFF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat kx, jfloat ky, jfloat px, jfloat py) { + SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle); SkScalar kx_ = SkFloatToScalar(kx); SkScalar ky_ = SkFloatToScalar(ky); SkScalar px_ = SkFloatToScalar(px); SkScalar py_ = SkFloatToScalar(py); - return obj->postSkew(kx_, ky_, px_, py_); + return obj->postSkew(kx_, ky_, px_, py_) ? JNI_TRUE : JNI_FALSE; } - - static jboolean postSkew__FF(JNIEnv* env, jobject clazz, SkMatrix* matrix, jfloat kx, jfloat ky) { + + static jboolean postSkew__FF(JNIEnv* env, jobject clazz, jlong matrixHandle, jfloat kx, jfloat ky) { + SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle); SkScalar kx_ = SkFloatToScalar(kx); SkScalar ky_ = SkFloatToScalar(ky); - return matrix->postSkew(kx_, ky_); + return matrix->postSkew(kx_, ky_) ? JNI_TRUE : JNI_FALSE; } - - static jboolean postConcat(JNIEnv* env, jobject clazz, SkMatrix* matrix, SkMatrix* other) { - return matrix->postConcat(*other); + + static jboolean postConcat(JNIEnv* env, jobject clazz, jlong matrixHandle, jlong otherHandle) { + SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle); + SkMatrix* other = reinterpret_cast<SkMatrix*>(otherHandle); + return matrix->postConcat(*other) ? JNI_TRUE : JNI_FALSE; } - - static jboolean setRectToRect(JNIEnv* env, jobject clazz, SkMatrix* matrix, jobject src, jobject dst, SkMatrix::ScaleToFit stf) { + + static jboolean setRectToRect(JNIEnv* env, jobject clazz, jlong matrixHandle, jobject src, jobject dst, jint stfHandle) { + SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle); + SkMatrix::ScaleToFit stf = static_cast<SkMatrix::ScaleToFit>(stfHandle); SkRect src_; GraphicsJNI::jrectf_to_rect(env, src, &src_); SkRect dst_; GraphicsJNI::jrectf_to_rect(env, dst, &dst_); - return matrix->setRectToRect(src_, dst_, stf); + return matrix->setRectToRect(src_, dst_, stf) ? JNI_TRUE : JNI_FALSE; } - - static jboolean setPolyToPoly(JNIEnv* env, jobject clazz, SkMatrix* matrix, - jfloatArray jsrc, int srcIndex, - jfloatArray jdst, int dstIndex, int ptCount) { + + static jboolean setPolyToPoly(JNIEnv* env, jobject clazz, jlong matrixHandle, + jfloatArray jsrc, jint srcIndex, + jfloatArray jdst, jint dstIndex, jint ptCount) { + SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle); SkASSERT(srcIndex >= 0); SkASSERT(dstIndex >= 0); SkASSERT((unsigned)ptCount <= 4); @@ -243,6 +270,7 @@ public: AutoJavaFloatArray autoDst(env, jdst, dstIndex + (ptCount << 1), kRW_JNIAccess); float* src = autoSrc.ptr() + srcIndex; float* dst = autoDst.ptr() + dstIndex; + bool result; #ifdef SK_SCALAR_IS_FIXED SkPoint srcPt[4], dstPt[4]; @@ -252,21 +280,25 @@ public: srcPt[i].set(SkFloatToScalar(src[x]), SkFloatToScalar(src[y])); dstPt[i].set(SkFloatToScalar(dst[x]), SkFloatToScalar(dst[y])); } - return matrix->setPolyToPoly(srcPt, dstPt, ptCount); + result = matrix->setPolyToPoly(srcPt, dstPt, ptCount); #else - return matrix->setPolyToPoly((const SkPoint*)src, (const SkPoint*)dst, + result = matrix->setPolyToPoly((const SkPoint*)src, (const SkPoint*)dst, ptCount); #endif + return result ? JNI_TRUE : JNI_FALSE; } - - static jboolean invert(JNIEnv* env, jobject clazz, SkMatrix* matrix, SkMatrix* inverse) { + + static jboolean invert(JNIEnv* env, jobject clazz, jlong matrixHandle, jlong inverseHandle) { + SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle); + SkMatrix* inverse = reinterpret_cast<SkMatrix*>(inverseHandle); return matrix->invert(inverse); } - - static void mapPoints(JNIEnv* env, jobject clazz, SkMatrix* matrix, - jfloatArray dst, int dstIndex, - jfloatArray src, int srcIndex, - int ptCount, bool isPts) { + + static void mapPoints(JNIEnv* env, jobject clazz, jlong matrixHandle, + jfloatArray dst, jint dstIndex, + jfloatArray src, jint srcIndex, + jint ptCount, jboolean isPts) { + SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle); SkASSERT(ptCount >= 0); AutoJavaFloatArray autoSrc(env, src, srcIndex + (ptCount << 1), kRO_JNIAccess); AutoJavaFloatArray autoDst(env, dst, dstIndex + (ptCount << 1), kRW_JNIAccess); @@ -304,20 +336,24 @@ public: ptCount); #endif } - - static jboolean mapRect__RectFRectF(JNIEnv* env, jobject clazz, SkMatrix* matrix, jobjectArray dst, jobject src) { + + static jboolean mapRect__RectFRectF(JNIEnv* env, jobject clazz, jlong matrixHandle, jobjectArray dst, jobject src) { + SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle); SkRect dst_, src_; GraphicsJNI::jrectf_to_rect(env, src, &src_); jboolean rectStaysRect = matrix->mapRect(&dst_, src_); GraphicsJNI::rect_to_jrectf(dst_, env, dst); - return rectStaysRect; + return rectStaysRect ? JNI_TRUE : JNI_FALSE; } - - static jfloat mapRadius(JNIEnv* env, jobject clazz, SkMatrix* matrix, jfloat radius) { - return SkScalarToFloat(matrix->mapRadius(SkFloatToScalar(radius))); - } - - static void getValues(JNIEnv* env, jobject clazz, SkMatrix* matrix, jfloatArray values) { + + static jfloat mapRadius(JNIEnv* env, jobject clazz, jlong matrixHandle, jfloat radius) { + SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle); + float result; + result = SkScalarToFloat(matrix->mapRadius(SkFloatToScalar(radius))); + return static_cast<jfloat>(result); + } + static void getValues(JNIEnv* env, jobject clazz, jlong matrixHandle, jfloatArray values) { + SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle); AutoJavaFloatArray autoValues(env, values, 9, kRW_JNIAccess); float* dst = autoValues.ptr(); @@ -334,8 +370,9 @@ public: } #endif } - - static void setValues(JNIEnv* env, jobject clazz, SkMatrix* matrix, jfloatArray values) { + + static void setValues(JNIEnv* env, jobject clazz, jlong matrixHandle, jfloatArray values) { + SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle); AutoJavaFloatArray autoValues(env, values, 9, kRO_JNIAccess); const float* src = autoValues.ptr(); @@ -353,53 +390,55 @@ public: #endif } - static jboolean equals(JNIEnv* env, jobject clazz, const SkMatrix* a, const SkMatrix* b) { + static jboolean equals(JNIEnv* env, jobject clazz, jlong aHandle, jlong bHandle) { + const SkMatrix* a = reinterpret_cast<SkMatrix*>(aHandle); + const SkMatrix* b = reinterpret_cast<SkMatrix*>(bHandle); return *a == *b; } }; static JNINativeMethod methods[] = { - {"finalizer", "(I)V", (void*) SkMatrixGlue::finalizer}, - {"native_create","(I)I", (void*) SkMatrixGlue::create}, - {"native_isIdentity","(I)Z", (void*) SkMatrixGlue::isIdentity}, - {"native_rectStaysRect","(I)Z", (void*) SkMatrixGlue::rectStaysRect}, - {"native_reset","(I)V", (void*) SkMatrixGlue::reset}, - {"native_set","(II)V", (void*) SkMatrixGlue::set}, - {"native_setTranslate","(IFF)V", (void*) SkMatrixGlue::setTranslate}, - {"native_setScale","(IFFFF)V", (void*) SkMatrixGlue::setScale__FFFF}, - {"native_setScale","(IFF)V", (void*) SkMatrixGlue::setScale__FF}, - {"native_setRotate","(IFFF)V", (void*) SkMatrixGlue::setRotate__FFF}, - {"native_setRotate","(IF)V", (void*) SkMatrixGlue::setRotate__F}, - {"native_setSinCos","(IFFFF)V", (void*) SkMatrixGlue::setSinCos__FFFF}, - {"native_setSinCos","(IFF)V", (void*) SkMatrixGlue::setSinCos__FF}, - {"native_setSkew","(IFFFF)V", (void*) SkMatrixGlue::setSkew__FFFF}, - {"native_setSkew","(IFF)V", (void*) SkMatrixGlue::setSkew__FF}, - {"native_setConcat","(III)Z", (void*) SkMatrixGlue::setConcat}, - {"native_preTranslate","(IFF)Z", (void*) SkMatrixGlue::preTranslate}, - {"native_preScale","(IFFFF)Z", (void*) SkMatrixGlue::preScale__FFFF}, - {"native_preScale","(IFF)Z", (void*) SkMatrixGlue::preScale__FF}, - {"native_preRotate","(IFFF)Z", (void*) SkMatrixGlue::preRotate__FFF}, - {"native_preRotate","(IF)Z", (void*) SkMatrixGlue::preRotate__F}, - {"native_preSkew","(IFFFF)Z", (void*) SkMatrixGlue::preSkew__FFFF}, - {"native_preSkew","(IFF)Z", (void*) SkMatrixGlue::preSkew__FF}, - {"native_preConcat","(II)Z", (void*) SkMatrixGlue::preConcat}, - {"native_postTranslate","(IFF)Z", (void*) SkMatrixGlue::postTranslate}, - {"native_postScale","(IFFFF)Z", (void*) SkMatrixGlue::postScale__FFFF}, - {"native_postScale","(IFF)Z", (void*) SkMatrixGlue::postScale__FF}, - {"native_postRotate","(IFFF)Z", (void*) SkMatrixGlue::postRotate__FFF}, - {"native_postRotate","(IF)Z", (void*) SkMatrixGlue::postRotate__F}, - {"native_postSkew","(IFFFF)Z", (void*) SkMatrixGlue::postSkew__FFFF}, - {"native_postSkew","(IFF)Z", (void*) SkMatrixGlue::postSkew__FF}, - {"native_postConcat","(II)Z", (void*) SkMatrixGlue::postConcat}, - {"native_setRectToRect","(ILandroid/graphics/RectF;Landroid/graphics/RectF;I)Z", (void*) SkMatrixGlue::setRectToRect}, - {"native_setPolyToPoly","(I[FI[FII)Z", (void*) SkMatrixGlue::setPolyToPoly}, - {"native_invert","(II)Z", (void*) SkMatrixGlue::invert}, - {"native_mapPoints","(I[FI[FIIZ)V", (void*) SkMatrixGlue::mapPoints}, - {"native_mapRect","(ILandroid/graphics/RectF;Landroid/graphics/RectF;)Z", (void*) SkMatrixGlue::mapRect__RectFRectF}, - {"native_mapRadius","(IF)F", (void*) SkMatrixGlue::mapRadius}, - {"native_getValues","(I[F)V", (void*) SkMatrixGlue::getValues}, - {"native_setValues","(I[F)V", (void*) SkMatrixGlue::setValues}, - {"native_equals", "(II)Z", (void*) SkMatrixGlue::equals} + {"finalizer", "(J)V", (void*) SkMatrixGlue::finalizer}, + {"native_create","(J)J", (void*) SkMatrixGlue::create}, + {"native_isIdentity","(J)Z", (void*) SkMatrixGlue::isIdentity}, + {"native_rectStaysRect","(J)Z", (void*) SkMatrixGlue::rectStaysRect}, + {"native_reset","(J)V", (void*) SkMatrixGlue::reset}, + {"native_set","(JJ)V", (void*) SkMatrixGlue::set}, + {"native_setTranslate","(JFF)V", (void*) SkMatrixGlue::setTranslate}, + {"native_setScale","(JFFFF)V", (void*) SkMatrixGlue::setScale__FFFF}, + {"native_setScale","(JFF)V", (void*) SkMatrixGlue::setScale__FF}, + {"native_setRotate","(JFFF)V", (void*) SkMatrixGlue::setRotate__FFF}, + {"native_setRotate","(JF)V", (void*) SkMatrixGlue::setRotate__F}, + {"native_setSinCos","(JFFFF)V", (void*) SkMatrixGlue::setSinCos__FFFF}, + {"native_setSinCos","(JFF)V", (void*) SkMatrixGlue::setSinCos__FF}, + {"native_setSkew","(JFFFF)V", (void*) SkMatrixGlue::setSkew__FFFF}, + {"native_setSkew","(JFF)V", (void*) SkMatrixGlue::setSkew__FF}, + {"native_setConcat","(JJJ)Z", (void*) SkMatrixGlue::setConcat}, + {"native_preTranslate","(JFF)Z", (void*) SkMatrixGlue::preTranslate}, + {"native_preScale","(JFFFF)Z", (void*) SkMatrixGlue::preScale__FFFF}, + {"native_preScale","(JFF)Z", (void*) SkMatrixGlue::preScale__FF}, + {"native_preRotate","(JFFF)Z", (void*) SkMatrixGlue::preRotate__FFF}, + {"native_preRotate","(JF)Z", (void*) SkMatrixGlue::preRotate__F}, + {"native_preSkew","(JFFFF)Z", (void*) SkMatrixGlue::preSkew__FFFF}, + {"native_preSkew","(JFF)Z", (void*) SkMatrixGlue::preSkew__FF}, + {"native_preConcat","(JJ)Z", (void*) SkMatrixGlue::preConcat}, + {"native_postTranslate","(JFF)Z", (void*) SkMatrixGlue::postTranslate}, + {"native_postScale","(JFFFF)Z", (void*) SkMatrixGlue::postScale__FFFF}, + {"native_postScale","(JFF)Z", (void*) SkMatrixGlue::postScale__FF}, + {"native_postRotate","(JFFF)Z", (void*) SkMatrixGlue::postRotate__FFF}, + {"native_postRotate","(JF)Z", (void*) SkMatrixGlue::postRotate__F}, + {"native_postSkew","(JFFFF)Z", (void*) SkMatrixGlue::postSkew__FFFF}, + {"native_postSkew","(JFF)Z", (void*) SkMatrixGlue::postSkew__FF}, + {"native_postConcat","(JJ)Z", (void*) SkMatrixGlue::postConcat}, + {"native_setRectToRect","(JLandroid/graphics/RectF;Landroid/graphics/RectF;I)Z", (void*) SkMatrixGlue::setRectToRect}, + {"native_setPolyToPoly","(J[FI[FII)Z", (void*) SkMatrixGlue::setPolyToPoly}, + {"native_invert","(JJ)Z", (void*) SkMatrixGlue::invert}, + {"native_mapPoints","(J[FI[FIIZ)V", (void*) SkMatrixGlue::mapPoints}, + {"native_mapRect","(JLandroid/graphics/RectF;Landroid/graphics/RectF;)Z", (void*) SkMatrixGlue::mapRect__RectFRectF}, + {"native_mapRadius","(JF)F", (void*) SkMatrixGlue::mapRadius}, + {"native_getValues","(J[F)V", (void*) SkMatrixGlue::getValues}, + {"native_setValues","(J[F)V", (void*) SkMatrixGlue::setValues}, + {"native_equals", "(JJ)Z", (void*) SkMatrixGlue::equals} }; static jfieldID sNativeInstanceField; @@ -409,13 +448,13 @@ int register_android_graphics_Matrix(JNIEnv* env) { sizeof(methods) / sizeof(methods[0])); jclass clazz = env->FindClass("android/graphics/Matrix"); - sNativeInstanceField = env->GetFieldID(clazz, "native_instance", "I"); + sNativeInstanceField = env->GetFieldID(clazz, "native_instance", "J"); return result; } SkMatrix* android_graphics_Matrix_getSkMatrix(JNIEnv* env, jobject matrixObj) { - return reinterpret_cast<SkMatrix*>(env->GetIntField(matrixObj, sNativeInstanceField)); + return reinterpret_cast<SkMatrix*>(env->GetLongField(matrixObj, sNativeInstanceField)); } } diff --git a/core/jni/android/graphics/NinePatch.cpp b/core/jni/android/graphics/NinePatch.cpp index 7e6aeae..871e24d 100644 --- a/core/jni/android/graphics/NinePatch.cpp +++ b/core/jni/android/graphics/NinePatch.cpp @@ -46,22 +46,22 @@ class SkNinePatchGlue { public: static jboolean isNinePatchChunk(JNIEnv* env, jobject, jbyteArray obj) { if (NULL == obj) { - return false; + return JNI_FALSE; } if (env->GetArrayLength(obj) < (int)sizeof(Res_png_9patch)) { - return false; + return JNI_FALSE; } const jbyte* array = env->GetByteArrayElements(obj, 0); if (array != NULL) { const Res_png_9patch* chunk = reinterpret_cast<const Res_png_9patch*>(array); int8_t wasDeserialized = chunk->wasDeserialized; env->ReleaseByteArrayElements(obj, const_cast<jbyte*>(array), JNI_ABORT); - return wasDeserialized != -1; + return (wasDeserialized != -1) ? JNI_TRUE : JNI_FALSE; } - return false; + return JNI_FALSE; } - static int8_t* validateNinePatchChunk(JNIEnv* env, jobject, jint, jbyteArray obj) { + static jlong validateNinePatchChunk(JNIEnv* env, jobject, jlong, jbyteArray obj) { size_t chunkSize = env->GetArrayLength(obj); if (chunkSize < (int) (sizeof(Res_png_9patch))) { jniThrowRuntimeException(env, "Array too small for chunk."); @@ -72,10 +72,11 @@ public: // This call copies the content of the jbyteArray env->GetByteArrayRegion(obj, 0, chunkSize, reinterpret_cast<jbyte*>(storage)); // Deserialize in place, return the array we just allocated - return (int8_t*) Res_png_9patch::deserialize(storage); + return reinterpret_cast<jlong>(Res_png_9patch::deserialize(storage)); } - static void finalize(JNIEnv* env, jobject, int8_t* patch) { + static void finalize(JNIEnv* env, jobject, jlong patchHandle) { + int8_t* patch = reinterpret_cast<int8_t*>(patchHandle); #ifdef USE_OPENGL_RENDERER if (android::uirenderer::Caches::hasInstance()) { Res_png_9patch* p = (Res_png_9patch*) patch; @@ -115,9 +116,13 @@ public: } } - static void drawF(JNIEnv* env, jobject, SkCanvas* canvas, jobject boundsRectF, - const SkBitmap* bitmap, Res_png_9patch* chunk, const SkPaint* paint, + static void drawF(JNIEnv* env, jobject, jlong canvasHandle, jobject boundsRectF, + jlong bitmapHandle, jlong chunkHandle, jlong paintHandle, jint destDensity, jint srcDensity) { + SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle); + const SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle); + Res_png_9patch* chunk = reinterpret_cast<Res_png_9patch*>(chunkHandle); + const SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); SkASSERT(canvas); SkASSERT(boundsRectF); SkASSERT(bitmap); @@ -130,9 +135,13 @@ public: draw(env, canvas, bounds, bitmap, chunk, paint, destDensity, srcDensity); } - static void drawI(JNIEnv* env, jobject, SkCanvas* canvas, jobject boundsRect, - const SkBitmap* bitmap, Res_png_9patch* chunk, const SkPaint* paint, + static void drawI(JNIEnv* env, jobject, jlong canvasHandle, jobject boundsRect, + jlong bitmapHandle, jlong chunkHandle, jlong paintHandle, jint destDensity, jint srcDensity) { + SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle); + const SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle); + Res_png_9patch* chunk = reinterpret_cast<Res_png_9patch*>(chunkHandle); + const SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); SkASSERT(canvas); SkASSERT(boundsRect); SkASSERT(bitmap); @@ -144,8 +153,10 @@ public: draw(env, canvas, bounds, bitmap, chunk, paint, destDensity, srcDensity); } - static jint getTransparentRegion(JNIEnv* env, jobject, const SkBitmap* bitmap, - Res_png_9patch* chunk, jobject boundsRect) { + static jlong getTransparentRegion(JNIEnv* env, jobject, jlong bitmapHandle, + jlong chunkHandle, jobject boundsRect) { + const SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle); + Res_png_9patch* chunk = reinterpret_cast<Res_png_9patch*>(chunkHandle); SkASSERT(bitmap); SkASSERT(chunk); SkASSERT(boundsRect); @@ -156,7 +167,7 @@ public: SkRegion* region = NULL; NinePatch_Draw(NULL, bounds, *bitmap, *chunk, NULL, ®ion); - return (jint) region; + return reinterpret_cast<jlong>(region); } }; @@ -167,11 +178,11 @@ public: static JNINativeMethod gNinePatchMethods[] = { { "isNinePatchChunk", "([B)Z", (void*) SkNinePatchGlue::isNinePatchChunk }, - { "validateNinePatchChunk", "(I[B)I", (void*) SkNinePatchGlue::validateNinePatchChunk }, - { "nativeFinalize", "(I)V", (void*) SkNinePatchGlue::finalize }, - { "nativeDraw", "(ILandroid/graphics/RectF;IIIII)V", (void*) SkNinePatchGlue::drawF }, - { "nativeDraw", "(ILandroid/graphics/Rect;IIIII)V", (void*) SkNinePatchGlue::drawI }, - { "nativeGetTransparentRegion", "(IILandroid/graphics/Rect;)I", + { "validateNinePatchChunk", "(J[B)J", (void*) SkNinePatchGlue::validateNinePatchChunk }, + { "nativeFinalize", "(J)V", (void*) SkNinePatchGlue::finalize }, + { "nativeDraw", "(JLandroid/graphics/RectF;JJJII)V", (void*) SkNinePatchGlue::drawF }, + { "nativeDraw", "(JLandroid/graphics/Rect;JJJII)V", (void*) SkNinePatchGlue::drawI }, + { "nativeGetTransparentRegion", "(JJLandroid/graphics/Rect;)J", (void*) SkNinePatchGlue::getTransparentRegion } }; diff --git a/core/jni/android/graphics/Paint.cpp b/core/jni/android/graphics/Paint.cpp index 1ca3f3a..6c81f06 100644 --- a/core/jni/android/graphics/Paint.cpp +++ b/core/jni/android/graphics/Paint.cpp @@ -70,33 +70,40 @@ public: AFTER, AT_OR_AFTER, BEFORE, AT_OR_BEFORE, AT }; - static void finalizer(JNIEnv* env, jobject clazz, SkPaint* obj) { + static void finalizer(JNIEnv* env, jobject clazz, jlong objHandle) { + SkPaint* obj = reinterpret_cast<SkPaint*>(objHandle); delete obj; } - static SkPaint* init(JNIEnv* env, jobject clazz) { + static jlong init(JNIEnv* env, jobject clazz) { SkPaint* obj = new SkPaint(); defaultSettingsForAndroid(obj); - return obj; + return reinterpret_cast<jlong>(obj); } - static SkPaint* intiWithPaint(JNIEnv* env, jobject clazz, SkPaint* paint) { + static jlong initWithPaint(JNIEnv* env, jobject clazz, jlong paintHandle) { + SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); SkPaint* obj = new SkPaint(*paint); - return obj; + return reinterpret_cast<jlong>(obj); } - static void reset(JNIEnv* env, jobject clazz, SkPaint* obj) { + static void reset(JNIEnv* env, jobject clazz, jlong objHandle) { + SkPaint* obj = reinterpret_cast<SkPaint*>(objHandle); obj->reset(); defaultSettingsForAndroid(obj); } - static void assign(JNIEnv* env, jobject clazz, SkPaint* dst, const SkPaint* src) { + static void assign(JNIEnv* env, jobject clazz, jlong dstPaintHandle, jlong srcPaintHandle) { + SkPaint* dst = reinterpret_cast<SkPaint*>(dstPaintHandle); + const SkPaint* src = reinterpret_cast<SkPaint*>(srcPaintHandle); *dst = *src; } static jint getFlags(JNIEnv* env, jobject paint) { NPE_CHECK_RETURN_ZERO(env, paint); - return GraphicsJNI::getNativePaint(env, paint)->getFlags(); + int result; + result = GraphicsJNI::getNativePaint(env, paint)->getFlags(); + return static_cast<jint>(result); } static void setFlags(JNIEnv* env, jobject paint, jint flags) { @@ -156,22 +163,29 @@ public: GraphicsJNI::getNativePaint(env, paint)->setDither(dither); } - static jint getStyle(JNIEnv* env, jobject clazz, SkPaint* obj) { - return obj->getStyle(); + static jint getStyle(JNIEnv* env, jobject clazz,jlong objHandle) { + SkPaint* obj = reinterpret_cast<SkPaint*>(objHandle); + return static_cast<jint>(obj->getStyle()); } - static void setStyle(JNIEnv* env, jobject clazz, SkPaint* obj, SkPaint::Style style) { + static void setStyle(JNIEnv* env, jobject clazz, jlong objHandle, jint styleHandle) { + SkPaint* obj = reinterpret_cast<SkPaint*>(objHandle); + SkPaint::Style style = static_cast<SkPaint::Style>(styleHandle); obj->setStyle(style); } static jint getColor(JNIEnv* env, jobject paint) { NPE_CHECK_RETURN_ZERO(env, paint); - return GraphicsJNI::getNativePaint(env, paint)->getColor(); + int color; + color = GraphicsJNI::getNativePaint(env, paint)->getColor(); + return static_cast<jint>(color); } static jint getAlpha(JNIEnv* env, jobject paint) { NPE_CHECK_RETURN_ZERO(env, paint); - return GraphicsJNI::getNativePaint(env, paint)->getAlpha(); + int alpha; + alpha = GraphicsJNI::getNativePaint(env, paint)->getAlpha(); + return static_cast<jint>(alpha); } static void setColor(JNIEnv* env, jobject paint, jint color) { @@ -204,64 +218,90 @@ public: GraphicsJNI::getNativePaint(env, paint)->setStrokeMiter(SkFloatToScalar(miter)); } - static jint getStrokeCap(JNIEnv* env, jobject clazz, SkPaint* obj) { - return obj->getStrokeCap(); + static jint getStrokeCap(JNIEnv* env, jobject clazz, jlong objHandle) { + SkPaint* obj = reinterpret_cast<SkPaint*>(objHandle); + return static_cast<jint>(obj->getStrokeCap()); } - static void setStrokeCap(JNIEnv* env, jobject clazz, SkPaint* obj, SkPaint::Cap cap) { + static void setStrokeCap(JNIEnv* env, jobject clazz, jlong objHandle, jint capHandle) { + SkPaint* obj = reinterpret_cast<SkPaint*>(objHandle); + SkPaint::Cap cap = static_cast<SkPaint::Cap>(capHandle); obj->setStrokeCap(cap); } - static jint getStrokeJoin(JNIEnv* env, jobject clazz, SkPaint* obj) { - return obj->getStrokeJoin(); + static jint getStrokeJoin(JNIEnv* env, jobject clazz, jlong objHandle) { + SkPaint* obj = reinterpret_cast<SkPaint*>(objHandle); + return static_cast<jint>(obj->getStrokeJoin()); } - static void setStrokeJoin(JNIEnv* env, jobject clazz, SkPaint* obj, SkPaint::Join join) { + static void setStrokeJoin(JNIEnv* env, jobject clazz, jlong objHandle, jint joinHandle) { + SkPaint* obj = reinterpret_cast<SkPaint*>(objHandle); + SkPaint::Join join = (SkPaint::Join) joinHandle; obj->setStrokeJoin(join); } - static jboolean getFillPath(JNIEnv* env, jobject clazz, SkPaint* obj, SkPath* src, SkPath* dst) { - return obj->getFillPath(*src, dst); + static jboolean getFillPath(JNIEnv* env, jobject clazz, jlong objHandle, jlong srcHandle, jlong dstHandle) { + SkPaint* obj = reinterpret_cast<SkPaint*>(objHandle); + SkPath* src = reinterpret_cast<SkPath*>(srcHandle); + SkPath* dst = reinterpret_cast<SkPath*>(dstHandle); + return obj->getFillPath(*src, dst) ? JNI_TRUE : JNI_FALSE; } - static SkShader* setShader(JNIEnv* env, jobject clazz, SkPaint* obj, SkShader* shader) { - return obj->setShader(shader); + static jlong setShader(JNIEnv* env, jobject clazz, jlong objHandle, jlong shaderHandle) { + SkPaint* obj = reinterpret_cast<SkPaint*>(objHandle); + SkShader* shader = reinterpret_cast<SkShader*>(shaderHandle); + return reinterpret_cast<jlong>(obj->setShader(shader)); } - static SkColorFilter* setColorFilter(JNIEnv* env, jobject clazz, SkPaint* obj, SkColorFilter* filter) { - return obj->setColorFilter(filter); + static jlong setColorFilter(JNIEnv* env, jobject clazz, jlong objHandle, jlong filterHandle) { + SkPaint* obj = reinterpret_cast<SkPaint *>(objHandle); + SkColorFilter* filter = reinterpret_cast<SkColorFilter *>(filterHandle); + return reinterpret_cast<jlong>(obj->setColorFilter(filter)); } - static SkXfermode* setXfermode(JNIEnv* env, jobject clazz, SkPaint* obj, SkXfermode* xfermode) { - return obj->setXfermode(xfermode); + static jlong setXfermode(JNIEnv* env, jobject clazz, jlong objHandle, jlong xfermodeHandle) { + SkPaint* obj = reinterpret_cast<SkPaint*>(objHandle); + SkXfermode* xfermode = reinterpret_cast<SkXfermode*>(xfermodeHandle); + return reinterpret_cast<jlong>(obj->setXfermode(xfermode)); } - static SkPathEffect* setPathEffect(JNIEnv* env, jobject clazz, SkPaint* obj, SkPathEffect* effect) { - return obj->setPathEffect(effect); + static jlong setPathEffect(JNIEnv* env, jobject clazz, jlong objHandle, jlong effectHandle) { + SkPaint* obj = reinterpret_cast<SkPaint*>(objHandle); + SkPathEffect* effect = reinterpret_cast<SkPathEffect*>(effectHandle); + return reinterpret_cast<jlong>(obj->setPathEffect(effect)); } - static SkMaskFilter* setMaskFilter(JNIEnv* env, jobject clazz, SkPaint* obj, SkMaskFilter* maskfilter) { - return obj->setMaskFilter(maskfilter); + static jlong setMaskFilter(JNIEnv* env, jobject clazz, jlong objHandle, jlong maskfilterHandle) { + SkPaint* obj = reinterpret_cast<SkPaint*>(objHandle); + SkMaskFilter* maskfilter = reinterpret_cast<SkMaskFilter*>(maskfilterHandle); + return reinterpret_cast<jlong>(obj->setMaskFilter(maskfilter)); } - static SkTypeface* setTypeface(JNIEnv* env, jobject clazz, SkPaint* obj, SkTypeface* typeface) { + static jlong setTypeface(JNIEnv* env, jobject clazz, jlong objHandle, jlong typefaceHandle) { #ifndef USE_MINIKIN - return obj->setTypeface(typeface); + SkPaint* obj = reinterpret_cast<SkPaint*>(objHandle); + SkTypeface* typeface = reinterpret_cast<SkTypeface*>(typefaceHandle); + return reinterpret_cast<jlong>(obj->setTypeface(typeface)); #else // TODO(raph): not yet implemented return NULL; #endif } - static SkRasterizer* setRasterizer(JNIEnv* env, jobject clazz, SkPaint* obj, SkRasterizer* rasterizer) { - return obj->setRasterizer(rasterizer); + static jlong setRasterizer(JNIEnv* env, jobject clazz, jlong objHandle, jlong rasterizerHandle) { + SkPaint* obj = reinterpret_cast<SkPaint*>(objHandle); + SkRasterizer* rasterizer = reinterpret_cast<SkRasterizer*>(rasterizerHandle); + return reinterpret_cast<jlong>(obj->setRasterizer(rasterizer)); } - static jint getTextAlign(JNIEnv* env, jobject clazz, SkPaint* obj) { - return obj->getTextAlign(); + static jint getTextAlign(JNIEnv* env, jobject clazz, jlong objHandle) { + SkPaint* obj = reinterpret_cast<SkPaint*>(objHandle); + return static_cast<jint>(obj->getTextAlign()); } - static void setTextAlign(JNIEnv* env, jobject clazz, SkPaint* obj, SkPaint::Align align) { + static void setTextAlign(JNIEnv* env, jobject clazz, jlong objHandle, jint alignHandle) { + SkPaint* obj = reinterpret_cast<SkPaint*>(objHandle); + SkPaint::Align align = static_cast<SkPaint::Align>(alignHandle); obj->setTextAlign(align); } @@ -305,7 +345,8 @@ public: output[0] = '\0'; } - static void setTextLocale(JNIEnv* env, jobject clazz, SkPaint* obj, jstring locale) { + static void setTextLocale(JNIEnv* env, jobject clazz, jlong objHandle, jstring locale) { + SkPaint* obj = reinterpret_cast<SkPaint*>(objHandle); ScopedUtfChars localeChars(env, locale); char langTag[ULOC_FULLNAME_CAPACITY]; toLanguageTag(langTag, ULOC_FULLNAME_CAPACITY, localeChars.c_str()); @@ -395,7 +436,7 @@ public: return descent - ascent + leading; } - static jfloat measureText_CIII(JNIEnv* env, jobject jpaint, jcharArray text, int index, int count, + static jfloat measureText_CIII(JNIEnv* env, jobject jpaint, jcharArray text, jint index, jint count, jint bidiFlags) { NPE_CHECK_RETURN_ZERO(env, jpaint); NPE_CHECK_RETURN_ZERO(env, text); @@ -420,7 +461,7 @@ public: return result; } - static jfloat measureText_StringIII(JNIEnv* env, jobject jpaint, jstring text, int start, int end, + static jfloat measureText_StringIII(JNIEnv* env, jobject jpaint, jstring text, jint start, jint end, jint bidiFlags) { NPE_CHECK_RETURN_ZERO(env, jpaint); NPE_CHECK_RETURN_ZERO(env, text); @@ -493,8 +534,9 @@ public: return count; } - static int getTextWidths___CIII_F(JNIEnv* env, jobject clazz, SkPaint* paint, jcharArray text, - int index, int count, jint bidiFlags, jfloatArray widths) { + static jint getTextWidths___CIII_F(JNIEnv* env, jobject clazz, jlong paintHandle, jcharArray text, + jint index, jint count, jint bidiFlags, jfloatArray widths) { + SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); const jchar* textArray = env->GetCharArrayElements(text, NULL); count = dotextwidths(env, paint, textArray + index, count, widths, bidiFlags); env->ReleaseCharArrayElements(text, const_cast<jchar*>(textArray), @@ -502,8 +544,9 @@ public: return count; } - static int getTextWidths__StringIII_F(JNIEnv* env, jobject clazz, SkPaint* paint, jstring text, - int start, int end, jint bidiFlags, jfloatArray widths) { + static jint getTextWidths__StringIII_F(JNIEnv* env, jobject clazz, jlong paintHandle, jstring text, + jint start, jint end, jint bidiFlags, jfloatArray widths) { + SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); const jchar* textArray = env->GetStringChars(text, NULL); int count = dotextwidths(env, paint, textArray + start, end - start, widths, bidiFlags); env->ReleaseStringChars(text, textArray); @@ -540,9 +583,10 @@ public: return glyphsCount; } - static int getTextGlyphs__StringIIIII_C(JNIEnv* env, jobject clazz, SkPaint* paint, + static jint getTextGlyphs__StringIIIII_C(JNIEnv* env, jobject clazz, jlong paintHandle, jstring text, jint start, jint end, jint contextStart, jint contextEnd, jint flags, jcharArray glyphs) { + SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); const jchar* textArray = env->GetStringChars(text, NULL); int count = doTextGlyphs(env, paint, textArray + contextStart, start - contextStart, end - start, contextEnd - contextStart, flags, glyphs); @@ -582,9 +626,10 @@ public: return totalAdvance; } - static float getTextRunAdvances___CIIIII_FI(JNIEnv* env, jobject clazz, SkPaint* paint, + static jfloat getTextRunAdvances___CIIIII_FI(JNIEnv* env, jobject clazz, jlong paintHandle, jcharArray text, jint index, jint count, jint contextIndex, jint contextCount, jint flags, jfloatArray advances, jint advancesIndex) { + SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); jchar* textArray = env->GetCharArrayElements(text, NULL); jfloat result = doTextRunAdvances(env, paint, textArray + contextIndex, index - contextIndex, count, contextCount, flags, advances, advancesIndex); @@ -592,9 +637,10 @@ public: return result; } - static float getTextRunAdvances__StringIIIII_FI(JNIEnv* env, jobject clazz, SkPaint* paint, + static jfloat getTextRunAdvances__StringIIIII_FI(JNIEnv* env, jobject clazz, jlong paintHandle, jstring text, jint start, jint end, jint contextStart, jint contextEnd, jint flags, jfloatArray advances, jint advancesIndex) { + SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); const jchar* textArray = env->GetStringChars(text, NULL); jfloat result = doTextRunAdvances(env, paint, textArray + contextStart, start - contextStart, end - start, contextEnd - contextStart, flags, @@ -647,8 +693,9 @@ public: return pos; } - static jint getTextRunCursor___C(JNIEnv* env, jobject clazz, SkPaint* paint, jcharArray text, + static jint getTextRunCursor___C(JNIEnv* env, jobject clazz, jlong paintHandle, jcharArray text, jint contextStart, jint contextCount, jint flags, jint offset, jint cursorOpt) { + SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); jchar* textArray = env->GetCharArrayElements(text, NULL); jint result = doTextRunCursor(env, paint, textArray, contextStart, contextCount, flags, offset, cursorOpt); @@ -656,8 +703,9 @@ public: return result; } - static jint getTextRunCursor__String(JNIEnv* env, jobject clazz, SkPaint* paint, jstring text, + static jint getTextRunCursor__String(JNIEnv* env, jobject clazz, jlong paintHandle, jstring text, jint contextStart, jint contextEnd, jint flags, jint offset, jint cursorOpt) { + SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); const jchar* textArray = env->GetStringChars(text, NULL); jint result = doTextRunCursor(env, paint, textArray, contextStart, contextEnd - contextStart, flags, offset, cursorOpt); @@ -670,22 +718,26 @@ public: TextLayout::getTextPath(paint, text, count, bidiFlags, x, y, path); } - static void getTextPath___C(JNIEnv* env, jobject clazz, SkPaint* paint, jint bidiFlags, - jcharArray text, int index, int count, jfloat x, jfloat y, SkPath* path) { + static void getTextPath___C(JNIEnv* env, jobject clazz, jlong paintHandle, jint bidiFlags, + jcharArray text, jint index, jint count, jfloat x, jfloat y, jlong pathHandle) { + SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); + SkPath* path = reinterpret_cast<SkPath*>(pathHandle); const jchar* textArray = env->GetCharArrayElements(text, NULL); getTextPath(env, paint, textArray + index, count, bidiFlags, x, y, path); env->ReleaseCharArrayElements(text, const_cast<jchar*>(textArray), JNI_ABORT); } - static void getTextPath__String(JNIEnv* env, jobject clazz, SkPaint* paint, jint bidiFlags, - jstring text, int start, int end, jfloat x, jfloat y, SkPath* path) { + static void getTextPath__String(JNIEnv* env, jobject clazz, jlong paintHandle, jint bidiFlags, + jstring text, jint start, jint end, jfloat x, jfloat y, jlong pathHandle) { + SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); + SkPath* path = reinterpret_cast<SkPath*>(pathHandle); const jchar* textArray = env->GetStringChars(text, NULL); getTextPath(env, paint, textArray + start, end - start, bidiFlags, x, y, path); env->ReleaseStringChars(text, textArray); } static void setShadowLayer(JNIEnv* env, jobject jpaint, jfloat radius, - jfloat dx, jfloat dy, int color) { + jfloat dx, jfloat dy, jint color) { NPE_CHECK_RETURN_VOID(env, jpaint); SkPaint* paint = GraphicsJNI::getNativePaint(env, jpaint); @@ -721,8 +773,8 @@ public: return bytes >> 1; } - static int breakTextC(JNIEnv* env, jobject jpaint, jcharArray jtext, - int index, int count, float maxWidth, jint bidiFlags, jfloatArray jmeasuredWidth) { + static jint breakTextC(JNIEnv* env, jobject jpaint, jcharArray jtext, + jint index, jint count, jfloat maxWidth, jint bidiFlags, jfloatArray jmeasuredWidth) { NPE_CHECK_RETURN_ZERO(env, jpaint); NPE_CHECK_RETURN_ZERO(env, jtext); @@ -749,8 +801,8 @@ public: return count; } - static int breakTextS(JNIEnv* env, jobject jpaint, jstring jtext, - bool forwards, float maxWidth, jint bidiFlags, jfloatArray jmeasuredWidth) { + static jint breakTextS(JNIEnv* env, jobject jpaint, jstring jtext, + jboolean forwards, jfloat maxWidth, jint bidiFlags, jfloatArray jmeasuredWidth) { NPE_CHECK_RETURN_ZERO(env, jpaint); NPE_CHECK_RETURN_ZERO(env, jtext); @@ -781,15 +833,17 @@ public: GraphicsJNI::irect_to_jrect(ir, env, bounds); } - static void getStringBounds(JNIEnv* env, jobject, const SkPaint* paint, - jstring text, int start, int end, jint bidiFlags, jobject bounds) { + static void getStringBounds(JNIEnv* env, jobject, jlong paintHandle, + jstring text, jint start, jint end, jint bidiFlags, jobject bounds) { + const SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle);; const jchar* textArray = env->GetStringChars(text, NULL); doTextBounds(env, textArray + start, end - start, bounds, *paint, bidiFlags); env->ReleaseStringChars(text, textArray); } - static void getCharArrayBounds(JNIEnv* env, jobject, const SkPaint* paint, - jcharArray text, int index, int count, jint bidiFlags, jobject bounds) { + static void getCharArrayBounds(JNIEnv* env, jobject, jlong paintHandle, + jcharArray text, jint index, jint count, jint bidiFlags, jobject bounds) { + const SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); const jchar* textArray = env->GetCharArrayElements(text, NULL); doTextBounds(env, textArray + index, count, bounds, *paint, bidiFlags); env->ReleaseCharArrayElements(text, const_cast<jchar*>(textArray), @@ -799,11 +853,11 @@ public: }; static JNINativeMethod methods[] = { - {"finalizer", "(I)V", (void*) SkPaintGlue::finalizer}, - {"native_init","()I", (void*) SkPaintGlue::init}, - {"native_initWithPaint","(I)I", (void*) SkPaintGlue::intiWithPaint}, - {"native_reset","(I)V", (void*) SkPaintGlue::reset}, - {"native_set","(II)V", (void*) SkPaintGlue::assign}, + {"finalizer", "(J)V", (void*) SkPaintGlue::finalizer}, + {"native_init","()J", (void*) SkPaintGlue::init}, + {"native_initWithPaint","(J)J", (void*) SkPaintGlue::initWithPaint}, + {"native_reset","(J)V", (void*) SkPaintGlue::reset}, + {"native_set","(JJ)V", (void*) SkPaintGlue::assign}, {"getFlags","()I", (void*) SkPaintGlue::getFlags}, {"setFlags","(I)V", (void*) SkPaintGlue::setFlags}, {"getHinting","()I", (void*) SkPaintGlue::getHinting}, @@ -816,8 +870,8 @@ static JNINativeMethod methods[] = { {"setFakeBoldText","(Z)V", (void*) SkPaintGlue::setFakeBoldText}, {"setFilterBitmap","(Z)V", (void*) SkPaintGlue::setFilterBitmap}, {"setDither","(Z)V", (void*) SkPaintGlue::setDither}, - {"native_getStyle","(I)I", (void*) SkPaintGlue::getStyle}, - {"native_setStyle","(II)V", (void*) SkPaintGlue::setStyle}, + {"native_getStyle","(J)I", (void*) SkPaintGlue::getStyle}, + {"native_setStyle","(JI)V", (void*) SkPaintGlue::setStyle}, {"getColor","()I", (void*) SkPaintGlue::getColor}, {"setColor","(I)V", (void*) SkPaintGlue::setColor}, {"getAlpha","()I", (void*) SkPaintGlue::getAlpha}, @@ -826,21 +880,21 @@ static JNINativeMethod methods[] = { {"setStrokeWidth","(F)V", (void*) SkPaintGlue::setStrokeWidth}, {"getStrokeMiter","()F", (void*) SkPaintGlue::getStrokeMiter}, {"setStrokeMiter","(F)V", (void*) SkPaintGlue::setStrokeMiter}, - {"native_getStrokeCap","(I)I", (void*) SkPaintGlue::getStrokeCap}, - {"native_setStrokeCap","(II)V", (void*) SkPaintGlue::setStrokeCap}, - {"native_getStrokeJoin","(I)I", (void*) SkPaintGlue::getStrokeJoin}, - {"native_setStrokeJoin","(II)V", (void*) SkPaintGlue::setStrokeJoin}, - {"native_getFillPath","(III)Z", (void*) SkPaintGlue::getFillPath}, - {"native_setShader","(II)I", (void*) SkPaintGlue::setShader}, - {"native_setColorFilter","(II)I", (void*) SkPaintGlue::setColorFilter}, - {"native_setXfermode","(II)I", (void*) SkPaintGlue::setXfermode}, - {"native_setPathEffect","(II)I", (void*) SkPaintGlue::setPathEffect}, - {"native_setMaskFilter","(II)I", (void*) SkPaintGlue::setMaskFilter}, - {"native_setTypeface","(II)I", (void*) SkPaintGlue::setTypeface}, - {"native_setRasterizer","(II)I", (void*) SkPaintGlue::setRasterizer}, - {"native_getTextAlign","(I)I", (void*) SkPaintGlue::getTextAlign}, - {"native_setTextAlign","(II)V", (void*) SkPaintGlue::setTextAlign}, - {"native_setTextLocale","(ILjava/lang/String;)V", (void*) SkPaintGlue::setTextLocale}, + {"native_getStrokeCap","(J)I", (void*) SkPaintGlue::getStrokeCap}, + {"native_setStrokeCap","(JI)V", (void*) SkPaintGlue::setStrokeCap}, + {"native_getStrokeJoin","(J)I", (void*) SkPaintGlue::getStrokeJoin}, + {"native_setStrokeJoin","(JI)V", (void*) SkPaintGlue::setStrokeJoin}, + {"native_getFillPath","(JJJ)Z", (void*) SkPaintGlue::getFillPath}, + {"native_setShader","(JJ)J", (void*) SkPaintGlue::setShader}, + {"native_setColorFilter","(JJ)J", (void*) SkPaintGlue::setColorFilter}, + {"native_setXfermode","(JJ)J", (void*) SkPaintGlue::setXfermode}, + {"native_setPathEffect","(JJ)J", (void*) SkPaintGlue::setPathEffect}, + {"native_setMaskFilter","(JJ)J", (void*) SkPaintGlue::setMaskFilter}, + {"native_setTypeface","(JJ)J", (void*) SkPaintGlue::setTypeface}, + {"native_setRasterizer","(JJ)J", (void*) SkPaintGlue::setRasterizer}, + {"native_getTextAlign","(J)I", (void*) SkPaintGlue::getTextAlign}, + {"native_setTextAlign","(JI)V", (void*) SkPaintGlue::setTextAlign}, + {"native_setTextLocale","(JLjava/lang/String;)V", (void*) SkPaintGlue::setTextLocale}, {"getTextSize","()F", (void*) SkPaintGlue::getTextSize}, {"setTextSize","(F)V", (void*) SkPaintGlue::setTextSize}, {"getTextScaleX","()F", (void*) SkPaintGlue::getTextScaleX}, @@ -856,24 +910,24 @@ static JNINativeMethod methods[] = { {"native_measureText","(Ljava/lang/String;III)F", (void*) SkPaintGlue::measureText_StringIII}, {"native_breakText","([CIIFI[F)I", (void*) SkPaintGlue::breakTextC}, {"native_breakText","(Ljava/lang/String;ZFI[F)I", (void*) SkPaintGlue::breakTextS}, - {"native_getTextWidths","(I[CIII[F)I", (void*) SkPaintGlue::getTextWidths___CIII_F}, - {"native_getTextWidths","(ILjava/lang/String;III[F)I", (void*) SkPaintGlue::getTextWidths__StringIII_F}, - {"native_getTextRunAdvances","(I[CIIIII[FI)F", + {"native_getTextWidths","(J[CIII[F)I", (void*) SkPaintGlue::getTextWidths___CIII_F}, + {"native_getTextWidths","(JLjava/lang/String;III[F)I", (void*) SkPaintGlue::getTextWidths__StringIII_F}, + {"native_getTextRunAdvances","(J[CIIIII[FI)F", (void*) SkPaintGlue::getTextRunAdvances___CIIIII_FI}, - {"native_getTextRunAdvances","(ILjava/lang/String;IIIII[FI)F", + {"native_getTextRunAdvances","(JLjava/lang/String;IIIII[FI)F", (void*) SkPaintGlue::getTextRunAdvances__StringIIIII_FI}, - {"native_getTextGlyphs","(ILjava/lang/String;IIIII[C)I", + {"native_getTextGlyphs","(JLjava/lang/String;IIIII[C)I", (void*) SkPaintGlue::getTextGlyphs__StringIIIII_C}, - {"native_getTextRunCursor", "(I[CIIIII)I", (void*) SkPaintGlue::getTextRunCursor___C}, - {"native_getTextRunCursor", "(ILjava/lang/String;IIIII)I", + {"native_getTextRunCursor", "(J[CIIIII)I", (void*) SkPaintGlue::getTextRunCursor___C}, + {"native_getTextRunCursor", "(JLjava/lang/String;IIIII)I", (void*) SkPaintGlue::getTextRunCursor__String}, - {"native_getTextPath","(II[CIIFFI)V", (void*) SkPaintGlue::getTextPath___C}, - {"native_getTextPath","(IILjava/lang/String;IIFFI)V", (void*) SkPaintGlue::getTextPath__String}, - {"nativeGetStringBounds", "(ILjava/lang/String;IIILandroid/graphics/Rect;)V", + {"native_getTextPath","(JI[CIIFFJ)V", (void*) SkPaintGlue::getTextPath___C}, + {"native_getTextPath","(JILjava/lang/String;IIFFJ)V", (void*) SkPaintGlue::getTextPath__String}, + {"nativeGetStringBounds", "(JLjava/lang/String;IIILandroid/graphics/Rect;)V", (void*) SkPaintGlue::getStringBounds }, - {"nativeGetCharArrayBounds", "(I[CIIILandroid/graphics/Rect;)V", + {"nativeGetCharArrayBounds", "(J[CIIILandroid/graphics/Rect;)V", (void*) SkPaintGlue::getCharArrayBounds }, {"nSetShadowLayer", "(FFFI)V", (void*)SkPaintGlue::setShadowLayer} }; diff --git a/core/jni/android/graphics/Path.cpp b/core/jni/android/graphics/Path.cpp index 2126ed4..c4d728f 100644 --- a/core/jni/android/graphics/Path.cpp +++ b/core/jni/android/graphics/Path.cpp @@ -36,7 +36,8 @@ namespace android { class SkPathGlue { public: - static void finalizer(JNIEnv* env, jobject clazz, SkPath* obj) { + static void finalizer(JNIEnv* env, jobject clazz, jlong objHandle) { + SkPath* obj = reinterpret_cast<SkPath*>(objHandle); #ifdef USE_OPENGL_RENDERER if (android::uirenderer::Caches::hasInstance()) { android::uirenderer::Caches::getInstance().resourceCache.destructor(obj); @@ -46,79 +47,96 @@ public: delete obj; } - static SkPath* init1(JNIEnv* env, jobject clazz) { - return new SkPath(); + static jlong init1(JNIEnv* env, jobject clazz) { + return reinterpret_cast<jlong>(new SkPath()); } - - static SkPath* init2(JNIEnv* env, jobject clazz, SkPath* val) { - return new SkPath(*val); + + static jlong init2(JNIEnv* env, jobject clazz, jlong valHandle) { + SkPath* val = reinterpret_cast<SkPath*>(valHandle); + return reinterpret_cast<jlong>(new SkPath(*val)); } - - static void reset(JNIEnv* env, jobject clazz, SkPath* obj) { + + static void reset(JNIEnv* env, jobject clazz, jlong objHandle) { + SkPath* obj = reinterpret_cast<SkPath*>(objHandle); obj->reset(); } - static void rewind(JNIEnv* env, jobject clazz, SkPath* obj) { + static void rewind(JNIEnv* env, jobject clazz, jlong objHandle) { + SkPath* obj = reinterpret_cast<SkPath*>(objHandle); obj->rewind(); } - static void assign(JNIEnv* env, jobject clazz, SkPath* dst, const SkPath* src) { + static void assign(JNIEnv* env, jobject clazz, jlong dstHandle, jlong srcHandle) { + SkPath* dst = reinterpret_cast<SkPath*>(dstHandle); + const SkPath* src = reinterpret_cast<SkPath*>(srcHandle); *dst = *src; } - - static jint getFillType(JNIEnv* env, jobject clazz, SkPath* obj) { + + static jint getFillType(JNIEnv* env, jobject clazz, jlong objHandle) { + SkPath* obj = reinterpret_cast<SkPath*>(objHandle); return obj->getFillType(); } - static void setFillType(JNIEnv* env, jobject clazz, SkPath* path, SkPath::FillType ft) { + static void setFillType(JNIEnv* env, jobject clazz, jlong pathHandle, jint ftHandle) { + SkPath* path = reinterpret_cast<SkPath*>(pathHandle); + SkPath::FillType ft = static_cast<SkPath::FillType>(ftHandle); path->setFillType(ft); } - - static jboolean isEmpty(JNIEnv* env, jobject clazz, SkPath* obj) { + + static jboolean isEmpty(JNIEnv* env, jobject clazz, jlong objHandle) { + SkPath* obj = reinterpret_cast<SkPath*>(objHandle); return obj->isEmpty(); } - static jboolean isRect(JNIEnv* env, jobject clazz, SkPath* obj, jobject rect) { + static jboolean isRect(JNIEnv* env, jobject clazz, jlong objHandle, jobject rect) { SkRect rect_; + SkPath* obj = reinterpret_cast<SkPath*>(objHandle); jboolean result = obj->isRect(&rect_); GraphicsJNI::rect_to_jrectf(rect_, env, rect); return result; } - static void computeBounds(JNIEnv* env, jobject clazz, SkPath* obj, jobject bounds) { + static void computeBounds(JNIEnv* env, jobject clazz, jlong objHandle, jobject bounds) { + SkPath* obj = reinterpret_cast<SkPath*>(objHandle); const SkRect& bounds_ = obj->getBounds(); GraphicsJNI::rect_to_jrectf(bounds_, env, bounds); } - static void incReserve(JNIEnv* env, jobject clazz, SkPath* obj, jint extraPtCount) { + static void incReserve(JNIEnv* env, jobject clazz, jlong objHandle, jint extraPtCount) { + SkPath* obj = reinterpret_cast<SkPath*>(objHandle); obj->incReserve(extraPtCount); } - static void moveTo__FF(JNIEnv* env, jobject clazz, SkPath* obj, jfloat x, jfloat y) { + static void moveTo__FF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat x, jfloat y) { + SkPath* obj = reinterpret_cast<SkPath*>(objHandle); SkScalar x_ = SkFloatToScalar(x); SkScalar y_ = SkFloatToScalar(y); obj->moveTo(x_, y_); } - static void rMoveTo(JNIEnv* env, jobject clazz, SkPath* obj, jfloat dx, jfloat dy) { + static void rMoveTo(JNIEnv* env, jobject clazz, jlong objHandle, jfloat dx, jfloat dy) { + SkPath* obj = reinterpret_cast<SkPath*>(objHandle); SkScalar dx_ = SkFloatToScalar(dx); SkScalar dy_ = SkFloatToScalar(dy); obj->rMoveTo(dx_, dy_); } - static void lineTo__FF(JNIEnv* env, jobject clazz, SkPath* obj, jfloat x, jfloat y) { + static void lineTo__FF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat x, jfloat y) { + SkPath* obj = reinterpret_cast<SkPath*>(objHandle); SkScalar x_ = SkFloatToScalar(x); SkScalar y_ = SkFloatToScalar(y); obj->lineTo(x_, y_); } - static void rLineTo(JNIEnv* env, jobject clazz, SkPath* obj, jfloat dx, jfloat dy) { + static void rLineTo(JNIEnv* env, jobject clazz, jlong objHandle, jfloat dx, jfloat dy) { + SkPath* obj = reinterpret_cast<SkPath*>(objHandle); SkScalar dx_ = SkFloatToScalar(dx); SkScalar dy_ = SkFloatToScalar(dy); obj->rLineTo(dx_, dy_); } - static void quadTo__FFFF(JNIEnv* env, jobject clazz, SkPath* obj, jfloat x1, jfloat y1, jfloat x2, jfloat y2) { + static void quadTo__FFFF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat x1, jfloat y1, jfloat x2, jfloat y2) { + SkPath* obj = reinterpret_cast<SkPath*>(objHandle); SkScalar x1_ = SkFloatToScalar(x1); SkScalar y1_ = SkFloatToScalar(y1); SkScalar x2_ = SkFloatToScalar(x2); @@ -126,7 +144,8 @@ public: obj->quadTo(x1_, y1_, x2_, y2_); } - static void rQuadTo(JNIEnv* env, jobject clazz, SkPath* obj, jfloat dx1, jfloat dy1, jfloat dx2, jfloat dy2) { + static void rQuadTo(JNIEnv* env, jobject clazz, jlong objHandle, jfloat dx1, jfloat dy1, jfloat dx2, jfloat dy2) { + SkPath* obj = reinterpret_cast<SkPath*>(objHandle); SkScalar dx1_ = SkFloatToScalar(dx1); SkScalar dy1_ = SkFloatToScalar(dy1); SkScalar dx2_ = SkFloatToScalar(dx2); @@ -134,7 +153,8 @@ public: obj->rQuadTo(dx1_, dy1_, dx2_, dy2_); } - static void cubicTo__FFFFFF(JNIEnv* env, jobject clazz, SkPath* obj, jfloat x1, jfloat y1, jfloat x2, jfloat y2, jfloat x3, jfloat y3) { + static void cubicTo__FFFFFF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat x1, jfloat y1, jfloat x2, jfloat y2, jfloat x3, jfloat y3) { + SkPath* obj = reinterpret_cast<SkPath*>(objHandle); SkScalar x1_ = SkFloatToScalar(x1); SkScalar y1_ = SkFloatToScalar(y1); SkScalar x2_ = SkFloatToScalar(x2); @@ -144,7 +164,8 @@ public: obj->cubicTo(x1_, y1_, x2_, y2_, x3_, y3_); } - static void rCubicTo(JNIEnv* env, jobject clazz, SkPath* obj, jfloat x1, jfloat y1, jfloat x2, jfloat y2, jfloat x3, jfloat y3) { + static void rCubicTo(JNIEnv* env, jobject clazz, jlong objHandle, jfloat x1, jfloat y1, jfloat x2, jfloat y2, jfloat x3, jfloat y3) { + SkPath* obj = reinterpret_cast<SkPath*>(objHandle); SkScalar x1_ = SkFloatToScalar(x1); SkScalar y1_ = SkFloatToScalar(y1); SkScalar x2_ = SkFloatToScalar(x2); @@ -154,7 +175,8 @@ public: obj->rCubicTo(x1_, y1_, x2_, y2_, x3_, y3_); } - static void arcTo(JNIEnv* env, jobject clazz, SkPath* obj, jobject oval, jfloat startAngle, jfloat sweepAngle, jboolean forceMoveTo) { + static void arcTo(JNIEnv* env, jobject clazz, jlong objHandle, jobject oval, jfloat startAngle, jfloat sweepAngle, jboolean forceMoveTo) { + SkPath* obj = reinterpret_cast<SkPath*>(objHandle); SkRect oval_; GraphicsJNI::jrectf_to_rect(env, oval, &oval_); SkScalar startAngle_ = SkFloatToScalar(startAngle); @@ -162,17 +184,22 @@ public: obj->arcTo(oval_, startAngle_, sweepAngle_, forceMoveTo); } - static void close(JNIEnv* env, jobject clazz, SkPath* obj) { + static void close(JNIEnv* env, jobject clazz, jlong objHandle) { + SkPath* obj = reinterpret_cast<SkPath*>(objHandle); obj->close(); } - static void addRect__RectFI(JNIEnv* env, jobject clazz, SkPath* obj, jobject rect, SkPath::Direction dir) { + static void addRect__RectFI(JNIEnv* env, jobject clazz, jlong objHandle, jobject rect, jint dirHandle) { SkRect rect_; + SkPath* obj = reinterpret_cast<SkPath*>(objHandle); + SkPath::Direction dir = static_cast<SkPath::Direction>(dirHandle); GraphicsJNI::jrectf_to_rect(env, rect, &rect_); obj->addRect(rect_, dir); } - static void addRect__FFFFI(JNIEnv* env, jobject clazz, SkPath* obj, jfloat left, jfloat top, jfloat right, jfloat bottom, SkPath::Direction dir) { + static void addRect__FFFFI(JNIEnv* env, jobject clazz, jlong objHandle, jfloat left, jfloat top, jfloat right, jfloat bottom, jint dirHandle) { + SkPath* obj = reinterpret_cast<SkPath*>(objHandle); + SkPath::Direction dir = static_cast<SkPath::Direction>(dirHandle); SkScalar left_ = SkFloatToScalar(left); SkScalar top_ = SkFloatToScalar(top); SkScalar right_ = SkFloatToScalar(right); @@ -180,39 +207,48 @@ public: obj->addRect(left_, top_, right_, bottom_, dir); } - static void addOval(JNIEnv* env, jobject clazz, SkPath* obj, jobject oval, SkPath::Direction dir) { + static void addOval(JNIEnv* env, jobject clazz, jlong objHandle, jobject oval, jint dirHandle) { + SkPath* obj = reinterpret_cast<SkPath*>(objHandle); + SkPath::Direction dir = static_cast<SkPath::Direction>(dirHandle); SkRect oval_; GraphicsJNI::jrectf_to_rect(env, oval, &oval_); obj->addOval(oval_, dir); } - static void addCircle(JNIEnv* env, jobject clazz, SkPath* obj, jfloat x, jfloat y, jfloat radius, SkPath::Direction dir) { + static void addCircle(JNIEnv* env, jobject clazz, jlong objHandle, jfloat x, jfloat y, jfloat radius, jint dirHandle) { + SkPath* obj = reinterpret_cast<SkPath*>(objHandle); + SkPath::Direction dir = static_cast<SkPath::Direction>(dirHandle); SkScalar x_ = SkFloatToScalar(x); SkScalar y_ = SkFloatToScalar(y); SkScalar radius_ = SkFloatToScalar(radius); obj->addCircle(x_, y_, radius_, dir); } - static void addArc(JNIEnv* env, jobject clazz, SkPath* obj, jobject oval, jfloat startAngle, jfloat sweepAngle) { + static void addArc(JNIEnv* env, jobject clazz, jlong objHandle, jobject oval, jfloat startAngle, jfloat sweepAngle) { SkRect oval_; + SkPath* obj = reinterpret_cast<SkPath*>(objHandle); GraphicsJNI::jrectf_to_rect(env, oval, &oval_); SkScalar startAngle_ = SkFloatToScalar(startAngle); SkScalar sweepAngle_ = SkFloatToScalar(sweepAngle); obj->addArc(oval_, startAngle_, sweepAngle_); } - static void addRoundRectXY(JNIEnv* env, jobject clazz, SkPath* obj, jobject rect, - jfloat rx, jfloat ry, SkPath::Direction dir) { + static void addRoundRectXY(JNIEnv* env, jobject clazz, jlong objHandle, jobject rect, + jfloat rx, jfloat ry, jint dirHandle) { SkRect rect_; + SkPath* obj = reinterpret_cast<SkPath*>(objHandle); + SkPath::Direction dir = static_cast<SkPath::Direction>(dirHandle); GraphicsJNI::jrectf_to_rect(env, rect, &rect_); SkScalar rx_ = SkFloatToScalar(rx); SkScalar ry_ = SkFloatToScalar(ry); obj->addRoundRect(rect_, rx_, ry_, dir); } - static void addRoundRect8(JNIEnv* env, jobject, SkPath* obj, jobject rect, - jfloatArray array, SkPath::Direction dir) { + static void addRoundRect8(JNIEnv* env, jobject, jlong objHandle, jobject rect, + jfloatArray array, jint dirHandle) { SkRect rect_; + SkPath* obj = reinterpret_cast<SkPath*>(objHandle); + SkPath::Direction dir = static_cast<SkPath::Direction>(dirHandle); GraphicsJNI::jrectf_to_rect(env, rect, &rect_); AutoJavaFloatArray afa(env, array, 8); const float* src = afa.ptr(); @@ -224,48 +260,68 @@ public: obj->addRoundRect(rect_, dst, dir); } - static void addPath__PathFF(JNIEnv* env, jobject clazz, SkPath* obj, SkPath* src, jfloat dx, jfloat dy) { + static void addPath__PathFF(JNIEnv* env, jobject clazz, jlong objHandle, jlong srcHandle, jfloat dx, jfloat dy) { + SkPath* obj = reinterpret_cast<SkPath*>(objHandle); + SkPath* src = reinterpret_cast<SkPath*>(srcHandle); SkScalar dx_ = SkFloatToScalar(dx); SkScalar dy_ = SkFloatToScalar(dy); obj->addPath(*src, dx_, dy_); } - static void addPath__Path(JNIEnv* env, jobject clazz, SkPath* obj, SkPath* src) { + static void addPath__Path(JNIEnv* env, jobject clazz, jlong objHandle, jlong srcHandle) { + SkPath* obj = reinterpret_cast<SkPath*>(objHandle); + SkPath* src = reinterpret_cast<SkPath*>(srcHandle); obj->addPath(*src); } - static void addPath__PathMatrix(JNIEnv* env, jobject clazz, SkPath* obj, SkPath* src, SkMatrix* matrix) { + static void addPath__PathMatrix(JNIEnv* env, jobject clazz, jlong objHandle, jlong srcHandle, jlong matrixHandle) { + SkPath* obj = reinterpret_cast<SkPath*>(objHandle); + SkPath* src = reinterpret_cast<SkPath*>(srcHandle); + SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle); obj->addPath(*src, *matrix); } - static void offset__FFPath(JNIEnv* env, jobject clazz, SkPath* obj, jfloat dx, jfloat dy, SkPath* dst) { + static void offset__FFPath(JNIEnv* env, jobject clazz, jlong objHandle, jfloat dx, jfloat dy, jlong dstHandle) { + SkPath* obj = reinterpret_cast<SkPath*>(objHandle); + SkPath* dst = reinterpret_cast<SkPath*>(dstHandle); SkScalar dx_ = SkFloatToScalar(dx); SkScalar dy_ = SkFloatToScalar(dy); obj->offset(dx_, dy_, dst); } - static void offset__FF(JNIEnv* env, jobject clazz, SkPath* obj, jfloat dx, jfloat dy) { + static void offset__FF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat dx, jfloat dy) { + SkPath* obj = reinterpret_cast<SkPath*>(objHandle); SkScalar dx_ = SkFloatToScalar(dx); SkScalar dy_ = SkFloatToScalar(dy); obj->offset(dx_, dy_); } - static void setLastPoint(JNIEnv* env, jobject clazz, SkPath* obj, jfloat dx, jfloat dy) { + static void setLastPoint(JNIEnv* env, jobject clazz, jlong objHandle, jfloat dx, jfloat dy) { + SkPath* obj = reinterpret_cast<SkPath*>(objHandle); SkScalar dx_ = SkFloatToScalar(dx); SkScalar dy_ = SkFloatToScalar(dy); obj->setLastPt(dx_, dy_); } - static void transform__MatrixPath(JNIEnv* env, jobject clazz, SkPath* obj, SkMatrix* matrix, SkPath* dst) { + static void transform__MatrixPath(JNIEnv* env, jobject clazz, jlong objHandle, jlong matrixHandle, jlong dstHandle) { + SkPath* obj = reinterpret_cast<SkPath*>(objHandle); + SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle); + SkPath* dst = reinterpret_cast<SkPath*>(dstHandle); obj->transform(*matrix, dst); } - static void transform__Matrix(JNIEnv* env, jobject clazz, SkPath* obj, SkMatrix* matrix) { + static void transform__Matrix(JNIEnv* env, jobject clazz, jlong objHandle, jlong matrixHandle) { + SkPath* obj = reinterpret_cast<SkPath*>(objHandle); + SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle); obj->transform(*matrix); } - static jboolean op(JNIEnv* env, jobject clazz, SkPath* p1, SkPath* p2, SkPathOp op, SkPath* r) { - return Op(*p1, *p2, op, r); + static jboolean op(JNIEnv* env, jobject clazz, jlong p1Handle, jlong p2Handle, jint opHandle, jlong rHandle) { + SkPath* p1 = reinterpret_cast<SkPath*>(p1Handle); + SkPath* p2 = reinterpret_cast<SkPath*>(p2Handle); + SkPathOp op = static_cast<SkPathOp>(opHandle); + SkPath* r = reinterpret_cast<SkPath*>(rHandle); + return Op(*p1, *p2, op, r); } typedef SkPoint (*bezierCalculation)(float t, const SkPoint* points); @@ -421,8 +477,9 @@ public: // Note that more than one point may have the same length along the path in // the case of a move. // NULL can be returned if the Path is empty. - static jfloatArray approximate(JNIEnv* env, jclass, SkPath* path, float acceptableError) + static jfloatArray approximate(JNIEnv* env, jclass, jlong pathHandle, float acceptableError) { + SkPath* path = reinterpret_cast<SkPath*>(pathHandle); SkASSERT(path); SkPath::Iter pathIter(*path, false); SkPath::Verb verb; @@ -459,8 +516,11 @@ public: return result; } - static SkPathMeasure* trim(JNIEnv* env, jobject clazz, SkPath* inPath, SkPath* outPath, - SkPathMeasure* pathMeasure, jfloat trimStart, jfloat trimEnd, jfloat trimOffset) { + static SkPathMeasure* trim(JNIEnv* env, jobject clazz, jlong inPathPtr, jlong outPathPtr, + jlong pathMeasurePtr, jfloat trimStart, jfloat trimEnd, jfloat trimOffset) { + SkPath* inPath = reinterpret_cast<SkPath*>(inPathPtr); + SkPath* outPath = reinterpret_cast<SkPath*>(outPathPtr); + SkPathMeasure* pathMeasure = reinterpret_cast<SkPathMeasure*>(pathMeasurePtr); if (trimStart == 0 && trimEnd == 1) { if (outPath != NULL) { *outPath = *inPath; @@ -500,53 +560,53 @@ public: return pathMeasure; } - static void destroyMeasure(JNIEnv* env, jobject clazz, SkPathMeasure* measure) { - delete measure; + static void destroyMeasure(JNIEnv* env, jobject clazz, jlong measure) { + delete reinterpret_cast<SkPathMeasure*>(measure); } }; static JNINativeMethod methods[] = { - {"finalizer", "(I)V", (void*) SkPathGlue::finalizer}, - {"init1","()I", (void*) SkPathGlue::init1}, - {"init2","(I)I", (void*) SkPathGlue::init2}, - {"native_reset","(I)V", (void*) SkPathGlue::reset}, - {"native_rewind","(I)V", (void*) SkPathGlue::rewind}, - {"native_set","(II)V", (void*) SkPathGlue::assign}, - {"native_getFillType","(I)I", (void*) SkPathGlue::getFillType}, - {"native_setFillType","(II)V", (void*) SkPathGlue::setFillType}, - {"native_isEmpty","(I)Z", (void*) SkPathGlue::isEmpty}, - {"native_isRect","(ILandroid/graphics/RectF;)Z", (void*) SkPathGlue::isRect}, - {"native_computeBounds","(ILandroid/graphics/RectF;)V", (void*) SkPathGlue::computeBounds}, - {"native_incReserve","(II)V", (void*) SkPathGlue::incReserve}, - {"native_moveTo","(IFF)V", (void*) SkPathGlue::moveTo__FF}, - {"native_rMoveTo","(IFF)V", (void*) SkPathGlue::rMoveTo}, - {"native_lineTo","(IFF)V", (void*) SkPathGlue::lineTo__FF}, - {"native_rLineTo","(IFF)V", (void*) SkPathGlue::rLineTo}, - {"native_quadTo","(IFFFF)V", (void*) SkPathGlue::quadTo__FFFF}, - {"native_rQuadTo","(IFFFF)V", (void*) SkPathGlue::rQuadTo}, - {"native_cubicTo","(IFFFFFF)V", (void*) SkPathGlue::cubicTo__FFFFFF}, - {"native_rCubicTo","(IFFFFFF)V", (void*) SkPathGlue::rCubicTo}, - {"native_arcTo","(ILandroid/graphics/RectF;FFZ)V", (void*) SkPathGlue::arcTo}, - {"native_close","(I)V", (void*) SkPathGlue::close}, - {"native_addRect","(ILandroid/graphics/RectF;I)V", (void*) SkPathGlue::addRect__RectFI}, - {"native_addRect","(IFFFFI)V", (void*) SkPathGlue::addRect__FFFFI}, - {"native_addOval","(ILandroid/graphics/RectF;I)V", (void*) SkPathGlue::addOval}, - {"native_addCircle","(IFFFI)V", (void*) SkPathGlue::addCircle}, - {"native_addArc","(ILandroid/graphics/RectF;FF)V", (void*) SkPathGlue::addArc}, - {"native_addRoundRect","(ILandroid/graphics/RectF;FFI)V", (void*) SkPathGlue::addRoundRectXY}, - {"native_addRoundRect","(ILandroid/graphics/RectF;[FI)V", (void*) SkPathGlue::addRoundRect8}, - {"native_addPath","(IIFF)V", (void*) SkPathGlue::addPath__PathFF}, - {"native_addPath","(II)V", (void*) SkPathGlue::addPath__Path}, - {"native_addPath","(III)V", (void*) SkPathGlue::addPath__PathMatrix}, - {"native_offset","(IFFI)V", (void*) SkPathGlue::offset__FFPath}, - {"native_offset","(IFF)V", (void*) SkPathGlue::offset__FF}, - {"native_setLastPoint","(IFF)V", (void*) SkPathGlue::setLastPoint}, - {"native_transform","(III)V", (void*) SkPathGlue::transform__MatrixPath}, - {"native_transform","(II)V", (void*) SkPathGlue::transform__Matrix}, - {"native_op","(IIII)Z", (void*) SkPathGlue::op}, - {"native_approximate", "(IF)[F", (void*) SkPathGlue::approximate}, - {"native_destroyMeasure","(I)V", (void*) SkPathGlue::destroyMeasure}, - {"native_trim","(IIIFFF)I", (void*) SkPathGlue::trim}, + {"finalizer", "(J)V", (void*) SkPathGlue::finalizer}, + {"init1","()J", (void*) SkPathGlue::init1}, + {"init2","(J)J", (void*) SkPathGlue::init2}, + {"native_reset","(J)V", (void*) SkPathGlue::reset}, + {"native_rewind","(J)V", (void*) SkPathGlue::rewind}, + {"native_set","(JJ)V", (void*) SkPathGlue::assign}, + {"native_getFillType","(J)I", (void*) SkPathGlue::getFillType}, + {"native_setFillType","(JI)V", (void*) SkPathGlue::setFillType}, + {"native_isEmpty","(J)Z", (void*) SkPathGlue::isEmpty}, + {"native_isRect","(JLandroid/graphics/RectF;)Z", (void*) SkPathGlue::isRect}, + {"native_computeBounds","(JLandroid/graphics/RectF;)V", (void*) SkPathGlue::computeBounds}, + {"native_incReserve","(JI)V", (void*) SkPathGlue::incReserve}, + {"native_moveTo","(JFF)V", (void*) SkPathGlue::moveTo__FF}, + {"native_rMoveTo","(JFF)V", (void*) SkPathGlue::rMoveTo}, + {"native_lineTo","(JFF)V", (void*) SkPathGlue::lineTo__FF}, + {"native_rLineTo","(JFF)V", (void*) SkPathGlue::rLineTo}, + {"native_quadTo","(JFFFF)V", (void*) SkPathGlue::quadTo__FFFF}, + {"native_rQuadTo","(JFFFF)V", (void*) SkPathGlue::rQuadTo}, + {"native_cubicTo","(JFFFFFF)V", (void*) SkPathGlue::cubicTo__FFFFFF}, + {"native_rCubicTo","(JFFFFFF)V", (void*) SkPathGlue::rCubicTo}, + {"native_arcTo","(JLandroid/graphics/RectF;FFZ)V", (void*) SkPathGlue::arcTo}, + {"native_close","(J)V", (void*) SkPathGlue::close}, + {"native_addRect","(JLandroid/graphics/RectF;I)V", (void*) SkPathGlue::addRect__RectFI}, + {"native_addRect","(JFFFFI)V", (void*) SkPathGlue::addRect__FFFFI}, + {"native_addOval","(JLandroid/graphics/RectF;I)V", (void*) SkPathGlue::addOval}, + {"native_addCircle","(JFFFI)V", (void*) SkPathGlue::addCircle}, + {"native_addArc","(JLandroid/graphics/RectF;FF)V", (void*) SkPathGlue::addArc}, + {"native_addRoundRect","(JLandroid/graphics/RectF;FFI)V", (void*) SkPathGlue::addRoundRectXY}, + {"native_addRoundRect","(JLandroid/graphics/RectF;[FI)V", (void*) SkPathGlue::addRoundRect8}, + {"native_addPath","(JJFF)V", (void*) SkPathGlue::addPath__PathFF}, + {"native_addPath","(JJ)V", (void*) SkPathGlue::addPath__Path}, + {"native_addPath","(JJJ)V", (void*) SkPathGlue::addPath__PathMatrix}, + {"native_offset","(JFFJ)V", (void*) SkPathGlue::offset__FFPath}, + {"native_offset","(JFF)V", (void*) SkPathGlue::offset__FF}, + {"native_setLastPoint","(JFF)V", (void*) SkPathGlue::setLastPoint}, + {"native_transform","(JJJ)V", (void*) SkPathGlue::transform__MatrixPath}, + {"native_transform","(JJ)V", (void*) SkPathGlue::transform__Matrix}, + {"native_op","(JJIJ)Z", (void*) SkPathGlue::op}, + {"native_approximate", "(JF)[F", (void*) SkPathGlue::approximate}, + {"native_destroyMeasure","(J)V", (void*) SkPathGlue::destroyMeasure}, + {"native_trim","(JJJFFF)I", (void*) SkPathGlue::trim}, }; int register_android_graphics_Path(JNIEnv* env) { diff --git a/core/jni/android/graphics/PathEffect.cpp b/core/jni/android/graphics/PathEffect.cpp index 0503614..2803758 100644 --- a/core/jni/android/graphics/PathEffect.cpp +++ b/core/jni/android/graphics/PathEffect.cpp @@ -11,22 +11,29 @@ class SkPathEffectGlue { public: - static void destructor(JNIEnv* env, jobject, SkPathEffect* effect) { + static void destructor(JNIEnv* env, jobject, jlong effectHandle) { + SkPathEffect* effect = reinterpret_cast<SkPathEffect*>(effectHandle); SkSafeUnref(effect); } - static SkPathEffect* Compose_constructor(JNIEnv* env, jobject, - SkPathEffect* outer, SkPathEffect* inner) { - return new SkComposePathEffect(outer, inner); + static jlong Compose_constructor(JNIEnv* env, jobject, + jlong outerHandle, jlong innerHandle) { + SkPathEffect* outer = reinterpret_cast<SkPathEffect*>(outerHandle); + SkPathEffect* inner = reinterpret_cast<SkPathEffect*>(innerHandle); + SkPathEffect* effect = new SkComposePathEffect(outer, inner); + return reinterpret_cast<jlong>(effect); } - static SkPathEffect* Sum_constructor(JNIEnv* env, jobject, - SkPathEffect* first, SkPathEffect* second) { - return new SkSumPathEffect(first, second); + static jlong Sum_constructor(JNIEnv* env, jobject, + jlong firstHandle, jlong secondHandle) { + SkPathEffect* first = reinterpret_cast<SkPathEffect*>(firstHandle); + SkPathEffect* second = reinterpret_cast<SkPathEffect*>(secondHandle); + SkPathEffect* effect = new SkSumPathEffect(first, second); + return reinterpret_cast<jlong>(effect); } - static SkPathEffect* Dash_constructor(JNIEnv* env, jobject, - jfloatArray intervalArray, float phase) { + static jlong Dash_constructor(JNIEnv* env, jobject, + jfloatArray intervalArray, jfloat phase) { AutoJavaFloatArray autoInterval(env, intervalArray); int count = autoInterval.length() & ~1; // even number float* values = autoInterval.ptr(); @@ -36,24 +43,29 @@ public: for (int i = 0; i < count; i++) { intervals[i] = SkFloatToScalar(values[i]); } - return new SkDashPathEffect(intervals, count, SkFloatToScalar(phase)); + SkPathEffect* effect = new SkDashPathEffect(intervals, count, SkFloatToScalar(phase)); + return reinterpret_cast<jlong>(effect); } - static SkPathEffect* OneD_constructor(JNIEnv* env, jobject, - const SkPath* shape, float advance, float phase, int style) { + static jlong OneD_constructor(JNIEnv* env, jobject, + jlong shapeHandle, jfloat advance, jfloat phase, jint style) { + const SkPath* shape = reinterpret_cast<SkPath*>(shapeHandle); SkASSERT(shape != NULL); - return new SkPath1DPathEffect(*shape, SkFloatToScalar(advance), + SkPathEffect* effect = new SkPath1DPathEffect(*shape, SkFloatToScalar(advance), SkFloatToScalar(phase), (SkPath1DPathEffect::Style)style); + return reinterpret_cast<jlong>(effect); } - static SkPathEffect* Corner_constructor(JNIEnv* env, jobject, float radius){ - return new SkCornerPathEffect(SkFloatToScalar(radius)); + static jlong Corner_constructor(JNIEnv* env, jobject, jfloat radius){ + SkPathEffect* effect = new SkCornerPathEffect(SkFloatToScalar(radius)); + return reinterpret_cast<jlong>(effect); } - static SkPathEffect* Discrete_constructor(JNIEnv* env, jobject, - float length, float deviation) { - return new SkDiscretePathEffect(SkFloatToScalar(length), + static jlong Discrete_constructor(JNIEnv* env, jobject, + jfloat length, jfloat deviation) { + SkPathEffect* effect = new SkDiscretePathEffect(SkFloatToScalar(length), SkFloatToScalar(deviation)); + return reinterpret_cast<jlong>(effect); } }; @@ -61,31 +73,31 @@ public: //////////////////////////////////////////////////////////////////////////////////////////////////////// static JNINativeMethod gPathEffectMethods[] = { - { "nativeDestructor", "(I)V", (void*)SkPathEffectGlue::destructor } + { "nativeDestructor", "(J)V", (void*)SkPathEffectGlue::destructor } }; static JNINativeMethod gComposePathEffectMethods[] = { - { "nativeCreate", "(II)I", (void*)SkPathEffectGlue::Compose_constructor } + { "nativeCreate", "(JJ)J", (void*)SkPathEffectGlue::Compose_constructor } }; static JNINativeMethod gSumPathEffectMethods[] = { - { "nativeCreate", "(II)I", (void*)SkPathEffectGlue::Sum_constructor } + { "nativeCreate", "(JJ)J", (void*)SkPathEffectGlue::Sum_constructor } }; static JNINativeMethod gDashPathEffectMethods[] = { - { "nativeCreate", "([FF)I", (void*)SkPathEffectGlue::Dash_constructor } + { "nativeCreate", "([FF)J", (void*)SkPathEffectGlue::Dash_constructor } }; static JNINativeMethod gPathDashPathEffectMethods[] = { - { "nativeCreate", "(IFFI)I", (void*)SkPathEffectGlue::OneD_constructor } + { "nativeCreate", "(JFFI)J", (void*)SkPathEffectGlue::OneD_constructor } }; static JNINativeMethod gCornerPathEffectMethods[] = { - { "nativeCreate", "(F)I", (void*)SkPathEffectGlue::Corner_constructor } + { "nativeCreate", "(F)J", (void*)SkPathEffectGlue::Corner_constructor } }; static JNINativeMethod gDiscretePathEffectMethods[] = { - { "nativeCreate", "(FF)I", (void*)SkPathEffectGlue::Discrete_constructor } + { "nativeCreate", "(FF)J", (void*)SkPathEffectGlue::Discrete_constructor } }; #include <android_runtime/AndroidRuntime.h> diff --git a/core/jni/android/graphics/Picture.cpp b/core/jni/android/graphics/Picture.cpp index fcf22b8..bac8ef7 100644 --- a/core/jni/android/graphics/Picture.cpp +++ b/core/jni/android/graphics/Picture.cpp @@ -28,71 +28,80 @@ namespace android { class SkPictureGlue { public: - static SkPicture* newPicture(JNIEnv* env, jobject, const SkPicture* src) { + static jlong newPicture(JNIEnv* env, jobject, jlong srcHandle) { + const SkPicture* src = reinterpret_cast<SkPicture*>(srcHandle); if (src) { - return new SkPicture(*src); + return reinterpret_cast<jlong>(new SkPicture(*src)); } else { - return new SkPicture; + return reinterpret_cast<jlong>(new SkPicture); } } - - static SkPicture* deserialize(JNIEnv* env, jobject, jobject jstream, - jbyteArray jstorage) { + + static jlong deserialize(JNIEnv* env, jobject, jobject jstream, + jbyteArray jstorage) { SkPicture* picture = NULL; SkStream* strm = CreateJavaInputStreamAdaptor(env, jstream, jstorage); if (strm) { picture = SkPicture::CreateFromStream(strm); delete strm; } - return picture; + return reinterpret_cast<jlong>(picture); } - - static void killPicture(JNIEnv* env, jobject, SkPicture* picture) { + + static void killPicture(JNIEnv* env, jobject, jlong pictureHandle) { + SkPicture* picture = reinterpret_cast<SkPicture*>(pictureHandle); SkASSERT(picture); picture->unref(); } - - static void draw(JNIEnv* env, jobject, SkCanvas* canvas, - SkPicture* picture) { + + static void draw(JNIEnv* env, jobject, jlong canvasHandle, + jlong pictureHandle) { + SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle); + SkPicture* picture = reinterpret_cast<SkPicture*>(pictureHandle); SkASSERT(canvas); SkASSERT(picture); picture->draw(canvas); } - - static bool serialize(JNIEnv* env, jobject, SkPicture* picture, + + static jboolean serialize(JNIEnv* env, jobject, jlong pictureHandle, jobject jstream, jbyteArray jstorage) { + SkPicture* picture = reinterpret_cast<SkPicture*>(pictureHandle); SkWStream* strm = CreateJavaOutputStreamAdaptor(env, jstream, jstorage); if (NULL != strm) { picture->serialize(strm); delete strm; - return true; + return JNI_TRUE; } - return false; + return JNI_FALSE; } - - static int getWidth(JNIEnv* env, jobject jpic) { + + static jint getWidth(JNIEnv* env, jobject jpic) { NPE_CHECK_RETURN_ZERO(env, jpic); - return GraphicsJNI::getNativePicture(env, jpic)->width(); + int width = GraphicsJNI::getNativePicture(env, jpic)->width(); + return static_cast<jint>(width); } - - static int getHeight(JNIEnv* env, jobject jpic) { + + static jint getHeight(JNIEnv* env, jobject jpic) { NPE_CHECK_RETURN_ZERO(env, jpic); - return GraphicsJNI::getNativePicture(env, jpic)->height(); + int height = GraphicsJNI::getNativePicture(env, jpic)->height(); + return static_cast<jint>(height); } - - static SkCanvas* beginRecording(JNIEnv* env, jobject, SkPicture* pict, - int w, int h) { + + static jlong beginRecording(JNIEnv* env, jobject, jlong pictHandle, + jint w, jint h) { + SkPicture* pict = reinterpret_cast<SkPicture*>(pictHandle); // beginRecording does not ref its return value, it just returns it. SkCanvas* canvas = pict->beginRecording(w, h); // the java side will wrap this guy in a Canvas.java, which will call // unref in its finalizer, so we have to ref it here, so that both that // Canvas.java and our picture can both be owners canvas->ref(); - return canvas; + return reinterpret_cast<jlong>(canvas); } - - static void endRecording(JNIEnv* env, jobject, SkPicture* pict) { + + static void endRecording(JNIEnv* env, jobject, jlong pictHandle) { + SkPicture* pict = reinterpret_cast<SkPicture*>(pictHandle); pict->endRecording(); } }; @@ -100,30 +109,30 @@ public: static JNINativeMethod gPictureMethods[] = { {"getWidth", "()I", (void*) SkPictureGlue::getWidth}, {"getHeight", "()I", (void*) SkPictureGlue::getHeight}, - {"nativeConstructor", "(I)I", (void*) SkPictureGlue::newPicture}, - {"nativeCreateFromStream", "(Ljava/io/InputStream;[B)I", (void*)SkPictureGlue::deserialize}, - {"nativeBeginRecording", "(III)I", (void*) SkPictureGlue::beginRecording}, - {"nativeEndRecording", "(I)V", (void*) SkPictureGlue::endRecording}, - {"nativeDraw", "(II)V", (void*) SkPictureGlue::draw}, - {"nativeWriteToStream", "(ILjava/io/OutputStream;[B)Z", (void*)SkPictureGlue::serialize}, - {"nativeDestructor","(I)V", (void*) SkPictureGlue::killPicture} + {"nativeConstructor", "(J)J", (void*) SkPictureGlue::newPicture}, + {"nativeCreateFromStream", "(Ljava/io/InputStream;[B)J", (void*)SkPictureGlue::deserialize}, + {"nativeBeginRecording", "(JII)J", (void*) SkPictureGlue::beginRecording}, + {"nativeEndRecording", "(J)V", (void*) SkPictureGlue::endRecording}, + {"nativeDraw", "(JJ)V", (void*) SkPictureGlue::draw}, + {"nativeWriteToStream", "(JLjava/io/OutputStream;[B)Z", (void*)SkPictureGlue::serialize}, + {"nativeDestructor","(J)V", (void*) SkPictureGlue::killPicture} }; #include <android_runtime/AndroidRuntime.h> - + #define REG(env, name, array) \ result = android::AndroidRuntime::registerNativeMethods(env, name, array, \ SK_ARRAY_COUNT(array)); \ if (result < 0) return result - + int register_android_graphics_Picture(JNIEnv* env) { int result; - + REG(env, "android/graphics/Picture", gPictureMethods); - + return result; } - + } diff --git a/core/jni/android/graphics/PorterDuff.cpp b/core/jni/android/graphics/PorterDuff.cpp index 47de601..8a49eb5 100644 --- a/core/jni/android/graphics/PorterDuff.cpp +++ b/core/jni/android/graphics/PorterDuff.cpp @@ -31,15 +31,15 @@ namespace android { class SkPorterDuffGlue { public: - static SkXfermode* CreateXfermode(JNIEnv* env, jobject, - SkPorterDuff::Mode mode) { - return SkPorterDuff::CreateXfermode(mode); + static jlong CreateXfermode(JNIEnv* env, jobject, jint modeHandle) { + SkPorterDuff::Mode mode = static_cast<SkPorterDuff::Mode>(modeHandle); + return reinterpret_cast<jlong>(SkPorterDuff::CreateXfermode(mode)); } }; static JNINativeMethod methods[] = { - {"nativeCreateXfermode","(I)I", (void*) SkPorterDuffGlue::CreateXfermode}, + {"nativeCreateXfermode","(I)J", (void*) SkPorterDuffGlue::CreateXfermode}, }; int register_android_graphics_PorterDuff(JNIEnv* env) { diff --git a/core/jni/android/graphics/Rasterizer.cpp b/core/jni/android/graphics/Rasterizer.cpp index 4e1b36a..b6450d0 100644 --- a/core/jni/android/graphics/Rasterizer.cpp +++ b/core/jni/android/graphics/Rasterizer.cpp @@ -31,14 +31,15 @@ namespace android { class SkRasterizerGlue { public: - static void finalizer(JNIEnv* env, jobject clazz, SkRasterizer* obj) { + static void finalizer(JNIEnv* env, jobject clazz, jlong objHandle) { + SkRasterizer* obj = reinterpret_cast<SkRasterizer *>(objHandle); SkSafeUnref(obj); } }; static JNINativeMethod methods[] = { - {"finalizer", "(I)V", (void*) SkRasterizerGlue::finalizer} + {"finalizer", "(J)V", (void*) SkRasterizerGlue::finalizer} }; int register_android_graphics_Rasterizer(JNIEnv* env) { diff --git a/core/jni/android/graphics/Region.cpp b/core/jni/android/graphics/Region.cpp index ded2186..bcf1273 100644 --- a/core/jni/android/graphics/Region.cpp +++ b/core/jni/android/graphics/Region.cpp @@ -29,95 +29,131 @@ namespace android { static jfieldID gRegion_nativeInstanceFieldID; +static inline jboolean boolTojboolean(bool value) { + return value ? JNI_TRUE : JNI_FALSE; +} + static inline SkRegion* GetSkRegion(JNIEnv* env, jobject regionObject) { - SkRegion* rgn = (SkRegion*)env->GetIntField(regionObject, gRegion_nativeInstanceFieldID); - SkASSERT(rgn != NULL); - return rgn; + jlong regionHandle = env->GetLongField(regionObject, gRegion_nativeInstanceFieldID); + SkRegion* region = reinterpret_cast<SkRegion*>(regionHandle); + SkASSERT(region != NULL); + return region; } -static SkRegion* Region_constructor(JNIEnv* env, jobject) { - return new SkRegion; +static jlong Region_constructor(JNIEnv* env, jobject) { + return reinterpret_cast<jlong>(new SkRegion); } -static void Region_destructor(JNIEnv* env, jobject, SkRegion* region) { +static void Region_destructor(JNIEnv* env, jobject, jlong regionHandle) { + SkRegion* region = reinterpret_cast<SkRegion*>(regionHandle); SkASSERT(region); delete region; } -static void Region_setRegion(JNIEnv* env, jobject, SkRegion* dst, const SkRegion* src) { +static void Region_setRegion(JNIEnv* env, jobject, jlong dstHandle, jlong srcHandle) { + SkRegion* dst = reinterpret_cast<SkRegion*>(dstHandle); + const SkRegion* src = reinterpret_cast<SkRegion*>(srcHandle); SkASSERT(dst && src); *dst = *src; } -static jboolean Region_setRect(JNIEnv* env, jobject, SkRegion* dst, int left, int top, int right, int bottom) { - return dst->setRect(left, top, right, bottom); +static jboolean Region_setRect(JNIEnv* env, jobject, jlong dstHandle, jint left, jint top, jint right, jint bottom) { + SkRegion* dst = reinterpret_cast<SkRegion*>(dstHandle); + bool result = dst->setRect(left, top, right, bottom); + return boolTojboolean(result); } -static jboolean Region_setPath(JNIEnv* env, jobject, SkRegion* dst, - const SkPath* path, const SkRegion* clip) { +static jboolean Region_setPath(JNIEnv* env, jobject, jlong dstHandle, + jlong pathHandle, jlong clipHandle) { + SkRegion* dst = reinterpret_cast<SkRegion*>(dstHandle); + const SkPath* path = reinterpret_cast<SkPath*>(pathHandle); + const SkRegion* clip = reinterpret_cast<SkRegion*>(clipHandle); SkASSERT(dst && path && clip); - return dst->setPath(*path, *clip); + bool result = dst->setPath(*path, *clip); + return boolTojboolean(result); + } -static jboolean Region_getBounds(JNIEnv* env, jobject, SkRegion* region, jobject rectBounds) { +static jboolean Region_getBounds(JNIEnv* env, jobject, jlong regionHandle, jobject rectBounds) { + SkRegion* region = reinterpret_cast<SkRegion*>(regionHandle); GraphicsJNI::irect_to_jrect(region->getBounds(), env, rectBounds); - return !region->isEmpty(); + bool result = !region->isEmpty(); + return boolTojboolean(result); } -static jboolean Region_getBoundaryPath(JNIEnv* env, jobject, const SkRegion* region, SkPath* path) { - return region->getBoundaryPath(path); +static jboolean Region_getBoundaryPath(JNIEnv* env, jobject, jlong regionHandle, jlong pathHandle) { + const SkRegion* region = reinterpret_cast<SkRegion*>(regionHandle); + SkPath* path = reinterpret_cast<SkPath*>(pathHandle); + bool result = region->getBoundaryPath(path); + return boolTojboolean(result); } -static jboolean Region_op0(JNIEnv* env, jobject, SkRegion* dst, int left, int top, int right, int bottom, int op) { +static jboolean Region_op0(JNIEnv* env, jobject, jlong dstHandle, jint left, jint top, jint right, jint bottom, jint op) { + SkRegion* dst = reinterpret_cast<SkRegion*>(dstHandle); SkIRect ir; ir.set(left, top, right, bottom); - return dst->op(ir, (SkRegion::Op)op); + bool result = dst->op(ir, (SkRegion::Op)op); + return boolTojboolean(result); } -static jboolean Region_op1(JNIEnv* env, jobject, SkRegion* dst, jobject rectObject, const SkRegion* region, int op) { +static jboolean Region_op1(JNIEnv* env, jobject, jlong dstHandle, jobject rectObject, jlong regionHandle, jint op) { + SkRegion* dst = reinterpret_cast<SkRegion*>(dstHandle); + const SkRegion* region = reinterpret_cast<SkRegion*>(regionHandle); SkIRect ir; GraphicsJNI::jrect_to_irect(env, rectObject, &ir); - return dst->op(ir, *region, (SkRegion::Op)op); + bool result = dst->op(ir, *region, (SkRegion::Op)op); + return boolTojboolean(result); } -static jboolean Region_op2(JNIEnv* env, jobject, SkRegion* dst, const SkRegion* region1, const SkRegion* region2, int op) { - return dst->op(*region1, *region2, (SkRegion::Op)op); +static jboolean Region_op2(JNIEnv* env, jobject, jlong dstHandle, jlong region1Handle, jlong region2Handle, jint op) { + SkRegion* dst = reinterpret_cast<SkRegion*>(dstHandle); + const SkRegion* region1 = reinterpret_cast<SkRegion*>(region1Handle); + const SkRegion* region2 = reinterpret_cast<SkRegion*>(region2Handle); + bool result = dst->op(*region1, *region2, (SkRegion::Op)op); + return boolTojboolean(result); } //////////////////////////////////// These are methods, not static static jboolean Region_isEmpty(JNIEnv* env, jobject region) { - return GetSkRegion(env, region)->isEmpty(); + bool result = GetSkRegion(env, region)->isEmpty(); + return boolTojboolean(result); } static jboolean Region_isRect(JNIEnv* env, jobject region) { - return GetSkRegion(env, region)->isRect(); + bool result = GetSkRegion(env, region)->isRect(); + return boolTojboolean(result); } static jboolean Region_isComplex(JNIEnv* env, jobject region) { - return GetSkRegion(env, region)->isComplex(); + bool result = GetSkRegion(env, region)->isComplex(); + return boolTojboolean(result); } -static jboolean Region_contains(JNIEnv* env, jobject region, int x, int y) { - return GetSkRegion(env, region)->contains(x, y); +static jboolean Region_contains(JNIEnv* env, jobject region, jint x, jint y) { + bool result = GetSkRegion(env, region)->contains(x, y); + return boolTojboolean(result); } -static jboolean Region_quickContains(JNIEnv* env, jobject region, int left, int top, int right, int bottom) { - return GetSkRegion(env, region)->quickContains(left, top, right, bottom); +static jboolean Region_quickContains(JNIEnv* env, jobject region, jint left, jint top, jint right, jint bottom) { + bool result = GetSkRegion(env, region)->quickContains(left, top, right, bottom); + return boolTojboolean(result); } -static jboolean Region_quickRejectIIII(JNIEnv* env, jobject region, int left, int top, int right, int bottom) { +static jboolean Region_quickRejectIIII(JNIEnv* env, jobject region, jint left, jint top, jint right, jint bottom) { SkIRect ir; ir.set(left, top, right, bottom); - return GetSkRegion(env, region)->quickReject(ir); + bool result = GetSkRegion(env, region)->quickReject(ir); + return boolTojboolean(result); } static jboolean Region_quickRejectRgn(JNIEnv* env, jobject region, jobject other) { - return GetSkRegion(env, region)->quickReject(*GetSkRegion(env, other)); + bool result = GetSkRegion(env, region)->quickReject(*GetSkRegion(env, other)); + return boolTojboolean(result); } -static void Region_translate(JNIEnv* env, jobject region, int x, int y, jobject dst) { +static void Region_translate(JNIEnv* env, jobject region, jint x, jint y, jobject dst) { SkRegion* rgn = GetSkRegion(env, region); if (dst) rgn->translate(x, y, GetSkRegion(env, dst)); @@ -155,7 +191,8 @@ static void Region_scale(JNIEnv* env, jobject region, jfloat scale, jobject dst) scale_rgn(rgn, *rgn, scale); } -static jstring Region_toString(JNIEnv* env, jobject clazz, SkRegion* region) { +static jstring Region_toString(JNIEnv* env, jobject clazz, jlong regionHandle) { + SkRegion* region = reinterpret_cast<SkRegion*>(regionHandle); char* str = region->toString(); if (str == NULL) { return NULL; @@ -167,7 +204,7 @@ static jstring Region_toString(JNIEnv* env, jobject clazz, SkRegion* region) { //////////////////////////////////////////////////////////////////////////////////////////////////////////// -static SkRegion* Region_createFromParcel(JNIEnv* env, jobject clazz, jobject parcel) +static jlong Region_createFromParcel(JNIEnv* env, jobject clazz, jobject parcel) { if (parcel == NULL) { return NULL; @@ -179,13 +216,14 @@ static SkRegion* Region_createFromParcel(JNIEnv* env, jobject clazz, jobject par size_t size = p->readInt32(); region->readFromMemory(p->readInplace(size)); - return region; + return reinterpret_cast<jlong>(region); } -static jboolean Region_writeToParcel(JNIEnv* env, jobject clazz, const SkRegion* region, jobject parcel) +static jboolean Region_writeToParcel(JNIEnv* env, jobject clazz, jlong regionHandle, jobject parcel) { + const SkRegion* region = reinterpret_cast<SkRegion*>(regionHandle); if (parcel == NULL) { - return false; + return JNI_FALSE; } android::Parcel* p = android::parcelForJavaObject(env, parcel); @@ -194,14 +232,16 @@ static jboolean Region_writeToParcel(JNIEnv* env, jobject clazz, const SkRegion* p->writeInt32(size); region->writeToMemory(p->writeInplace(size)); - return true; + return JNI_TRUE; } //////////////////////////////////////////////////////////////////////////////////////////////////////////// -static jboolean Region_equals(JNIEnv* env, jobject clazz, const SkRegion *r1, const SkRegion* r2) +static jboolean Region_equals(JNIEnv* env, jobject clazz, jlong r1Handle, jlong r2Handle) { - return (jboolean) (*r1 == *r2); + const SkRegion *r1 = reinterpret_cast<SkRegion*>(r1Handle); + const SkRegion *r2 = reinterpret_cast<SkRegion*>(r2Handle); + return boolTojboolean(*r1 == *r2); } //////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -217,20 +257,23 @@ struct RgnIterPair { } }; -static RgnIterPair* RegionIter_constructor(JNIEnv* env, jobject, const SkRegion* region) +static jlong RegionIter_constructor(JNIEnv* env, jobject, jlong regionHandle) { + const SkRegion* region = reinterpret_cast<SkRegion*>(regionHandle); SkASSERT(region); - return new RgnIterPair(*region); + return reinterpret_cast<jlong>(new RgnIterPair(*region)); } -static void RegionIter_destructor(JNIEnv* env, jobject, RgnIterPair* pair) +static void RegionIter_destructor(JNIEnv* env, jobject, jlong pairHandle) { + RgnIterPair* pair = reinterpret_cast<RgnIterPair*>(pairHandle); SkASSERT(pair); delete pair; } -static jboolean RegionIter_next(JNIEnv* env, jobject, RgnIterPair* pair, jobject rectObject) +static jboolean RegionIter_next(JNIEnv* env, jobject, jlong pairHandle, jobject rectObject) { + RgnIterPair* pair = reinterpret_cast<RgnIterPair*>(pairHandle); // the caller has checked that rectObject is not nul SkASSERT(pair); SkASSERT(rectObject); @@ -238,31 +281,31 @@ static jboolean RegionIter_next(JNIEnv* env, jobject, RgnIterPair* pair, jobject if (!pair->fIter.done()) { GraphicsJNI::irect_to_jrect(pair->fIter.rect(), env, rectObject); pair->fIter.next(); - return true; + return JNI_TRUE; } - return false; + return JNI_FALSE; } //////////////////////////////////////////////////////////////////////////////////////////////////////////// static JNINativeMethod gRegionIterMethods[] = { - { "nativeConstructor", "(I)I", (void*)RegionIter_constructor }, - { "nativeDestructor", "(I)V", (void*)RegionIter_destructor }, - { "nativeNext", "(ILandroid/graphics/Rect;)Z", (void*)RegionIter_next } + { "nativeConstructor", "(J)J", (void*)RegionIter_constructor }, + { "nativeDestructor", "(J)V", (void*)RegionIter_destructor }, + { "nativeNext", "(JLandroid/graphics/Rect;)Z", (void*)RegionIter_next } }; static JNINativeMethod gRegionMethods[] = { // these are static methods - { "nativeConstructor", "()I", (void*)Region_constructor }, - { "nativeDestructor", "(I)V", (void*)Region_destructor }, - { "nativeSetRegion", "(II)V", (void*)Region_setRegion }, - { "nativeSetRect", "(IIIII)Z", (void*)Region_setRect }, - { "nativeSetPath", "(III)Z", (void*)Region_setPath }, - { "nativeGetBounds", "(ILandroid/graphics/Rect;)Z", (void*)Region_getBounds }, - { "nativeGetBoundaryPath", "(II)Z", (void*)Region_getBoundaryPath }, - { "nativeOp", "(IIIIII)Z", (void*)Region_op0 }, - { "nativeOp", "(ILandroid/graphics/Rect;II)Z", (void*)Region_op1 }, - { "nativeOp", "(IIII)Z", (void*)Region_op2 }, + { "nativeConstructor", "()J", (void*)Region_constructor }, + { "nativeDestructor", "(J)V", (void*)Region_destructor }, + { "nativeSetRegion", "(JJ)V", (void*)Region_setRegion }, + { "nativeSetRect", "(JIIII)Z", (void*)Region_setRect }, + { "nativeSetPath", "(JJJ)Z", (void*)Region_setPath }, + { "nativeGetBounds", "(JLandroid/graphics/Rect;)Z", (void*)Region_getBounds }, + { "nativeGetBoundaryPath", "(JJ)Z", (void*)Region_getBoundaryPath }, + { "nativeOp", "(JIIIII)Z", (void*)Region_op0 }, + { "nativeOp", "(JLandroid/graphics/Rect;JI)Z", (void*)Region_op1 }, + { "nativeOp", "(JJJI)Z", (void*)Region_op2 }, // these are methods that take the java region object { "isEmpty", "()Z", (void*)Region_isEmpty }, { "isRect", "()Z", (void*)Region_isRect }, @@ -273,11 +316,11 @@ static JNINativeMethod gRegionMethods[] = { { "quickReject", "(Landroid/graphics/Region;)Z", (void*)Region_quickRejectRgn }, { "scale", "(FLandroid/graphics/Region;)V", (void*)Region_scale }, { "translate", "(IILandroid/graphics/Region;)V", (void*)Region_translate }, - { "nativeToString", "(I)Ljava/lang/String;", (void*)Region_toString }, + { "nativeToString", "(J)Ljava/lang/String;", (void*)Region_toString }, // parceling methods - { "nativeCreateFromParcel", "(Landroid/os/Parcel;)I", (void*)Region_createFromParcel }, - { "nativeWriteToParcel", "(ILandroid/os/Parcel;)Z", (void*)Region_writeToParcel }, - { "nativeEquals", "(II)Z", (void*)Region_equals }, + { "nativeCreateFromParcel", "(Landroid/os/Parcel;)J", (void*)Region_createFromParcel }, + { "nativeWriteToParcel", "(JLandroid/os/Parcel;)Z", (void*)Region_writeToParcel }, + { "nativeEquals", "(JJ)Z", (void*)Region_equals }, }; int register_android_graphics_Region(JNIEnv* env) @@ -285,7 +328,7 @@ int register_android_graphics_Region(JNIEnv* env) jclass clazz = env->FindClass("android/graphics/Region"); SkASSERT(clazz); - gRegion_nativeInstanceFieldID = env->GetFieldID(clazz, "mNativeRegion", "I"); + gRegion_nativeInstanceFieldID = env->GetFieldID(clazz, "mNativeRegion", "J"); SkASSERT(gRegion_nativeInstanceFieldID); int result = android::AndroidRuntime::registerNativeMethods(env, "android/graphics/Region", diff --git a/core/jni/android/graphics/Shader.cpp b/core/jni/android/graphics/Shader.cpp index 6323ab3..3047440 100644 --- a/core/jni/android/graphics/Shader.cpp +++ b/core/jni/android/graphics/Shader.cpp @@ -24,7 +24,7 @@ static void ThrowIAE_IfNull(JNIEnv* env, void* ptr) { } } -static void Color_RGBToHSV(JNIEnv* env, jobject, int red, int green, int blue, jfloatArray hsvArray) +static void Color_RGBToHSV(JNIEnv* env, jobject, jint red, jint green, jint blue, jfloatArray hsvArray) { SkScalar hsv[3]; SkRGBToHSV(red, green, blue, hsv); @@ -36,7 +36,7 @@ static void Color_RGBToHSV(JNIEnv* env, jobject, int red, int green, int blue, j } } -static int Color_HSVToColor(JNIEnv* env, jobject, int alpha, jfloatArray hsvArray) +static jint Color_HSVToColor(JNIEnv* env, jobject, jint alpha, jfloatArray hsvArray) { AutoJavaFloatArray autoHSV(env, hsvArray, 3); float* values = autoHSV.ptr();; @@ -46,13 +46,15 @@ static int Color_HSVToColor(JNIEnv* env, jobject, int alpha, jfloatArray hsvArra hsv[i] = SkFloatToScalar(values[i]); } - return SkHSVToColor(alpha, hsv); + return static_cast<jint>(SkHSVToColor(alpha, hsv)); } /////////////////////////////////////////////////////////////////////////////////////////////// -static void Shader_destructor(JNIEnv* env, jobject o, SkShader* shader, SkiaShader* skiaShader) +static void Shader_destructor(JNIEnv* env, jobject o, jlong shaderHandle, jlong skiaShaderHandle) { + SkShader* shader = reinterpret_cast<SkShader*>(shaderHandle); + SkiaShader* skiaShader = reinterpret_cast<SkiaShader*>(skiaShaderHandle); SkSafeUnref(shader); // skiaShader == NULL when not !USE_OPENGL_RENDERER, so no need to delete it outside the ifdef #ifdef USE_OPENGL_RENDERER @@ -64,9 +66,12 @@ static void Shader_destructor(JNIEnv* env, jobject o, SkShader* shader, SkiaShad #endif } -static void Shader_setLocalMatrix(JNIEnv* env, jobject o, SkShader* shader, SkiaShader* skiaShader, - const SkMatrix* matrix) +static void Shader_setLocalMatrix(JNIEnv* env, jobject o, jlong shaderHandle, + jlong skiaShaderHandle, jlong matrixHandle) { + SkShader* shader = reinterpret_cast<SkShader*>(shaderHandle); + SkiaShader* skiaShader = reinterpret_cast<SkiaShader*>(skiaShaderHandle); + const SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle); if (shader) { if (NULL == matrix) { shader->resetLocalMatrix(); @@ -82,24 +87,27 @@ static void Shader_setLocalMatrix(JNIEnv* env, jobject o, SkShader* shader, Skia /////////////////////////////////////////////////////////////////////////////////////////////// -static SkShader* BitmapShader_constructor(JNIEnv* env, jobject o, const SkBitmap* bitmap, - int tileModeX, int tileModeY) +static jlong BitmapShader_constructor(JNIEnv* env, jobject o, jlong bitmapHandle, + jint tileModeX, jint tileModeY) { + const SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle); SkShader* s = SkShader::CreateBitmapShader(*bitmap, (SkShader::TileMode)tileModeX, (SkShader::TileMode)tileModeY); ThrowIAE_IfNull(env, s); - return s; + return reinterpret_cast<jlong>(s); } -static SkiaShader* BitmapShader_postConstructor(JNIEnv* env, jobject o, SkShader* shader, - SkBitmap* bitmap, int tileModeX, int tileModeY) { +static jlong BitmapShader_postConstructor(JNIEnv* env, jobject o, jlong shaderHandle, + jlong bitmapHandle, jint tileModeX, jint tileModeY) { + SkShader* shader = reinterpret_cast<SkShader*>(shaderHandle); + SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle); #ifdef USE_OPENGL_RENDERER SkiaShader* skiaShader = new SkiaBitmapShader(bitmap, shader, static_cast<SkShader::TileMode>(tileModeX), static_cast<SkShader::TileMode>(tileModeY), NULL, (shader->getFlags() & SkShader::kOpaqueAlpha_Flag) == 0); - return skiaShader; + return reinterpret_cast<jlong>(skiaShader); #else return NULL; #endif @@ -107,9 +115,9 @@ static SkiaShader* BitmapShader_postConstructor(JNIEnv* env, jobject o, SkShader /////////////////////////////////////////////////////////////////////////////////////////////// -static SkShader* LinearGradient_create1(JNIEnv* env, jobject o, - float x0, float y0, float x1, float y1, - jintArray colorArray, jfloatArray posArray, int tileMode) +static jlong LinearGradient_create1(JNIEnv* env, jobject o, + jfloat x0, jfloat y0, jfloat x1, jfloat y1, + jintArray colorArray, jfloatArray posArray, jint tileMode) { SkPoint pts[2]; pts[0].set(SkFloatToScalar(x0), SkFloatToScalar(y0)); @@ -137,13 +145,14 @@ static SkShader* LinearGradient_create1(JNIEnv* env, jobject o, env->ReleaseIntArrayElements(colorArray, const_cast<jint*>(colorValues), JNI_ABORT); ThrowIAE_IfNull(env, shader); - return shader; + return reinterpret_cast<jlong>(shader); } -static SkiaShader* LinearGradient_postCreate1(JNIEnv* env, jobject o, SkShader* shader, - float x0, float y0, float x1, float y1, jintArray colorArray, - jfloatArray posArray, int tileMode) { +static jlong LinearGradient_postCreate1(JNIEnv* env, jobject o, jlong shaderHandle, + jfloat x0, jfloat y0, jfloat x1, jfloat y1, jintArray colorArray, + jfloatArray posArray, jint tileMode) { #ifdef USE_OPENGL_RENDERER + SkShader* shader = reinterpret_cast<SkShader*>(shaderHandle); size_t count = env->GetArrayLength(colorArray); const jint* colorValues = env->GetIntArrayElements(colorArray, NULL); @@ -206,15 +215,16 @@ static SkiaShader* LinearGradient_postCreate1(JNIEnv* env, jobject o, SkShader* (shader->getFlags() & SkShader::kOpaqueAlpha_Flag) == 0); env->ReleaseIntArrayElements(colorArray, const_cast<jint*>(colorValues), JNI_ABORT); - return skiaShader; + return reinterpret_cast<jlong>(skiaShader); #else return NULL; #endif } -static SkiaShader* LinearGradient_postCreate2(JNIEnv* env, jobject o, SkShader* shader, - float x0, float y0, float x1, float y1, int color0, int color1, int tileMode) { +static jlong LinearGradient_postCreate2(JNIEnv* env, jobject o, jlong shaderHandle, + jfloat x0, jfloat y0, jfloat x1, jfloat y1, jint color0, jint color1, jint tileMode) { #ifdef USE_OPENGL_RENDERER + SkShader* shader = reinterpret_cast<SkShader*>(shaderHandle); float* storedBounds = new float[4]; storedBounds[0] = x0; storedBounds[1] = y0; storedBounds[2] = x1; storedBounds[3] = y1; @@ -231,15 +241,15 @@ static SkiaShader* LinearGradient_postCreate2(JNIEnv* env, jobject o, SkShader* storedPositions, 2, shader, static_cast<SkShader::TileMode>(tileMode), NULL, (shader->getFlags() & SkShader::kOpaqueAlpha_Flag) == 0); - return skiaShader; + return reinterpret_cast<jlong>(skiaShader); #else return NULL; #endif } -static SkShader* LinearGradient_create2(JNIEnv* env, jobject o, - float x0, float y0, float x1, float y1, - int color0, int color1, int tileMode) +static jlong LinearGradient_create2(JNIEnv* env, jobject o, + jfloat x0, jfloat y0, jfloat x1, jfloat y1, + jint color0, jint color1, jint tileMode) { SkPoint pts[2]; pts[0].set(SkFloatToScalar(x0), SkFloatToScalar(y0)); @@ -252,13 +262,13 @@ static SkShader* LinearGradient_create2(JNIEnv* env, jobject o, SkShader* s = SkGradientShader::CreateLinear(pts, colors, NULL, 2, (SkShader::TileMode)tileMode); ThrowIAE_IfNull(env, s); - return s; + return reinterpret_cast<jlong>(s); } /////////////////////////////////////////////////////////////////////////////////////////////// -static SkShader* RadialGradient_create1(JNIEnv* env, jobject, float x, float y, float radius, - jintArray colorArray, jfloatArray posArray, int tileMode) { +static jlong RadialGradient_create1(JNIEnv* env, jobject, jfloat x, jfloat y, jfloat radius, + jintArray colorArray, jfloatArray posArray, jint tileMode) { SkPoint center; center.set(SkFloatToScalar(x), SkFloatToScalar(y)); @@ -285,11 +295,11 @@ static SkShader* RadialGradient_create1(JNIEnv* env, jobject, float x, float y, JNI_ABORT); ThrowIAE_IfNull(env, shader); - return shader; + return reinterpret_cast<jlong>(shader); } -static SkShader* RadialGradient_create2(JNIEnv* env, jobject, float x, float y, float radius, - int color0, int color1, int tileMode) { +static jlong RadialGradient_create2(JNIEnv* env, jobject, jfloat x, jfloat y, jfloat radius, + jint color0, jint color1, jint tileMode) { SkPoint center; center.set(SkFloatToScalar(x), SkFloatToScalar(y)); @@ -300,12 +310,13 @@ static SkShader* RadialGradient_create2(JNIEnv* env, jobject, float x, float y, SkShader* s = SkGradientShader::CreateRadial(center, SkFloatToScalar(radius), colors, NULL, 2, (SkShader::TileMode)tileMode); ThrowIAE_IfNull(env, s); - return s; + return reinterpret_cast<jlong>(s); } -static SkiaShader* RadialGradient_postCreate1(JNIEnv* env, jobject o, SkShader* shader, - float x, float y, float radius, jintArray colorArray, jfloatArray posArray, int tileMode) { +static jlong RadialGradient_postCreate1(JNIEnv* env, jobject o, jlong shaderHandle, + jfloat x, jfloat y, jfloat radius, jintArray colorArray, jfloatArray posArray, jint tileMode) { #ifdef USE_OPENGL_RENDERER + SkShader* shader = reinterpret_cast<SkShader*>(shaderHandle); size_t count = env->GetArrayLength(colorArray); const jint* colorValues = env->GetIntArrayElements(colorArray, NULL); @@ -335,15 +346,16 @@ static SkiaShader* RadialGradient_postCreate1(JNIEnv* env, jobject o, SkShader* (shader->getFlags() & SkShader::kOpaqueAlpha_Flag) == 0); env->ReleaseIntArrayElements(colorArray, const_cast<jint*>(colorValues), JNI_ABORT); - return skiaShader; + return reinterpret_cast<jlong>(skiaShader); #else return NULL; #endif } -static SkiaShader* RadialGradient_postCreate2(JNIEnv* env, jobject o, SkShader* shader, - float x, float y, float radius, int color0, int color1, int tileMode) { +static jlong RadialGradient_postCreate2(JNIEnv* env, jobject o, jlong shaderHandle, + jfloat x, jfloat y, jfloat radius, jint color0, jint color1, jint tileMode) { #ifdef USE_OPENGL_RENDERER + SkShader* shader = reinterpret_cast<SkShader*>(shaderHandle); float* storedPositions = new float[2]; storedPositions[0] = 0.0f; storedPositions[1] = 1.0f; @@ -356,7 +368,7 @@ static SkiaShader* RadialGradient_postCreate2(JNIEnv* env, jobject o, SkShader* storedPositions, 2, shader, (SkShader::TileMode) tileMode, NULL, (shader->getFlags() & SkShader::kOpaqueAlpha_Flag) == 0); - return skiaShader; + return reinterpret_cast<jlong>(skiaShader); #else return NULL; #endif @@ -364,7 +376,7 @@ static SkiaShader* RadialGradient_postCreate2(JNIEnv* env, jobject o, SkShader* /////////////////////////////////////////////////////////////////////////////// -static SkShader* SweepGradient_create1(JNIEnv* env, jobject, float x, float y, +static jlong SweepGradient_create1(JNIEnv* env, jobject, jfloat x, jfloat y, jintArray jcolors, jfloatArray jpositions) { size_t count = env->GetArrayLength(jcolors); const jint* colors = env->GetIntArrayElements(jcolors, NULL); @@ -388,10 +400,10 @@ static SkShader* SweepGradient_create1(JNIEnv* env, jobject, float x, float y, env->ReleaseIntArrayElements(jcolors, const_cast<jint*>(colors), JNI_ABORT); ThrowIAE_IfNull(env, shader); - return shader; + return reinterpret_cast<jlong>(shader); } -static SkShader* SweepGradient_create2(JNIEnv* env, jobject, float x, float y, +static jlong SweepGradient_create2(JNIEnv* env, jobject, jfloat x, jfloat y, int color0, int color1) { SkColor colors[2]; colors[0] = color0; @@ -399,12 +411,13 @@ static SkShader* SweepGradient_create2(JNIEnv* env, jobject, float x, float y, SkShader* s = SkGradientShader::CreateSweep(SkFloatToScalar(x), SkFloatToScalar(y), colors, NULL, 2); ThrowIAE_IfNull(env, s); - return s; + return reinterpret_cast<jlong>(s); } -static SkiaShader* SweepGradient_postCreate1(JNIEnv* env, jobject o, SkShader* shader, - float x, float y, jintArray colorArray, jfloatArray posArray) { +static jlong SweepGradient_postCreate1(JNIEnv* env, jobject o, jlong shaderHandle, + jfloat x, jfloat y, jintArray colorArray, jfloatArray posArray) { #ifdef USE_OPENGL_RENDERER + SkShader* shader = reinterpret_cast<SkShader*>(shaderHandle); size_t count = env->GetArrayLength(colorArray); const jint* colorValues = env->GetIntArrayElements(colorArray, NULL); @@ -433,15 +446,16 @@ static SkiaShader* SweepGradient_postCreate1(JNIEnv* env, jobject o, SkShader* s shader, NULL, (shader->getFlags() & SkShader::kOpaqueAlpha_Flag) == 0); env->ReleaseIntArrayElements(colorArray, const_cast<jint*>(colorValues), JNI_ABORT); - return skiaShader; + return reinterpret_cast<jlong>(skiaShader); #else return NULL; #endif } -static SkiaShader* SweepGradient_postCreate2(JNIEnv* env, jobject o, SkShader* shader, - float x, float y, int color0, int color1) { +static jlong SweepGradient_postCreate2(JNIEnv* env, jobject o, jlong shaderHandle, + jfloat x, jfloat y, jint color0, jint color1) { #ifdef USE_OPENGL_RENDERER + SkShader* shader = reinterpret_cast<SkShader*>(shaderHandle); float* storedPositions = new float[2]; storedPositions[0] = 0.0f; storedPositions[1] = 1.0f; @@ -453,7 +467,7 @@ static SkiaShader* SweepGradient_postCreate2(JNIEnv* env, jobject o, SkShader* s SkiaShader* skiaShader = new SkiaSweepGradientShader(x, y, storedColors, storedPositions, 2, shader, NULL, (shader->getFlags() & SkShader::kOpaqueAlpha_Flag) == 0); - return skiaShader; + return reinterpret_cast<jlong>(skiaShader); #else return NULL; #endif @@ -461,39 +475,57 @@ static SkiaShader* SweepGradient_postCreate2(JNIEnv* env, jobject o, SkShader* s /////////////////////////////////////////////////////////////////////////////////////////////// -static SkShader* ComposeShader_create1(JNIEnv* env, jobject o, - SkShader* shaderA, SkShader* shaderB, SkXfermode* mode) +static jlong ComposeShader_create1(JNIEnv* env, jobject o, + jlong shaderAHandle, jlong shaderBHandle, jlong modeHandle) { - return new SkComposeShader(shaderA, shaderB, mode); + SkShader* shaderA = reinterpret_cast<SkShader *>(shaderAHandle); + SkShader* shaderB = reinterpret_cast<SkShader *>(shaderBHandle); + SkXfermode* mode = reinterpret_cast<SkXfermode *>(modeHandle); + SkShader* shader = new SkComposeShader(shaderA, shaderB, mode); + return reinterpret_cast<jlong>(shader); } -static SkShader* ComposeShader_create2(JNIEnv* env, jobject o, - SkShader* shaderA, SkShader* shaderB, SkPorterDuff::Mode porterDuffMode) +static jlong ComposeShader_create2(JNIEnv* env, jobject o, + jlong shaderAHandle, jlong shaderBHandle, jint porterDuffModeHandle) { + SkShader* shaderA = reinterpret_cast<SkShader *>(shaderAHandle); + SkShader* shaderB = reinterpret_cast<SkShader *>(shaderBHandle); + SkPorterDuff::Mode porterDuffMode = static_cast<SkPorterDuff::Mode>(porterDuffModeHandle); SkAutoUnref au(SkPorterDuff::CreateXfermode(porterDuffMode)); SkXfermode* mode = (SkXfermode*) au.get(); - return new SkComposeShader(shaderA, shaderB, mode); + SkShader* shader = new SkComposeShader(shaderA, shaderB, mode); + return reinterpret_cast<jlong>(shader); } -static SkiaShader* ComposeShader_postCreate2(JNIEnv* env, jobject o, SkShader* shader, - SkiaShader* shaderA, SkiaShader* shaderB, SkPorterDuff::Mode porterDuffMode) { +static jlong ComposeShader_postCreate2(JNIEnv* env, jobject o, jlong shaderHandle, + jlong shaderAHandle, jlong shaderBHandle, jint porterDuffModeHandle) { #ifdef USE_OPENGL_RENDERER + SkShader* shader = reinterpret_cast<SkShader *>(shaderHandle); + SkiaShader* shaderA = reinterpret_cast<SkiaShader *>(shaderAHandle); + SkiaShader* shaderB = reinterpret_cast<SkiaShader *>(shaderBHandle); + SkPorterDuff::Mode porterDuffMode = static_cast<SkPorterDuff::Mode>(porterDuffModeHandle); SkXfermode::Mode mode = SkPorterDuff::ToXfermodeMode(porterDuffMode); - return new SkiaComposeShader(shaderA, shaderB, mode, shader); + SkiaShader* skiaShader = new SkiaComposeShader(shaderA, shaderB, mode, shader); + return reinterpret_cast<jlong>(skiaShader); #else return NULL; #endif } -static SkiaShader* ComposeShader_postCreate1(JNIEnv* env, jobject o, SkShader* shader, - SkiaShader* shaderA, SkiaShader* shaderB, SkXfermode* mode) { +static jlong ComposeShader_postCreate1(JNIEnv* env, jobject o, jlong shaderHandle, + jlong shaderAHandle, jlong shaderBHandle, jlong modeHandle) { #ifdef USE_OPENGL_RENDERER + SkShader* shader = reinterpret_cast<SkShader *>(shaderHandle); + SkiaShader* shaderA = reinterpret_cast<SkiaShader *>(shaderAHandle); + SkiaShader* shaderB = reinterpret_cast<SkiaShader *>(shaderBHandle); + SkXfermode* mode = reinterpret_cast<SkXfermode *>(modeHandle); SkXfermode::Mode skiaMode; if (!SkXfermode::IsMode(mode, &skiaMode)) { // TODO: Support other modes skiaMode = SkXfermode::kSrcOver_Mode; } - return new SkiaComposeShader(shaderA, shaderB, skiaMode, shader); + SkiaShader* skiaShader = new SkiaComposeShader(shaderA, shaderB, skiaMode, shader); + return reinterpret_cast<jlong>(skiaShader); #else return NULL; #endif @@ -507,41 +539,41 @@ static JNINativeMethod gColorMethods[] = { }; static JNINativeMethod gShaderMethods[] = { - { "nativeDestructor", "(II)V", (void*)Shader_destructor }, - { "nativeSetLocalMatrix", "(III)V", (void*)Shader_setLocalMatrix } + { "nativeDestructor", "(JJ)V", (void*)Shader_destructor }, + { "nativeSetLocalMatrix", "(JJJ)V", (void*)Shader_setLocalMatrix } }; static JNINativeMethod gBitmapShaderMethods[] = { - { "nativeCreate", "(III)I", (void*)BitmapShader_constructor }, - { "nativePostCreate", "(IIII)I", (void*)BitmapShader_postConstructor } + { "nativeCreate", "(JII)J", (void*)BitmapShader_constructor }, + { "nativePostCreate", "(JJII)J", (void*)BitmapShader_postConstructor } }; static JNINativeMethod gLinearGradientMethods[] = { - { "nativeCreate1", "(FFFF[I[FI)I", (void*)LinearGradient_create1 }, - { "nativeCreate2", "(FFFFIII)I", (void*)LinearGradient_create2 }, - { "nativePostCreate1", "(IFFFF[I[FI)I", (void*)LinearGradient_postCreate1 }, - { "nativePostCreate2", "(IFFFFIII)I", (void*)LinearGradient_postCreate2 } + { "nativeCreate1", "(FFFF[I[FI)J", (void*)LinearGradient_create1 }, + { "nativeCreate2", "(FFFFIII)J", (void*)LinearGradient_create2 }, + { "nativePostCreate1", "(JFFFF[I[FI)J", (void*)LinearGradient_postCreate1 }, + { "nativePostCreate2", "(JFFFFIII)J", (void*)LinearGradient_postCreate2 } }; static JNINativeMethod gRadialGradientMethods[] = { - { "nativeCreate1", "(FFF[I[FI)I", (void*)RadialGradient_create1 }, - { "nativeCreate2", "(FFFIII)I", (void*)RadialGradient_create2 }, - { "nativePostCreate1", "(IFFF[I[FI)I", (void*)RadialGradient_postCreate1 }, - { "nativePostCreate2", "(IFFFIII)I", (void*)RadialGradient_postCreate2 } + { "nativeCreate1", "(FFF[I[FI)J", (void*)RadialGradient_create1 }, + { "nativeCreate2", "(FFFIII)J", (void*)RadialGradient_create2 }, + { "nativePostCreate1", "(JFFF[I[FI)J", (void*)RadialGradient_postCreate1 }, + { "nativePostCreate2", "(JFFFIII)J", (void*)RadialGradient_postCreate2 } }; static JNINativeMethod gSweepGradientMethods[] = { - { "nativeCreate1", "(FF[I[F)I", (void*)SweepGradient_create1 }, - { "nativeCreate2", "(FFII)I", (void*)SweepGradient_create2 }, - { "nativePostCreate1", "(IFF[I[F)I", (void*)SweepGradient_postCreate1 }, - { "nativePostCreate2", "(IFFII)I", (void*)SweepGradient_postCreate2 } + { "nativeCreate1", "(FF[I[F)J", (void*)SweepGradient_create1 }, + { "nativeCreate2", "(FFII)J", (void*)SweepGradient_create2 }, + { "nativePostCreate1", "(JFF[I[F)J", (void*)SweepGradient_postCreate1 }, + { "nativePostCreate2", "(JFFII)J", (void*)SweepGradient_postCreate2 } }; static JNINativeMethod gComposeShaderMethods[] = { - { "nativeCreate1", "(III)I", (void*)ComposeShader_create1 }, - { "nativeCreate2", "(III)I", (void*)ComposeShader_create2 }, - { "nativePostCreate1", "(IIII)I", (void*)ComposeShader_postCreate1 }, - { "nativePostCreate2", "(IIII)I", (void*)ComposeShader_postCreate2 } + { "nativeCreate1", "(JJJ)J", (void*)ComposeShader_create1 }, + { "nativeCreate2", "(JJI)J", (void*)ComposeShader_create2 }, + { "nativePostCreate1", "(JJJJ)J", (void*)ComposeShader_postCreate1 }, + { "nativePostCreate2", "(JJJI)J", (void*)ComposeShader_postCreate2 } }; #include <android_runtime/AndroidRuntime.h> diff --git a/core/jni/android/graphics/Typeface.cpp b/core/jni/android/graphics/Typeface.cpp index 04f9fe1..a349a7f 100644 --- a/core/jni/android/graphics/Typeface.cpp +++ b/core/jni/android/graphics/Typeface.cpp @@ -44,8 +44,9 @@ private: const char* fCStr; }; -static TypefaceImpl* Typeface_create(JNIEnv* env, jobject, jstring name, - SkTypeface::Style style) { +static jlong Typeface_create(JNIEnv* env, jobject, jstring name, + jint styleHandle) { + SkTypeface::Style style = static_cast<SkTypeface::Style>(styleHandle); TypefaceImpl* face = NULL; if (NULL != name) { @@ -57,10 +58,11 @@ static TypefaceImpl* Typeface_create(JNIEnv* env, jobject, jstring name, if (NULL == face) { face = TypefaceImpl_createFromName(NULL, style); } - return face; + return reinterpret_cast<jlong>(face); } -static TypefaceImpl* Typeface_createFromTypeface(JNIEnv* env, jobject, TypefaceImpl* family, int style) { +static jlong Typeface_createFromTypeface(JNIEnv* env, jobject, jlong familyHandle, jint style) { + SkTypeface* family = reinterpret_cast<SkTypeface*>(familyHandle); TypefaceImpl* face = TypefaceImpl_createFromTypeface(family, (SkTypeface::Style)style); // Try to find the closest matching font, using the standard heuristic if (NULL == face) { @@ -72,21 +74,22 @@ static TypefaceImpl* Typeface_createFromTypeface(JNIEnv* env, jobject, TypefaceI if (NULL == face) { face = TypefaceImpl_createFromName(NULL, (SkTypeface::Style)style); } - return face; + return reinterpret_cast<jlong>(face); } -static void Typeface_unref(JNIEnv* env, jobject obj, TypefaceImpl* face) { +static void Typeface_unref(JNIEnv* env, jobject obj, jlong faceHandle) { + TypefaceImpl* face = reinterpret_cast<TypefaceImpl*>(faceHandle); TypefaceImpl_unref(face); } -static int Typeface_getStyle(JNIEnv* env, jobject obj, TypefaceImpl* face) { +static jint Typeface_getStyle(JNIEnv* env, jobject obj, jlong faceHandle) { + TypefaceImpl* face = reinterpret_cast<TypefaceImpl*>(faceHandle); return TypefaceImpl_getStyle(face); } -static TypefaceImpl* Typeface_createFromAsset(JNIEnv* env, jobject, - jobject jassetMgr, - jstring jpath) { - +static jlong Typeface_createFromAsset(JNIEnv* env, jobject, + jobject jassetMgr, + jstring jpath) { NPE_CHECK_RETURN_ZERO(env, jassetMgr); NPE_CHECK_RETURN_ZERO(env, jpath); @@ -95,33 +98,32 @@ static TypefaceImpl* Typeface_createFromAsset(JNIEnv* env, jobject, return NULL; } - AutoJavaStringToUTF8 str(env, jpath); + AutoJavaStringToUTF8 str(env, jpath); Asset* asset = mgr->open(str.c_str(), Asset::ACCESS_BUFFER); if (NULL == asset) { return NULL; } - return TypefaceImpl_createFromAsset(asset); + return reinterpret_cast<jlong>(TypefaceImpl_createFromAsset(asset)); } -static TypefaceImpl* Typeface_createFromFile(JNIEnv* env, jobject, jstring jpath) { +static jlong Typeface_createFromFile(JNIEnv* env, jobject, jstring jpath) { NPE_CHECK_RETURN_ZERO(env, jpath); AutoJavaStringToUTF8 str(env, jpath); - - return TypefaceImpl_createFromFile(str.c_str()); + return reinterpret_cast<jlong>(TypefaceImpl_createFromFile(str.c_str())); } /////////////////////////////////////////////////////////////////////////////// static JNINativeMethod gTypefaceMethods[] = { - { "nativeCreate", "(Ljava/lang/String;I)I", (void*)Typeface_create }, - { "nativeCreateFromTypeface", "(II)I", (void*)Typeface_createFromTypeface }, - { "nativeUnref", "(I)V", (void*)Typeface_unref }, - { "nativeGetStyle", "(I)I", (void*)Typeface_getStyle }, - { "nativeCreateFromAsset", "(Landroid/content/res/AssetManager;Ljava/lang/String;)I", + { "nativeCreate", "(Ljava/lang/String;I)J", (void*)Typeface_create }, + { "nativeCreateFromTypeface", "(JI)J", (void*)Typeface_createFromTypeface }, + { "nativeUnref", "(J)V", (void*)Typeface_unref }, + { "nativeGetStyle", "(J)I", (void*)Typeface_getStyle }, + { "nativeCreateFromAsset", "(Landroid/content/res/AssetManager;Ljava/lang/String;)J", (void*)Typeface_createFromAsset }, - { "nativeCreateFromFile", "(Ljava/lang/String;)I", + { "nativeCreateFromFile", "(Ljava/lang/String;)J", (void*)Typeface_createFromFile }, }; diff --git a/core/jni/android/graphics/Xfermode.cpp b/core/jni/android/graphics/Xfermode.cpp index 976a91f..eedceb7 100644 --- a/core/jni/android/graphics/Xfermode.cpp +++ b/core/jni/android/graphics/Xfermode.cpp @@ -26,35 +26,37 @@ namespace android { class SkXfermodeGlue { public: - static void finalizer(JNIEnv* env, jobject, SkXfermode* obj) + static void finalizer(JNIEnv* env, jobject, jlong objHandle) { + SkXfermode* obj = reinterpret_cast<SkXfermode *>(objHandle); SkSafeUnref(obj); } - static SkXfermode* avoid_create(JNIEnv* env, jobject, SkColor opColor, - U8CPU tolerance, SkAvoidXfermode::Mode mode) + static jlong avoid_create(JNIEnv* env, jobject, jint opColor, + jint tolerance, jint modeHandle) { - return new SkAvoidXfermode(opColor, tolerance, mode); + SkAvoidXfermode::Mode mode = static_cast<SkAvoidXfermode::Mode>(modeHandle); + return reinterpret_cast<jlong>(new SkAvoidXfermode(opColor, tolerance, mode)); } - - static SkXfermode* pixelxor_create(JNIEnv* env, jobject, SkColor opColor) + + static jlong pixelxor_create(JNIEnv* env, jobject, jint opColor) { - return new SkPixelXorXfermode(opColor); + return reinterpret_cast<jlong>(new SkPixelXorXfermode(opColor)); } }; /////////////////////////////////////////////////////////////////////////////// static JNINativeMethod gXfermodeMethods[] = { - {"finalizer", "(I)V", (void*) SkXfermodeGlue::finalizer} + {"finalizer", "(J)V", (void*) SkXfermodeGlue::finalizer} }; static JNINativeMethod gAvoidMethods[] = { - {"nativeCreate", "(III)I", (void*) SkXfermodeGlue::avoid_create} + {"nativeCreate", "(III)J", (void*) SkXfermodeGlue::avoid_create} }; static JNINativeMethod gPixelXorMethods[] = { - {"nativeCreate", "(I)I", (void*) SkXfermodeGlue::pixelxor_create} + {"nativeCreate", "(I)J", (void*) SkXfermodeGlue::pixelxor_create} }; #include <android_runtime/AndroidRuntime.h> |