From 95d49149cc7fff87a18449fa661454c1b5ddbd30 Mon Sep 17 00:00:00 2001 From: Florin Malita Date: Tue, 3 Jun 2014 12:27:17 -0400 Subject: Canvas JNI cleanup. As pointed out in a previous patch review, some native Canvas methods do not receive a native canvas handle and instead have to use GraphicsJNI to query the object mNativeCanvasWrapper field. To avoid the extra JNI call, this change adds the missing Java wrapper methods and ensures that all native calls are passed efficient native handles. Also, some native methods are consolidated: save, saveAll -> save, clipRect* -> clipRect. Change-Id: I2eae4a633f6a463d9fbae2ca632661acc8b5cfc3 --- core/jni/android/graphics/Canvas.cpp | 267 ++++++++--------------------- graphics/java/android/graphics/Canvas.java | 132 ++++++++++---- 2 files changed, 170 insertions(+), 229 deletions(-) diff --git a/core/jni/android/graphics/Canvas.cpp b/core/jni/android/graphics/Canvas.cpp index 5fca582..c57f0ba 100644 --- a/core/jni/android/graphics/Canvas.cpp +++ b/core/jni/android/graphics/Canvas.cpp @@ -170,56 +170,33 @@ public: TextLayoutEngine::getInstance().purgeCaches(); } - static jboolean isOpaque(JNIEnv* env, jobject jcanvas) { - NPE_CHECK_RETURN_ZERO(env, jcanvas); - SkCanvas* canvas = GraphicsJNI::getNativeCanvas(env, jcanvas); + static jboolean isOpaque(JNIEnv*, jobject, jlong canvasHandle) { + SkCanvas* canvas = getNativeCanvas(canvasHandle); bool result = canvas->getDevice()->accessBitmap(false).isOpaque(); return result ? JNI_TRUE : JNI_FALSE; } - static jint getWidth(JNIEnv* env, jobject jcanvas) { - NPE_CHECK_RETURN_ZERO(env, jcanvas); - SkCanvas* canvas = GraphicsJNI::getNativeCanvas(env, jcanvas); + static jint getWidth(JNIEnv*, jobject, jlong canvasHandle) { + SkCanvas* canvas = getNativeCanvas(canvasHandle); int width = canvas->getDevice()->accessBitmap(false).width(); return static_cast(width); } - static jint getHeight(JNIEnv* env, jobject jcanvas) { - NPE_CHECK_RETURN_ZERO(env, jcanvas); - SkCanvas* canvas = GraphicsJNI::getNativeCanvas(env, jcanvas); + static jint getHeight(JNIEnv*, jobject, jlong canvasHandle) { + SkCanvas* canvas = getNativeCanvas(canvasHandle); int height = canvas->getDevice()->accessBitmap(false).height(); return static_cast(height); } - static jint saveAll(JNIEnv* env, jobject jcanvas) { - NPE_CHECK_RETURN_ZERO(env, jcanvas); - int result = GraphicsJNI::getNativeCanvas(env, jcanvas)->save(); - return static_cast(result); - } - - static jint save(JNIEnv* env, jobject jcanvas, jint flagsHandle) { - SkCanvas::SaveFlags flags = static_cast(flagsHandle); - NPE_CHECK_RETURN_ZERO(env, jcanvas); - int result = GraphicsJNI::getNativeCanvas(env, jcanvas)->save(flags); - return static_cast(result); - } - - static jint saveLayer(JNIEnv* env, jobject, jlong canvasHandle, jobject bounds, - jlong paintHandle, jint flags) { + static jint save(JNIEnv*, jobject, jlong canvasHandle, jint flagsHandle) { SkCanvas* canvas = getNativeCanvas(canvasHandle); - SkPaint* paint = reinterpret_cast(paintHandle); - SkRect* bounds_ = NULL; - SkRect storage; - if (bounds != NULL) { - GraphicsJNI::jrectf_to_rect(env, bounds, &storage); - bounds_ = &storage; - } - return canvas->saveLayer(bounds_, paint, static_cast(flags)); + SkCanvas::SaveFlags flags = static_cast(flagsHandle); + return static_cast(canvas->save(flags)); } - static jint saveLayer4F(JNIEnv* env, jobject, jlong canvasHandle, - jfloat l, jfloat t, jfloat r, jfloat b, - jlong paintHandle, jint flags) { + static jint saveLayer(JNIEnv* env, jobject, jlong canvasHandle, + jfloat l, jfloat t, jfloat r, jfloat b, + jlong paintHandle, jint flags) { SkCanvas* canvas = getNativeCanvas(canvasHandle); SkPaint* paint = reinterpret_cast(paintHandle); SkRect bounds; @@ -230,22 +207,8 @@ public: } static jint saveLayerAlpha(JNIEnv* env, jobject, jlong canvasHandle, - jobject bounds, jint alpha, jint flags) { - SkCanvas* canvas = getNativeCanvas(canvasHandle); - SkRect* bounds_ = NULL; - SkRect storage; - if (bounds != NULL) { - GraphicsJNI::jrectf_to_rect(env, bounds, &storage); - bounds_ = &storage; - } - int result = canvas->saveLayerAlpha(bounds_, alpha, - static_cast(flags)); - return static_cast(result); - } - - static jint saveLayerAlpha4F(JNIEnv* env, jobject, jlong canvasHandle, - jfloat l, jfloat t, jfloat r, jfloat b, - jint alpha, jint flags) { + jfloat l, jfloat t, jfloat r, jfloat b, + jint alpha, jint flags) { SkCanvas* canvas = getNativeCanvas(canvasHandle); SkRect bounds; bounds.set(l, t, r, b); @@ -254,9 +217,8 @@ public: return static_cast(result); } - static void restore(JNIEnv* env, jobject jcanvas) { - NPE_CHECK_RETURN_VOID(env, jcanvas); - SkCanvas* canvas = GraphicsJNI::getNativeCanvas(env, jcanvas); + static void restore(JNIEnv* env, jobject, jlong canvasHandle) { + SkCanvas* canvas = getNativeCanvas(canvasHandle); if (canvas->getSaveCount() <= 1) { // cannot restore anymore doThrowISE(env, "Underflow in restore"); return; @@ -264,15 +226,14 @@ public: canvas->restore(); } - static jint getSaveCount(JNIEnv* env, jobject jcanvas) { - NPE_CHECK_RETURN_ZERO(env, jcanvas); - int result = GraphicsJNI::getNativeCanvas(env, jcanvas)->getSaveCount(); - return static_cast(result); + static jint getSaveCount(JNIEnv*, jobject, jlong canvasHandle) { + SkCanvas* canvas = getNativeCanvas(canvasHandle); + return static_cast(canvas->getSaveCount()); } - static void restoreToCount(JNIEnv* env, jobject jcanvas, jint restoreCount) { - NPE_CHECK_RETURN_VOID(env, jcanvas); - SkCanvas* canvas = GraphicsJNI::getNativeCanvas(env, jcanvas); + static void restoreToCount(JNIEnv* env, jobject, jlong canvasHandle, + jint restoreCount) { + SkCanvas* canvas = getNativeCanvas(canvasHandle); if (restoreCount < 1) { doThrowIAE(env, "Underflow in restoreToCount"); return; @@ -280,24 +241,24 @@ public: canvas->restoreToCount(restoreCount); } - static void translate(JNIEnv* env, jobject jcanvas, jfloat dx, jfloat dy) { - NPE_CHECK_RETURN_VOID(env, jcanvas); - (void)GraphicsJNI::getNativeCanvas(env, jcanvas)->translate(dx, dy); + static void translate(JNIEnv*, jobject, jlong canvasHandle, + jfloat dx, jfloat dy) { + getNativeCanvas(canvasHandle)->translate(dx, dy); } - static void scale__FF(JNIEnv* env, jobject jcanvas, jfloat sx, jfloat sy) { - NPE_CHECK_RETURN_VOID(env, jcanvas); - (void)GraphicsJNI::getNativeCanvas(env, jcanvas)->scale(sx, sy); + static void scale__FF(JNIEnv*, jobject, jlong canvasHandle, + jfloat sx, jfloat sy) { + getNativeCanvas(canvasHandle)->scale(sx, sy); } - static void rotate__F(JNIEnv* env, jobject jcanvas, jfloat degrees) { - NPE_CHECK_RETURN_VOID(env, jcanvas); - (void)GraphicsJNI::getNativeCanvas(env, jcanvas)->rotate(degrees); + static void rotate__F(JNIEnv*, jobject, jlong canvasHandle, + jfloat degrees) { + getNativeCanvas(canvasHandle)->rotate(degrees); } - static void skew__FF(JNIEnv* env, jobject jcanvas, jfloat sx, jfloat sy) { - NPE_CHECK_RETURN_VOID(env, jcanvas); - (void)GraphicsJNI::getNativeCanvas(env, jcanvas)->skew(sx, sy); + static void skew__FF(JNIEnv*, jobject, jlong canvasHandle, + jfloat sx, jfloat sy) { + getNativeCanvas(canvasHandle)->skew(sx, sy); } static void concat(JNIEnv* env, jobject, jlong canvasHandle, @@ -318,56 +279,16 @@ public: } } - static jboolean clipRect_FFFF(JNIEnv* env, jobject jcanvas, jfloat left, - jfloat top, jfloat right, jfloat bottom) { - NPE_CHECK_RETURN_ZERO(env, jcanvas); + static jboolean clipRect(JNIEnv*, jobject, jlong canvasHandle, + jfloat left, jfloat top, jfloat right, + jfloat bottom, jint op) { SkRect r; r.set(left, top, right, bottom); - SkCanvas* c = GraphicsJNI::getNativeCanvas(env, jcanvas); - c->clipRect(r); - return hasNonEmptyClip(*c); - } - - 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)); - SkCanvas* c = GraphicsJNI::getNativeCanvas(env, jcanvas); - c->clipRect(r); + SkCanvas* c = getNativeCanvas(canvasHandle); + c->clipRect(r, static_cast(op)); return hasNonEmptyClip(*c); } - 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; - c->clipRect(*GraphicsJNI::jrectf_to_rect(env, rectf, &tmp)); - return hasNonEmptyClip(*c); - } - - 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; - c->clipRect(*GraphicsJNI::jrect_to_rect(env, rect, &tmp)); - return hasNonEmptyClip(*c); - - } - - static jboolean clipRect(JNIEnv* env, jobject, jlong canvasHandle, - jfloat left, jfloat top, jfloat right, jfloat bottom, - jint op) { - SkCanvas* canvas = getNativeCanvas(canvasHandle); - SkRect rect; - rect.set(left, top, right, bottom); - canvas->clipRect(rect, static_cast(op)); - return hasNonEmptyClip(*canvas); - } - static jboolean clipPath(JNIEnv* env, jobject, jlong canvasHandle, jlong pathHandle, jint op) { SkCanvas* canvas = getNativeCanvas(canvasHandle); @@ -390,15 +311,6 @@ public: canvas->setDrawFilter(reinterpret_cast(filterHandle)); } - static jboolean quickReject__RectF(JNIEnv* env, jobject, jlong canvasHandle, - jobject rect) { - SkCanvas* canvas = getNativeCanvas(canvasHandle); - SkRect rect_; - GraphicsJNI::jrectf_to_rect(env, rect, &rect_); - bool result = canvas->quickReject(rect_); - return result ? JNI_TRUE : JNI_FALSE; - } - static jboolean quickReject__Path(JNIEnv* env, jobject, jlong canvasHandle, jlong pathHandle) { SkCanvas* canvas = getNativeCanvas(canvasHandle); @@ -448,15 +360,13 @@ public: canvas->drawPaint(*paint); } - static void doPoints(JNIEnv* env, jobject jcanvas, jfloatArray jptsArray, - jint offset, jint count, jobject jpaint, - jint modeHandle) { - NPE_CHECK_RETURN_VOID(env, jcanvas); + static void doPoints(JNIEnv* env, jlong canvasHandle, + jfloatArray jptsArray, jint offset, jint count, + jlong paintHandle, jint modeHandle) { NPE_CHECK_RETURN_VOID(env, jptsArray); - NPE_CHECK_RETURN_VOID(env, jpaint); SkCanvas::PointMode mode = static_cast(modeHandle); - SkCanvas* canvas = GraphicsJNI::getNativeCanvas(env, jcanvas); - const SkPaint& paint = *GraphicsJNI::getNativePaint(env, jpaint); + SkCanvas* canvas = getNativeCanvas(canvasHandle); + const SkPaint* paint = reinterpret_cast(paintHandle); AutoJavaFloatArray autoPts(env, jptsArray); float* floats = autoPts.ptr(); @@ -476,29 +386,28 @@ public: pts[i].set(src[0], src[1]); src += 2; } - canvas->drawPoints(mode, count, pts, paint); + 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, + static void drawPoints(JNIEnv* env, jobject, jlong canvasHandle, + jfloatArray jptsArray, jint offset, + jint count, jlong paintHandle) { + doPoints(env, canvasHandle, jptsArray, offset, count, paintHandle, 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, + static void drawLines(JNIEnv* env, jobject, jlong canvasHandle, + jfloatArray jptsArray, jint offset, jint count, + jlong paintHandle) { + doPoints(env, canvasHandle, jptsArray, offset, count, paintHandle, SkCanvas::kLines_PointMode); } - 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(x, y, paint); + static void drawPoint(JNIEnv*, jobject, jlong canvasHandle, jfloat x, jfloat y, + jlong paintHandle) { + SkCanvas* canvas = getNativeCanvas(canvasHandle); + const SkPaint* paint = reinterpret_cast(paintHandle); + canvas->drawPoint(x, y, *paint); } static void drawLine__FFFFPaint(JNIEnv* env, jobject, jlong canvasHandle, @@ -509,15 +418,6 @@ public: canvas->drawLine(startX, startY, stopX, stopY, *paint); } - static void drawRect__RectFPaint(JNIEnv* env, jobject, jlong canvasHandle, - jobject rect, jlong paintHandle) { - SkCanvas* canvas = getNativeCanvas(canvasHandle); - SkPaint* paint = reinterpret_cast(paintHandle); - SkRect rect_; - GraphicsJNI::jrectf_to_rect(env, rect, &rect_); - canvas->drawRect(rect_, *paint); - } - static void drawRect__FFFFPaint(JNIEnv* env, jobject, jlong canvasHandle, jfloat left, jfloat top, jfloat right, jfloat bottom, jlong paintHandle) { @@ -1153,33 +1053,21 @@ static JNINativeMethod gCanvasMethods[] = { {"initRaster", "(J)J", (void*) SkCanvasGlue::initRaster}, {"initCanvas", "(J)J", (void*) SkCanvasGlue::initCanvas}, {"native_setBitmap", "(JJZ)V", (void*) SkCanvasGlue::setBitmap}, - {"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","(JLandroid/graphics/RectF;JI)I", - (void*) SkCanvasGlue::saveLayer}, - {"native_saveLayer","(JFFFFJI)I", (void*) SkCanvasGlue::saveLayer4F}, - {"native_saveLayerAlpha","(JLandroid/graphics/RectF;II)I", - (void*) SkCanvasGlue::saveLayerAlpha}, - {"native_saveLayerAlpha","(JFFFFII)I", - (void*) SkCanvasGlue::saveLayerAlpha4F}, - {"restore","()V", (void*) SkCanvasGlue::restore}, - {"getSaveCount","()I", (void*) SkCanvasGlue::getSaveCount}, - {"restoreToCount","(I)V", (void*) SkCanvasGlue::restoreToCount}, - {"translate","(FF)V", (void*) SkCanvasGlue::translate}, - {"scale","(FF)V", (void*) SkCanvasGlue::scale__FF}, - {"rotate","(F)V", (void*) SkCanvasGlue::rotate__F}, - {"skew","(FF)V", (void*) SkCanvasGlue::skew__FF}, + {"native_isOpaque","(J)Z", (void*) SkCanvasGlue::isOpaque}, + {"native_getWidth","(J)I", (void*) SkCanvasGlue::getWidth}, + {"native_getHeight","(J)I", (void*) SkCanvasGlue::getHeight}, + {"native_save","(JI)I", (void*) SkCanvasGlue::save}, + {"native_saveLayer","(JFFFFJI)I", (void*) SkCanvasGlue::saveLayer}, + {"native_saveLayerAlpha","(JFFFFII)I", (void*) SkCanvasGlue::saveLayerAlpha}, + {"native_restore","(J)V", (void*) SkCanvasGlue::restore}, + {"native_getSaveCount","(J)I", (void*) SkCanvasGlue::getSaveCount}, + {"native_restoreToCount","(JI)V", (void*) SkCanvasGlue::restoreToCount}, + {"native_translate","(JFF)V", (void*) SkCanvasGlue::translate}, + {"native_scale","(JFF)V", (void*) SkCanvasGlue::scale__FF}, + {"native_rotate","(JF)V", (void*) SkCanvasGlue::rotate__F}, + {"native_skew","(JFF)V", (void*) SkCanvasGlue::skew__FF}, {"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","(JFFFFI)Z", (void*) SkCanvasGlue::clipRect}, {"native_clipPath","(JJI)Z", (void*) SkCanvasGlue::clipPath}, {"native_clipRegion","(JJI)Z", (void*) SkCanvasGlue::clipRegion}, @@ -1187,8 +1075,6 @@ static JNINativeMethod gCanvasMethods[] = { {"native_getClipBounds","(JLandroid/graphics/Rect;)Z", (void*) SkCanvasGlue::getClipBounds}, {"native_getCTM", "(JJ)V", (void*)SkCanvasGlue::getCTM}, - {"native_quickReject","(JLandroid/graphics/RectF;)Z", - (void*) SkCanvasGlue::quickReject__RectF}, {"native_quickReject","(JJ)Z", (void*) SkCanvasGlue::quickReject__Path}, {"native_quickReject","(JFFFF)Z", (void*)SkCanvasGlue::quickReject__FFFF}, {"native_drawRGB","(JIII)V", (void*) SkCanvasGlue::drawRGB}, @@ -1196,15 +1082,10 @@ static JNINativeMethod gCanvasMethods[] = { {"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_drawPoint", "(JFFJ)V", (void*) SkCanvasGlue::drawPoint}, + {"native_drawPoints", "(J[FIIJ)V", (void*) SkCanvasGlue::drawPoints}, + {"native_drawLines", "(J[FIIJ)V", (void*) SkCanvasGlue::drawLines}, {"native_drawLine","(JFFFFJ)V", (void*) SkCanvasGlue::drawLine__FFFFPaint}, - {"native_drawRect","(JLandroid/graphics/RectF;J)V", - (void*) SkCanvasGlue::drawRect__RectFPaint}, {"native_drawRect","(JFFFFJ)V", (void*) SkCanvasGlue::drawRect__FFFFPaint}, {"native_drawOval","(JLandroid/graphics/RectF;J)V", (void*) SkCanvasGlue::drawOval}, diff --git a/graphics/java/android/graphics/Canvas.java b/graphics/java/android/graphics/Canvas.java index bd868f2..12877de 100644 --- a/graphics/java/android/graphics/Canvas.java +++ b/graphics/java/android/graphics/Canvas.java @@ -242,21 +242,27 @@ public class Canvas { * * @return true if the device that the current layer draws into is opaque */ - public native boolean isOpaque(); + public boolean isOpaque() { + return native_isOpaque(mNativeCanvasWrapper); + } /** * Returns the width of the current drawing layer * * @return the width of the current drawing layer */ - public native int getWidth(); + public int getWidth() { + return native_getWidth(mNativeCanvasWrapper); + } /** * Returns the height of the current drawing layer * * @return the height of the current drawing layer */ - public native int getHeight(); + public int getHeight() { + return native_getHeight(mNativeCanvasWrapper); + } /** *

Returns the target density of the canvas. The default density is @@ -343,7 +349,9 @@ public class Canvas { * * @return The value to pass to restoreToCount() to balance this save() */ - public native int save(); + public int save() { + return native_save(mNativeCanvasWrapper, MATRIX_SAVE_FLAG | CLIP_SAVE_FLAG); + } /** * Based on saveFlags, can save the current matrix and clip onto a private @@ -356,7 +364,9 @@ public class Canvas { * to save/restore * @return The value to pass to restoreToCount() to balance this save() */ - public native int save(int saveFlags); + public int save(int saveFlags) { + return native_save(mNativeCanvasWrapper, saveFlags); + } /** * This behaves the same as save(), but in addition it allocates an @@ -375,7 +385,8 @@ public class Canvas { * @return value to pass to restoreToCount() to balance this save() */ public int saveLayer(RectF bounds, Paint paint, int saveFlags) { - return native_saveLayer(mNativeCanvasWrapper, bounds, + return native_saveLayer(mNativeCanvasWrapper, + bounds.left, bounds.top, bounds.right, bounds.bottom, paint != null ? paint.mNativePaint : 0, saveFlags); } @@ -422,7 +433,9 @@ public class Canvas { */ public int saveLayerAlpha(RectF bounds, int alpha, int saveFlags) { alpha = Math.min(255, Math.max(0, alpha)); - return native_saveLayerAlpha(mNativeCanvasWrapper, bounds, alpha, saveFlags); + return native_saveLayerAlpha(mNativeCanvasWrapper, + bounds.left, bounds.top, bounds.right, bounds.bottom, + alpha, saveFlags); } /** @@ -453,13 +466,17 @@ public class Canvas { * modifications to the matrix/clip state since the last save call. It is * an error to call restore() more times than save() was called. */ - public native void restore(); + public void restore() { + native_restore(mNativeCanvasWrapper); + } /** * Returns the number of matrix/clip states on the Canvas' private stack. * This will equal # save() calls - # restore() calls. */ - public native int getSaveCount(); + public int getSaveCount() { + return native_getSaveCount(mNativeCanvasWrapper); + } /** * Efficient way to pop any calls to save() that happened after the save @@ -474,7 +491,9 @@ public class Canvas { * * @param saveCount The save level to restore to. */ - public native void restoreToCount(int saveCount); + public void restoreToCount(int saveCount) { + native_restoreToCount(mNativeCanvasWrapper, saveCount); + } /** * Preconcat the current matrix with the specified translation @@ -482,7 +501,9 @@ public class Canvas { * @param dx The distance to translate in X * @param dy The distance to translate in Y */ - public native void translate(float dx, float dy); + public void translate(float dx, float dy) { + native_translate(mNativeCanvasWrapper, dx, dy); + } /** * Preconcat the current matrix with the specified scale. @@ -490,7 +511,9 @@ public class Canvas { * @param sx The amount to scale in X * @param sy The amount to scale in Y */ - public native void scale(float sx, float sy); + public void scale(float sx, float sy) { + native_scale(mNativeCanvasWrapper, sx, sy); + } /** * Preconcat the current matrix with the specified scale. @@ -511,7 +534,9 @@ public class Canvas { * * @param degrees The amount to rotate, in degrees */ - public native void rotate(float degrees); + public void rotate(float degrees) { + native_rotate(mNativeCanvasWrapper, degrees); + } /** * Preconcat the current matrix with the specified rotation. @@ -532,7 +557,9 @@ public class Canvas { * @param sx The amount to skew in X * @param sy The amount to skew in Y */ - public native void skew(float sx, float sy); + public void skew(float sx, float sy) { + native_skew(mNativeCanvasWrapper, sx, sy); + } /** * Preconcat the current matrix with the specified matrix. If the specified @@ -615,8 +642,11 @@ public class Canvas { * @param rect The rectangle to intersect with the current clip. * @return true if the resulting clip is non-empty */ - public native boolean clipRect(RectF rect); - + public boolean clipRect(RectF rect) { + return native_clipRect(mNativeCanvasWrapper, rect.left, rect.top, rect.right, rect.bottom, + Region.Op.INTERSECT.nativeInt); + } + /** * Intersect the current clip with the specified rectangle, which is * expressed in local coordinates. @@ -624,7 +654,10 @@ public class Canvas { * @param rect The rectangle to intersect with the current clip. * @return true if the resulting clip is non-empty */ - public native boolean clipRect(Rect rect); + public boolean clipRect(Rect rect) { + return native_clipRect(mNativeCanvasWrapper, rect.left, rect.top, rect.right, rect.bottom, + Region.Op.INTERSECT.nativeInt); + } /** * Modify the current clip with the specified rectangle, which is @@ -658,7 +691,10 @@ public class Canvas { * clip * @return true if the resulting clip is non-empty */ - public native boolean clipRect(float left, float top, float right, float bottom); + public boolean clipRect(float left, float top, float right, float bottom) { + return native_clipRect(mNativeCanvasWrapper, left, top, right, bottom, + Region.Op.INTERSECT.nativeInt); + } /** * Intersect the current clip with the specified rectangle, which is @@ -673,7 +709,10 @@ public class Canvas { * clip * @return true if the resulting clip is non-empty */ - public native boolean clipRect(int left, int top, int right, int bottom); + public boolean clipRect(int left, int top, int right, int bottom) { + return native_clipRect(mNativeCanvasWrapper, left, top, right, bottom, + Region.Op.INTERSECT.nativeInt); + } /** * Modify the current clip with the specified path. @@ -780,7 +819,8 @@ public class Canvas { * does not intersect with the canvas' clip */ public boolean quickReject(RectF rect, EdgeType type) { - return native_quickReject(mNativeCanvasWrapper, rect); + return native_quickReject(mNativeCanvasWrapper, + rect.left, rect.top, rect.right, rect.bottom); } /** @@ -925,7 +965,9 @@ public class Canvas { * "points" that are drawn is really (count >> 1). * @param paint The paint used to draw the points */ - public native void drawPoints(float[] pts, int offset, int count, Paint paint); + public void drawPoints(float[] pts, int offset, int count, Paint paint) { + native_drawPoints(mNativeCanvasWrapper, pts, offset, count, paint.mNativePaint); + } /** * Helper for drawPoints() that assumes you want to draw the entire array @@ -937,7 +979,9 @@ public class Canvas { /** * Helper for drawPoints() for drawing a single point. */ - public native void drawPoint(float x, float y, Paint paint); + public void drawPoint(float x, float y, Paint paint) { + native_drawPoint(mNativeCanvasWrapper, x, y, paint.mNativePaint); + } /** * Draw a line segment with the specified start and stop x,y coordinates, @@ -970,7 +1014,9 @@ public class Canvas { * (count >> 2). * @param paint The paint used to draw the points */ - public native void drawLines(float[] pts, int offset, int count, Paint paint); + public void drawLines(float[] pts, int offset, int count, Paint paint) { + native_drawLines(mNativeCanvasWrapper, pts, offset, count, paint.mNativePaint); + } public void drawLines(float[] pts, Paint paint) { drawLines(pts, 0, pts.length, paint); @@ -984,7 +1030,8 @@ public class Canvas { * @param paint The paint used to draw the rect */ public void drawRect(RectF rect, Paint paint) { - native_drawRect(mNativeCanvasWrapper, rect, paint.mNativePaint); + native_drawRect(mNativeCanvasWrapper, + rect.left, rect.top, rect.right, rect.bottom, paint.mNativePaint); } /** @@ -1764,21 +1811,30 @@ public class Canvas { private static native void native_setBitmap(long canvasHandle, long bitmapHandle, boolean copyState); - private static native int native_saveLayer(long nativeCanvas, - RectF bounds, - long nativePaint, - int layerFlags); + private static native boolean native_isOpaque(long canvasHandle); + private static native int native_getWidth(long canvasHandle); + private static native int native_getHeight(long canvasHandle); + + private static native int native_save(long canvasHandle, int saveFlags); private static native int native_saveLayer(long nativeCanvas, float l, float t, float r, float b, long nativePaint, int layerFlags); - private static native int native_saveLayerAlpha(long nativeCanvas, - RectF bounds, int alpha, - int layerFlags); private static native int native_saveLayerAlpha(long nativeCanvas, float l, float t, float r, float b, int alpha, int layerFlags); - + private static native void native_restore(long canvasHandle); + private static native void native_restoreToCount(long canvasHandle, + int saveCount); + private static native int native_getSaveCount(long canvasHandle); + + private static native void native_translate(long canvasHandle, + float dx, float dy); + private static native void native_scale(long canvasHandle, + float sx, float sy); + private static native void native_rotate(long canvasHandle, float degrees); + private static native void native_skew(long canvasHandle, + float sx, float sy); private static native void native_concat(long nativeCanvas, long nativeMatrix); private static native void native_setMatrix(long nativeCanvas, @@ -1800,8 +1856,6 @@ public class Canvas { private static native void native_getCTM(long nativeCanvas, long nativeMatrix); private static native boolean native_quickReject(long nativeCanvas, - RectF rect); - private static native boolean native_quickReject(long nativeCanvas, long nativePath); private static native boolean native_quickReject(long nativeCanvas, float left, float top, @@ -1815,11 +1869,17 @@ public class Canvas { int mode); private static native void native_drawPaint(long nativeCanvas, long nativePaint); + private static native void native_drawPoint(long canvasHandle, float x, float y, + long paintHandle); + private static native void native_drawPoints(long canvasHandle, float[] pts, + int offset, int count, + long paintHandle); private static native void native_drawLine(long nativeCanvas, float startX, float startY, float stopX, float stopY, long nativePaint); - private static native void native_drawRect(long nativeCanvas, RectF rect, - long nativePaint); + private static native void native_drawLines(long canvasHandle, float[] pts, + int offset, int count, + long paintHandle); private static native void native_drawRect(long nativeCanvas, float left, float top, float right, float bottom, -- cgit v1.1