diff options
Diffstat (limited to 'core/jni/android/graphics/Canvas.cpp')
| -rw-r--r-- | core/jni/android/graphics/Canvas.cpp | 603 |
1 files changed, 358 insertions, 245 deletions
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; } |