Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge "Canvas JNI cleanup."

Browse Source
This commit is contained in:
Florin Malita
2014-06-04 16:04:44 +00:00
committed by Android (Google) Code Review
parent a578ab00c4 95d49149cc
commit 676f92e9a7
2 changed files with 169 additions and 228 deletions
Download Patch File Download Diff File Expand all files Collapse all files

267
core/jni/android/graphics/Canvas.cpp
View File

@@ -167,56 +167,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<jint>(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<jint>(height);
}
static jint saveAll(JNIEnv* env, jobject jcanvas) {
NPE_CHECK_RETURN_ZERO(env, jcanvas);
int result = GraphicsJNI::getNativeCanvas(env, jcanvas)->save();
return static_cast<jint>(result);
}
static jint save(JNIEnv* env, jobject jcanvas, jint flagsHandle) {
SkCanvas::SaveFlags flags = static_cast<SkCanvas::SaveFlags>(flagsHandle);
NPE_CHECK_RETURN_ZERO(env, jcanvas);
int result = GraphicsJNI::getNativeCanvas(env, jcanvas)->save(flags);
return static_cast<jint>(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<SkPaint*>(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<SkCanvas::SaveFlags>(flags));
SkCanvas::SaveFlags flags = static_cast<SkCanvas::SaveFlags>(flagsHandle);
return static_cast<jint>(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<SkPaint*>(paintHandle);
SkRect bounds;
@@ -227,22 +204,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<SkCanvas::SaveFlags>(flags));
return static_cast<jint>(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);
@@ -251,9 +214,8 @@ public:
return static_cast<jint>(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;
@@ -261,15 +223,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<jint>(result);
static jint getSaveCount(JNIEnv*, jobject, jlong canvasHandle) {
SkCanvas* canvas = getNativeCanvas(canvasHandle);
return static_cast<jint>(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;
@@ -277,24 +238,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,
@@ -315,56 +276,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);
SkCanvas* c = getNativeCanvas(canvasHandle);
c->clipRect(r, static_cast<SkRegion::Op>(op));
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);
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<SkRegion::Op>(op));
return hasNonEmptyClip(*canvas);
}
static jboolean clipPath(JNIEnv* env, jobject, jlong canvasHandle,
jlong pathHandle, jint op) {
SkCanvas* canvas = getNativeCanvas(canvasHandle);
@@ -387,15 +308,6 @@ public:
canvas->setDrawFilter(reinterpret_cast<SkDrawFilter*>(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);
@@ -445,15 +357,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<SkCanvas::PointMode>(modeHandle);
SkCanvas* canvas = GraphicsJNI::getNativeCanvas(env, jcanvas);
const SkPaint& paint = *GraphicsJNI::getNativePaint(env, jpaint);
SkCanvas* canvas = getNativeCanvas(canvasHandle);
const SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle);
AutoJavaFloatArray autoPts(env, jptsArray);
float* floats = autoPts.ptr();
@@ -473,29 +383,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<SkPaint*>(paintHandle);
canvas->drawPoint(x, y, *paint);
}
static void drawLine__FFFFPaint(JNIEnv* env, jobject, jlong canvasHandle,
@@ -506,15 +415,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<SkPaint*>(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) {
@@ -1150,33 +1050,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},
@@ -1184,8 +1072,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},
@@ -1193,15 +1079,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},

130
graphics/java/android/graphics/Canvas.java
View File

@@ -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);
}
/**
* <p>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,
@@ -1799,8 +1855,6 @@ public class Canvas {
Rect bounds);
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,
@@ -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,