android_graphics_Canvas.cpp revision 8872b38ef403cc2c44aca07d392f5e9426fd7f54
1/* 2 * Copyright (C) 2014 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17#include "jni.h" 18#include "GraphicsJNI.h" 19#include <android_runtime/AndroidRuntime.h> 20 21#include "Canvas.h" 22#include "SkGraphics.h" 23#include "SkPorterDuff.h" 24#include "TypefaceImpl.h" 25 26#include <minikin/Layout.h> 27#include "MinikinSkia.h" 28#include "MinikinUtils.h" 29 30namespace android { 31 32namespace CanvasJNI { 33 34static Canvas* get_canvas(jlong canvasHandle) { 35 return reinterpret_cast<Canvas*>(canvasHandle); 36} 37 38static void finalizer(JNIEnv* env, jobject clazz, jlong canvasHandle) { 39 delete get_canvas(canvasHandle); 40} 41 42// Native wrapper constructor used by Canvas(Bitmap) 43static jlong initRaster(JNIEnv* env, jobject, jlong bitmapHandle) { 44 SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle); 45 return reinterpret_cast<jlong>(Canvas::create_canvas(bitmap)); 46} 47 48// Set the given bitmap as the new draw target (wrapped in a new SkCanvas), 49// optionally copying canvas matrix & clip state. 50static void setBitmap(JNIEnv* env, jobject, jlong canvasHandle, jlong bitmapHandle, 51 jboolean copyState) { 52 SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle); 53 get_canvas(canvasHandle)->setBitmap(bitmap, copyState); 54} 55 56static jboolean isOpaque(JNIEnv*, jobject, jlong canvasHandle) { 57 return get_canvas(canvasHandle)->isOpaque() ? JNI_TRUE : JNI_FALSE; 58} 59 60static jint getWidth(JNIEnv*, jobject, jlong canvasHandle) { 61 return static_cast<jint>(get_canvas(canvasHandle)->width()); 62} 63 64static jint getHeight(JNIEnv*, jobject, jlong canvasHandle) { 65 return static_cast<jint>(get_canvas(canvasHandle)->height()); 66} 67 68static jint getSaveCount(JNIEnv*, jobject, jlong canvasHandle) { 69 return static_cast<jint>(get_canvas(canvasHandle)->getSaveCount()); 70} 71 72static jint save(JNIEnv*, jobject, jlong canvasHandle, jint flagsHandle) { 73 SkCanvas::SaveFlags flags = static_cast<SkCanvas::SaveFlags>(flagsHandle); 74 return static_cast<jint>(get_canvas(canvasHandle)->save(flags)); 75} 76 77static jint saveLayer(JNIEnv* env, jobject, jlong canvasHandle, jfloat l, jfloat t, 78 jfloat r, jfloat b, jlong paintHandle, jint flagsHandle) { 79 SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); 80 SkCanvas::SaveFlags flags = static_cast<SkCanvas::SaveFlags>(flagsHandle); 81 return static_cast<jint>(get_canvas(canvasHandle)->saveLayer(l, t, r, b, paint, flags)); 82} 83 84static jint saveLayerAlpha(JNIEnv* env, jobject, jlong canvasHandle, jfloat l, jfloat t, 85 jfloat r, jfloat b, jint alpha, jint flagsHandle) { 86 SkCanvas::SaveFlags flags = static_cast<SkCanvas::SaveFlags>(flagsHandle); 87 return static_cast<jint>(get_canvas(canvasHandle)->saveLayerAlpha(l, t, r, b, alpha, flags)); 88} 89 90static void restore(JNIEnv* env, jobject, jlong canvasHandle) { 91 Canvas* canvas = get_canvas(canvasHandle); 92 if (canvas->getSaveCount() <= 1) { // cannot restore anymore 93 doThrowISE(env, "Underflow in restore"); 94 return; 95 } 96 canvas->restore(); 97} 98 99static void restoreToCount(JNIEnv* env, jobject, jlong canvasHandle, jint restoreCount) { 100 Canvas* canvas = get_canvas(canvasHandle); 101 if (restoreCount < 1 || restoreCount > canvas->getSaveCount()) { 102 doThrowIAE(env, "Underflow in restoreToCount"); 103 return; 104 } 105 canvas->restoreToCount(restoreCount); 106} 107 108static void getCTM(JNIEnv* env, jobject, jlong canvasHandle, jlong matrixHandle) { 109 SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle); 110 get_canvas(canvasHandle)->getMatrix(matrix); 111} 112 113static void setMatrix(JNIEnv* env, jobject, jlong canvasHandle, jlong matrixHandle) { 114 const SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle); 115 get_canvas(canvasHandle)->setMatrix(matrix ? *matrix : SkMatrix::I()); 116} 117 118static void concat(JNIEnv* env, jobject, jlong canvasHandle, jlong matrixHandle) { 119 const SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle); 120 get_canvas(canvasHandle)->concat(*matrix); 121} 122 123static void rotate(JNIEnv*, jobject, jlong canvasHandle, jfloat degrees) { 124 get_canvas(canvasHandle)->rotate(degrees); 125} 126 127static void scale(JNIEnv*, jobject, jlong canvasHandle, jfloat sx, jfloat sy) { 128 get_canvas(canvasHandle)->scale(sx, sy); 129} 130 131static void skew(JNIEnv*, jobject, jlong canvasHandle, jfloat sx, jfloat sy) { 132 get_canvas(canvasHandle)->skew(sx, sy); 133} 134 135static void translate(JNIEnv*, jobject, jlong canvasHandle, jfloat dx, jfloat dy) { 136 get_canvas(canvasHandle)->translate(dx, dy); 137} 138 139static jboolean getClipBounds(JNIEnv* env, jobject, jlong canvasHandle, jobject bounds) { 140 SkRect r; 141 SkIRect ir; 142 bool result = get_canvas(canvasHandle)->getClipBounds(&r); 143 144 if (!result) { 145 r.setEmpty(); 146 } 147 r.round(&ir); 148 149 (void)GraphicsJNI::irect_to_jrect(ir, env, bounds); 150 return result ? JNI_TRUE : JNI_FALSE; 151} 152 153static jboolean quickRejectRect(JNIEnv* env, jobject, jlong canvasHandle, 154 jfloat left, jfloat top, jfloat right, jfloat bottom) { 155 bool result = get_canvas(canvasHandle)->quickRejectRect(left, top, right, bottom); 156 return result ? JNI_TRUE : JNI_FALSE; 157} 158 159static jboolean quickRejectPath(JNIEnv* env, jobject, jlong canvasHandle, jlong pathHandle) { 160 SkPath* path = reinterpret_cast<SkPath*>(pathHandle); 161 bool result = get_canvas(canvasHandle)->quickRejectPath(*path); 162 return result ? JNI_TRUE : JNI_FALSE; 163} 164 165static jboolean clipRect(JNIEnv*, jobject, jlong canvasHandle, jfloat l, jfloat t, 166 jfloat r, jfloat b, jint opHandle) { 167 SkRegion::Op op = static_cast<SkRegion::Op>(opHandle); 168 bool emptyClip = get_canvas(canvasHandle)->clipRect(l, t, r, b, op); 169 return emptyClip ? JNI_FALSE : JNI_TRUE; 170} 171 172static jboolean clipPath(JNIEnv* env, jobject, jlong canvasHandle, jlong pathHandle, 173 jint opHandle) { 174 SkPath* path = reinterpret_cast<SkPath*>(pathHandle); 175 SkRegion::Op op = static_cast<SkRegion::Op>(opHandle); 176 bool emptyClip = get_canvas(canvasHandle)->clipPath(path, op); 177 return emptyClip ? JNI_FALSE : JNI_TRUE; 178} 179 180static jboolean clipRegion(JNIEnv* env, jobject, jlong canvasHandle, jlong deviceRgnHandle, 181 jint opHandle) { 182 SkRegion* deviceRgn = reinterpret_cast<SkRegion*>(deviceRgnHandle); 183 SkRegion::Op op = static_cast<SkRegion::Op>(opHandle); 184 bool emptyClip = get_canvas(canvasHandle)->clipRegion(deviceRgn, op); 185 return emptyClip ? JNI_FALSE : JNI_TRUE; 186} 187 188static void drawColor(JNIEnv* env, jobject, jlong canvasHandle, jint color, jint modeHandle) { 189 SkPorterDuff::Mode mode = static_cast<SkPorterDuff::Mode>(modeHandle); 190 get_canvas(canvasHandle)->drawColor(color, SkPorterDuff::ToXfermodeMode(mode)); 191} 192 193static void drawPaint(JNIEnv* env, jobject, jlong canvasHandle, jlong paintHandle) { 194 SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); 195 get_canvas(canvasHandle)->drawPaint(*paint); 196} 197 198static void drawPoint(JNIEnv*, jobject, jlong canvasHandle, jfloat x, jfloat y, 199 jlong paintHandle) { 200 const SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); 201 get_canvas(canvasHandle)->drawPoint(x, y, *paint); 202} 203 204static void drawPoints(JNIEnv* env, jobject, jlong canvasHandle, jfloatArray jptsArray, 205 jint offset, jint count, jlong paintHandle) { 206 NPE_CHECK_RETURN_VOID(env, jptsArray); 207 AutoJavaFloatArray autoPts(env, jptsArray); 208 float* floats = autoPts.ptr(); 209 const int length = autoPts.length(); 210 211 if ((offset | count) < 0 || offset + count > length) { 212 doThrowAIOOBE(env); 213 return; 214 } 215 216 const SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); 217 get_canvas(canvasHandle)->drawPoints(floats + offset, count, *paint); 218} 219 220static void drawLine(JNIEnv* env, jobject, jlong canvasHandle, jfloat startX, jfloat startY, 221 jfloat stopX, jfloat stopY, jlong paintHandle) { 222 SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); 223 get_canvas(canvasHandle)->drawLine(startX, startY, stopX, stopY, *paint); 224} 225 226static void drawLines(JNIEnv* env, jobject, jlong canvasHandle, jfloatArray jptsArray, 227 jint offset, jint count, jlong paintHandle) { 228 NPE_CHECK_RETURN_VOID(env, jptsArray); 229 AutoJavaFloatArray autoPts(env, jptsArray); 230 float* floats = autoPts.ptr(); 231 const int length = autoPts.length(); 232 233 if ((offset | count) < 0 || offset + count > length) { 234 doThrowAIOOBE(env); 235 return; 236 } 237 238 const SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); 239 get_canvas(canvasHandle)->drawLines(floats + offset, count, *paint); 240} 241 242static void drawRect(JNIEnv* env, jobject, jlong canvasHandle, jfloat left, jfloat top, 243 jfloat right, jfloat bottom, jlong paintHandle) { 244 const SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); 245 get_canvas(canvasHandle)->drawRect(left, top, right, bottom, *paint); 246} 247 248static void drawRoundRect(JNIEnv* env, jobject, jlong canvasHandle, jfloat left, jfloat top, 249 jfloat right, jfloat bottom, jfloat rx, jfloat ry, jlong paintHandle) { 250 const SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); 251 get_canvas(canvasHandle)->drawRoundRect(left, top, right, bottom, rx, ry, *paint); 252} 253 254static void drawCircle(JNIEnv* env, jobject, jlong canvasHandle, jfloat cx, jfloat cy, 255 jfloat radius, jlong paintHandle) { 256 const SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); 257 get_canvas(canvasHandle)->drawCircle(cx, cy, radius, *paint); 258} 259 260static void drawOval(JNIEnv* env, jobject, jlong canvasHandle, jfloat left, jfloat top, 261 jfloat right, jfloat bottom, jlong paintHandle) { 262 const SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); 263 get_canvas(canvasHandle)->drawOval(left, top, right, bottom, *paint); 264} 265 266static void drawArc(JNIEnv* env, jobject, jlong canvasHandle, jfloat left, jfloat top, 267 jfloat right, jfloat bottom, jfloat startAngle, jfloat sweepAngle, 268 jboolean useCenter, jlong paintHandle) { 269 const SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); 270 get_canvas(canvasHandle)->drawArc(left, top, right, bottom, startAngle, sweepAngle, 271 useCenter, *paint); 272} 273 274static void drawPath(JNIEnv* env, jobject, jlong canvasHandle, jlong pathHandle, 275 jlong paintHandle) { 276 const SkPath* path = reinterpret_cast<SkPath*>(pathHandle); 277 const SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); 278 get_canvas(canvasHandle)->drawPath(*path, *paint); 279} 280 281static void drawVertices(JNIEnv* env, jobject, jlong canvasHandle, 282 jint modeHandle, jint vertexCount, 283 jfloatArray jverts, jint vertIndex, 284 jfloatArray jtexs, jint texIndex, 285 jintArray jcolors, jint colorIndex, 286 jshortArray jindices, jint indexIndex, 287 jint indexCount, jlong paintHandle) { 288 AutoJavaFloatArray vertA(env, jverts, vertIndex + vertexCount); 289 AutoJavaFloatArray texA(env, jtexs, texIndex + vertexCount); 290 AutoJavaIntArray colorA(env, jcolors, colorIndex + vertexCount); 291 AutoJavaShortArray indexA(env, jindices, indexIndex + indexCount); 292 293 const float* verts = vertA.ptr() + vertIndex; 294 const float* texs = texA.ptr() + vertIndex; 295 const int* colors = NULL; 296 const uint16_t* indices = NULL; 297 298 if (jcolors != NULL) { 299 colors = colorA.ptr() + colorIndex; 300 } 301 if (jindices != NULL) { 302 indices = (const uint16_t*)(indexA.ptr() + indexIndex); 303 } 304 305 SkCanvas::VertexMode mode = static_cast<SkCanvas::VertexMode>(modeHandle); 306 const SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); 307 get_canvas(canvasHandle)->drawVertices(mode, vertexCount, verts, texs, colors, 308 indices, indexCount, *paint); 309} 310 311static void drawBitmap(JNIEnv* env, jobject jcanvas, jlong canvasHandle, jlong bitmapHandle, 312 jfloat left, jfloat top, jlong paintHandle, jint canvasDensity, 313 jint screenDensity, jint bitmapDensity) { 314 Canvas* canvas = get_canvas(canvasHandle); 315 const SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle); 316 const SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); 317 318 if (canvasDensity == bitmapDensity || canvasDensity == 0 || bitmapDensity == 0) { 319 if (screenDensity != 0 && screenDensity != bitmapDensity) { 320 SkPaint filteredPaint; 321 if (paint) { 322 filteredPaint = *paint; 323 } 324 filteredPaint.setFilterLevel(SkPaint::kLow_FilterLevel); 325 canvas->drawBitmap(*bitmap, left, top, &filteredPaint); 326 } else { 327 canvas->drawBitmap(*bitmap, left, top, paint); 328 } 329 } else { 330 canvas->save(SkCanvas::kMatrixClip_SaveFlag); 331 SkScalar scale = canvasDensity / (float)bitmapDensity; 332 canvas->translate(left, top); 333 canvas->scale(scale, scale); 334 335 SkPaint filteredPaint; 336 if (paint) { 337 filteredPaint = *paint; 338 } 339 filteredPaint.setFilterLevel(SkPaint::kLow_FilterLevel); 340 341 canvas->drawBitmap(*bitmap, 0, 0, &filteredPaint); 342 canvas->restore(); 343 } 344} 345 346static void drawBitmapMatrix(JNIEnv* env, jobject, jlong canvasHandle, jlong bitmapHandle, 347 jlong matrixHandle, jlong paintHandle) { 348 const SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle); 349 const SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle); 350 const SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); 351 get_canvas(canvasHandle)->drawBitmap(*bitmap, *matrix, paint); 352} 353 354static void drawBitmapRect(JNIEnv* env, jobject, jlong canvasHandle, jlong bitmapHandle, 355 float srcLeft, float srcTop, float srcRight, float srcBottom, 356 float dstLeft, float dstTop, float dstRight, float dstBottom, 357 jlong paintHandle, jint screenDensity, jint bitmapDensity) { 358 Canvas* canvas = get_canvas(canvasHandle); 359 const SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle); 360 const SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); 361 362 if (screenDensity != 0 && screenDensity != bitmapDensity) { 363 SkPaint filteredPaint; 364 if (paint) { 365 filteredPaint = *paint; 366 } 367 filteredPaint.setFilterLevel(SkPaint::kLow_FilterLevel); 368 canvas->drawBitmap(*bitmap, srcLeft, srcTop, srcRight, srcBottom, 369 dstLeft, dstTop, dstRight, dstBottom, &filteredPaint); 370 } else { 371 canvas->drawBitmap(*bitmap, srcLeft, srcTop, srcRight, srcBottom, 372 dstLeft, dstTop, dstRight, dstBottom, paint); 373 } 374} 375 376static void drawBitmapArray(JNIEnv* env, jobject, jlong canvasHandle, 377 jintArray jcolors, jint offset, jint stride, 378 jfloat x, jfloat y, jint width, jint height, 379 jboolean hasAlpha, jlong paintHandle) { 380 // Note: If hasAlpha is false, kRGB_565_SkColorType will be used, which will 381 // correct the alphaType to kOpaque_SkAlphaType. 382 SkImageInfo info = SkImageInfo::Make(width, height, 383 hasAlpha ? kN32_SkColorType : kRGB_565_SkColorType, 384 kPremul_SkAlphaType); 385 SkBitmap bitmap; 386 if (!bitmap.allocPixels(info)) { 387 return; 388 } 389 390 if (!GraphicsJNI::SetPixels(env, jcolors, offset, stride, 0, 0, width, height, bitmap)) { 391 return; 392 } 393 394 const SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); 395 get_canvas(canvasHandle)->drawBitmap(bitmap, x, y, paint); 396} 397 398static void drawBitmapMesh(JNIEnv* env, jobject, jlong canvasHandle, jlong bitmapHandle, 399 jint meshWidth, jint meshHeight, jfloatArray jverts, 400 jint vertIndex, jintArray jcolors, jint colorIndex, jlong paintHandle) { 401 const int ptCount = (meshWidth + 1) * (meshHeight + 1); 402 AutoJavaFloatArray vertA(env, jverts, vertIndex + (ptCount << 1)); 403 AutoJavaIntArray colorA(env, jcolors, colorIndex + ptCount); 404 405 const SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle); 406 const SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); 407 get_canvas(canvasHandle)->drawBitmapMesh(*bitmap, meshWidth, meshHeight, 408 vertA.ptr(), colorA.ptr(), paint); 409} 410 411static void drawTextChars(JNIEnv* env, jobject, jlong canvasHandle, jcharArray text, 412 jint index, jint count, jfloat x, jfloat y, jint bidiFlags, 413 jlong paintHandle, jlong typefaceHandle) { 414 SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); 415 TypefaceImpl* typeface = reinterpret_cast<TypefaceImpl*>(typefaceHandle); 416 jchar* jchars = env->GetCharArrayElements(text, NULL); 417 get_canvas(canvasHandle)->drawText(jchars + index, 0, count, count, x, y, 418 bidiFlags, *paint, typeface); 419 env->ReleaseCharArrayElements(text, jchars, JNI_ABORT); 420} 421 422static void drawTextString(JNIEnv* env, jobject, jlong canvasHandle, jstring text, 423 jint start, jint end, jfloat x, jfloat y, jint bidiFlags, 424 jlong paintHandle, jlong typefaceHandle) { 425 SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); 426 TypefaceImpl* typeface = reinterpret_cast<TypefaceImpl*>(typefaceHandle); 427 const int count = end - start; 428 const jchar* jchars = env->GetStringChars(text, NULL); 429 get_canvas(canvasHandle)->drawText(jchars + start, 0, count, count, x, y, 430 bidiFlags, *paint, typeface); 431 env->ReleaseStringChars(text, jchars); 432} 433 434static void drawTextRunChars(JNIEnv* env, jobject, jlong canvasHandle, jcharArray text, jint index, 435 jint count, jint contextIndex, jint contextCount, jfloat x, jfloat y, 436 jboolean isRtl, jlong paintHandle, jlong typefaceHandle) { 437 SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); 438 TypefaceImpl* typeface = reinterpret_cast<TypefaceImpl*>(typefaceHandle); 439 440 const int bidiFlags = isRtl ? kBidi_Force_RTL : kBidi_Force_LTR; 441 jchar* jchars = env->GetCharArrayElements(text, NULL); 442 get_canvas(canvasHandle)->drawText(jchars + contextIndex, index - contextIndex, count, 443 contextCount, x, y, bidiFlags, *paint, typeface); 444 env->ReleaseCharArrayElements(text, jchars, JNI_ABORT); 445} 446 447static void drawTextRunString(JNIEnv* env, jobject obj, jlong canvasHandle, jstring text, 448 jint start, jint end, jint contextStart, jint contextEnd, 449 jfloat x, jfloat y, jboolean isRtl, jlong paintHandle, 450 jlong typefaceHandle) { 451 SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); 452 TypefaceImpl* typeface = reinterpret_cast<TypefaceImpl*>(typefaceHandle); 453 454 int bidiFlags = isRtl ? kBidi_Force_RTL : kBidi_Force_LTR; 455 jint count = end - start; 456 jint contextCount = contextEnd - contextStart; 457 const jchar* jchars = env->GetStringChars(text, NULL); 458 get_canvas(canvasHandle)->drawText(jchars + contextStart, start - contextStart, count, 459 contextCount, x, y, bidiFlags, *paint, typeface); 460 env->ReleaseStringChars(text, jchars); 461} 462 463static void drawPosTextChars(JNIEnv* env, jobject, jlong canvasHandle, jcharArray text, 464 jint index, jint count, jfloatArray pos, jlong paintHandle) { 465 SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); 466 jchar* jchars = text ? env->GetCharArrayElements(text, NULL) : NULL; 467 float* posArray = pos ? env->GetFloatArrayElements(pos, NULL) : NULL; 468 int posCount = pos ? env->GetArrayLength(pos) >> 1: 0; 469 470 get_canvas(canvasHandle)->drawPosText(jchars + index, posArray, count << 1, posCount, *paint); 471 472 if (text) { 473 env->ReleaseCharArrayElements(text, jchars, 0); 474 } 475 if (pos) { 476 env->ReleaseFloatArrayElements(pos, posArray, 0); 477 } 478} 479 480 481static void drawPosTextString(JNIEnv* env, jobject, jlong canvasHandle, jstring text, 482 jfloatArray pos, jlong paintHandle) { 483 SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); 484 const jchar* jchars = text ? env->GetStringChars(text, NULL) : NULL; 485 int byteLength = text ? env->GetStringLength(text) : 0; 486 float* posArray = pos ? env->GetFloatArrayElements(pos, NULL) : NULL; 487 int posCount = pos ? env->GetArrayLength(pos) >> 1: 0; 488 489 get_canvas(canvasHandle)->drawPosText(jchars , posArray, byteLength << 1, posCount, *paint); 490 491 if (text) { 492 env->ReleaseStringChars(text, jchars); 493 } 494 if (pos) { 495 env->ReleaseFloatArrayElements(pos, posArray, 0); 496 } 497} 498 499class DrawTextOnPathFunctor { 500public: 501 DrawTextOnPathFunctor(const Layout& layout, Canvas* canvas, float hOffset, 502 float vOffset, const SkPaint& paint, const SkPath& path) 503 : layout(layout), canvas(canvas), hOffset(hOffset), vOffset(vOffset), 504 paint(paint), path(path) { 505 } 506 void operator()(size_t start, size_t end) { 507 uint16_t glyphs[1]; 508 for (size_t i = start; i < end; i++) { 509 glyphs[0] = layout.getGlyphId(i); 510 float x = hOffset + layout.getX(i); 511 float y = vOffset + layout.getY(i); 512 canvas->drawTextOnPath(glyphs, 1, path, x, y, paint); 513 } 514 } 515private: 516 const Layout& layout; 517 Canvas* canvas; 518 float hOffset; 519 float vOffset; 520 const SkPaint& paint; 521 const SkPath& path; 522}; 523 524static void drawTextOnPath(Canvas* canvas, const uint16_t* text, int count, int bidiFlags, 525 const SkPath& path, float hOffset, float vOffset, 526 const SkPaint& paint, TypefaceImpl* typeface) { 527 SkPaint paintCopy(paint); 528 Layout layout; 529 std::string css = MinikinUtils::setLayoutProperties(&layout, &paintCopy, bidiFlags, typeface); 530 layout.doLayout(text, 0, count, count, css); 531 hOffset += MinikinUtils::hOffsetForTextAlign(&paintCopy, layout, path); 532 533 // Set align to left for drawing, as we don't want individual 534 // glyphs centered or right-aligned; the offset above takes 535 // care of all alignment. 536 paintCopy.setTextAlign(SkPaint::kLeft_Align); 537 538 DrawTextOnPathFunctor f(layout, canvas, hOffset, vOffset, paintCopy, path); 539 MinikinUtils::forFontRun(layout, &paintCopy, f); 540} 541 542static void drawTextOnPathChars(JNIEnv* env, jobject, jlong canvasHandle, jcharArray text, 543 jint index, jint count, jlong pathHandle, jfloat hOffset, 544 jfloat vOffset, jint bidiFlags, jlong paintHandle, 545 jlong typefaceHandle) { 546 SkPath* path = reinterpret_cast<SkPath*>(pathHandle); 547 SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); 548 TypefaceImpl* typeface = reinterpret_cast<TypefaceImpl*>(typefaceHandle); 549 550 jchar* jchars = env->GetCharArrayElements(text, NULL); 551 552 drawTextOnPath(get_canvas(canvasHandle), jchars + index, count, bidiFlags, *path, 553 hOffset, vOffset, *paint, typeface); 554 555 env->ReleaseCharArrayElements(text, jchars, 0); 556} 557 558static void drawTextOnPathString(JNIEnv* env, jobject, jlong canvasHandle, jstring text, 559 jlong pathHandle, jfloat hOffset, jfloat vOffset, 560 jint bidiFlags, jlong paintHandle, jlong typefaceHandle) { 561 SkPath* path = reinterpret_cast<SkPath*>(pathHandle); 562 SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); 563 TypefaceImpl* typeface = reinterpret_cast<TypefaceImpl*>(typefaceHandle); 564 565 const jchar* jchars = env->GetStringChars(text, NULL); 566 int count = env->GetStringLength(text); 567 568 drawTextOnPath(get_canvas(canvasHandle), jchars, count, bidiFlags, *path, 569 hOffset, vOffset, *paint, typeface); 570 571 env->ReleaseStringChars(text, jchars); 572} 573 574static void setDrawFilter(JNIEnv* env, jobject, jlong canvasHandle, jlong filterHandle) { 575 get_canvas(canvasHandle)->setDrawFilter(reinterpret_cast<SkDrawFilter*>(filterHandle)); 576} 577 578static void freeCaches(JNIEnv* env, jobject) { 579 SkGraphics::PurgeFontCache(); 580} 581 582static void freeTextLayoutCaches(JNIEnv* env, jobject) { 583 Layout::purgeCaches(); 584} 585 586}; // namespace CanvasJNI 587 588static JNINativeMethod gMethods[] = { 589 {"finalizer", "(J)V", (void*) CanvasJNI::finalizer}, 590 {"initRaster", "(J)J", (void*) CanvasJNI::initRaster}, 591 {"native_setBitmap", "(JJZ)V", (void*) CanvasJNI::setBitmap}, 592 {"native_isOpaque","(J)Z", (void*) CanvasJNI::isOpaque}, 593 {"native_getWidth","(J)I", (void*) CanvasJNI::getWidth}, 594 {"native_getHeight","(J)I", (void*) CanvasJNI::getHeight}, 595 {"native_save","(JI)I", (void*) CanvasJNI::save}, 596 {"native_saveLayer","(JFFFFJI)I", (void*) CanvasJNI::saveLayer}, 597 {"native_saveLayerAlpha","(JFFFFII)I", (void*) CanvasJNI::saveLayerAlpha}, 598 {"native_getSaveCount","(J)I", (void*) CanvasJNI::getSaveCount}, 599 {"native_restore","(J)V", (void*) CanvasJNI::restore}, 600 {"native_restoreToCount","(JI)V", (void*) CanvasJNI::restoreToCount}, 601 {"native_getCTM", "(JJ)V", (void*)CanvasJNI::getCTM}, 602 {"native_setMatrix","(JJ)V", (void*) CanvasJNI::setMatrix}, 603 {"native_concat","(JJ)V", (void*) CanvasJNI::concat}, 604 {"native_rotate","(JF)V", (void*) CanvasJNI::rotate}, 605 {"native_scale","(JFF)V", (void*) CanvasJNI::scale}, 606 {"native_skew","(JFF)V", (void*) CanvasJNI::skew}, 607 {"native_translate","(JFF)V", (void*) CanvasJNI::translate}, 608 {"native_getClipBounds","(JLandroid/graphics/Rect;)Z", (void*) CanvasJNI::getClipBounds}, 609 {"native_quickReject","(JJ)Z", (void*) CanvasJNI::quickRejectPath}, 610 {"native_quickReject","(JFFFF)Z", (void*)CanvasJNI::quickRejectRect}, 611 {"native_clipRect","(JFFFFI)Z", (void*) CanvasJNI::clipRect}, 612 {"native_clipPath","(JJI)Z", (void*) CanvasJNI::clipPath}, 613 {"native_clipRegion","(JJI)Z", (void*) CanvasJNI::clipRegion}, 614 {"native_drawColor","(JII)V", (void*) CanvasJNI::drawColor}, 615 {"native_drawPaint","(JJ)V", (void*) CanvasJNI::drawPaint}, 616 {"native_drawPoint", "(JFFJ)V", (void*) CanvasJNI::drawPoint}, 617 {"native_drawPoints", "(J[FIIJ)V", (void*) CanvasJNI::drawPoints}, 618 {"native_drawLine", "(JFFFFJ)V", (void*) CanvasJNI::drawLine}, 619 {"native_drawLines", "(J[FIIJ)V", (void*) CanvasJNI::drawLines}, 620 {"native_drawRect","(JFFFFJ)V", (void*) CanvasJNI::drawRect}, 621 {"native_drawRoundRect","(JFFFFFFJ)V", (void*) CanvasJNI::drawRoundRect}, 622 {"native_drawCircle","(JFFFJ)V", (void*) CanvasJNI::drawCircle}, 623 {"native_drawOval","(JFFFFJ)V", (void*) CanvasJNI::drawOval}, 624 {"native_drawArc","(JFFFFFFZJ)V", (void*) CanvasJNI::drawArc}, 625 {"native_drawPath","(JJJ)V", (void*) CanvasJNI::drawPath}, 626 {"nativeDrawVertices", "(JII[FI[FI[II[SIIJ)V", (void*)CanvasJNI::drawVertices}, 627 {"native_drawBitmap","(JJFFJIII)V", (void*) CanvasJNI::drawBitmap}, 628 {"nativeDrawBitmapMatrix", "(JJJJ)V", (void*)CanvasJNI::drawBitmapMatrix}, 629 {"native_drawBitmap","(JJFFFFFFFFJII)V", (void*) CanvasJNI::drawBitmapRect}, 630 {"native_drawBitmap", "(J[IIIFFIIZJ)V", (void*)CanvasJNI::drawBitmapArray}, 631 {"nativeDrawBitmapMesh", "(JJII[FI[IIJ)V", (void*)CanvasJNI::drawBitmapMesh}, 632 {"native_drawText","(J[CIIFFIJJ)V", (void*) CanvasJNI::drawTextChars}, 633 {"native_drawText","(JLjava/lang/String;IIFFIJJ)V", (void*) CanvasJNI::drawTextString}, 634 {"native_drawTextRun","(J[CIIIIFFZJJ)V", (void*) CanvasJNI::drawTextRunChars}, 635 {"native_drawTextRun","(JLjava/lang/String;IIIIFFZJJ)V", (void*) CanvasJNI::drawTextRunString}, 636 {"native_drawTextOnPath","(J[CIIJFFIJJ)V", (void*) CanvasJNI::drawTextOnPathChars}, 637 {"native_drawTextOnPath","(JLjava/lang/String;JFFIJJ)V", (void*) CanvasJNI::drawTextOnPathString}, 638 {"nativeSetDrawFilter", "(JJ)V", (void*) CanvasJNI::setDrawFilter}, 639 {"freeCaches", "()V", (void*) CanvasJNI::freeCaches}, 640 {"freeTextLayoutCaches", "()V", (void*) CanvasJNI::freeTextLayoutCaches} 641}; 642 643int register_android_graphics_Canvas(JNIEnv* env) { 644 return AndroidRuntime::registerNativeMethods(env, "android/graphics/Canvas", gMethods, NELEM(gMethods)); 645} 646 647}; // namespace android 648