android_graphics_Canvas.cpp revision f5d6c555c3430f6e423952ba3ab024380e550bba
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 const char* textArray = reinterpret_cast<const char*>(jchars) + index; 418 get_canvas(canvasHandle)->drawText(textArray, 0, count, count, x, y, 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 const char* textArray = reinterpret_cast<const char*>(jchars) + start; 430 get_canvas(canvasHandle)->drawText(textArray, 0, count, count, x, y, 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 const char* textArray = reinterpret_cast<const char*>(jchars) + contextIndex; 443 get_canvas(canvasHandle)->drawText(textArray, index - contextIndex, count, contextCount, 444 x, y, bidiFlags, *paint, typeface); 445 env->ReleaseCharArrayElements(text, jchars, JNI_ABORT); 446} 447 448static void drawTextRunString(JNIEnv* env, jobject obj, jlong canvasHandle, jstring text, 449 jint start, jint end, jint contextStart, jint contextEnd, 450 jfloat x, jfloat y, jboolean isRtl, jlong paintHandle, 451 jlong typefaceHandle) { 452 SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); 453 TypefaceImpl* typeface = reinterpret_cast<TypefaceImpl*>(typefaceHandle); 454 455 int bidiFlags = isRtl ? kBidi_Force_RTL : kBidi_Force_LTR; 456 jint count = end - start; 457 jint contextCount = contextEnd - contextStart; 458 const jchar* jchars = env->GetStringChars(text, NULL); 459 const char* textArray = reinterpret_cast<const char*>(jchars) + contextStart; 460 get_canvas(canvasHandle)->drawText(textArray, start - contextStart, count, contextCount, 461 x, y, bidiFlags, *paint, typeface); 462 env->ReleaseStringChars(text, jchars); 463} 464 465static void drawPosTextChars(JNIEnv* env, jobject, jlong canvasHandle, jcharArray text, 466 jint index, jint count, jfloatArray pos, jlong paintHandle) { 467 SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); 468 jchar* jchars = text ? env->GetCharArrayElements(text, NULL) : NULL; 469 float* posArray = pos ? env->GetFloatArrayElements(pos, NULL) : NULL; 470 int posCount = pos ? env->GetArrayLength(pos) >> 1: 0; 471 472 const char* textArray = reinterpret_cast<const char*>(jchars) + index; 473 get_canvas(canvasHandle)->drawPosText(textArray, posArray, count << 1, posCount, *paint); 474 475 if (text) { 476 env->ReleaseCharArrayElements(text, jchars, 0); 477 } 478 if (pos) { 479 env->ReleaseFloatArrayElements(pos, posArray, 0); 480 } 481} 482 483 484static void drawPosTextString(JNIEnv* env, jobject, jlong canvasHandle, jstring text, 485 jfloatArray pos, jlong paintHandle) { 486 SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); 487 const jchar* jchars = text ? env->GetStringChars(text, NULL) : NULL; 488 int byteLength = text ? env->GetStringLength(text) : 0; 489 float* posArray = pos ? env->GetFloatArrayElements(pos, NULL) : NULL; 490 int posCount = pos ? env->GetArrayLength(pos) >> 1: 0; 491 492 const char* textArray = reinterpret_cast<const char*>(jchars); 493 get_canvas(canvasHandle)->drawPosText(textArray , posArray, byteLength << 1, posCount, *paint); 494 495 if (text) { 496 env->ReleaseStringChars(text, jchars); 497 } 498 if (pos) { 499 env->ReleaseFloatArrayElements(pos, posArray, 0); 500 } 501} 502 503class DrawTextOnPathFunctor { 504public: 505 DrawTextOnPathFunctor(const Layout& layout, Canvas* canvas, float hOffset, 506 float vOffset, const SkPaint& paint, const SkPath& path) 507 : layout(layout), canvas(canvas), hOffset(hOffset), vOffset(vOffset), 508 paint(paint), path(path) { 509 } 510 void operator()(size_t start, size_t end) { 511 uint16_t glyphs[1]; 512 for (size_t i = start; i < end; i++) { 513 glyphs[0] = layout.getGlyphId(i); 514 float x = hOffset + layout.getX(i); 515 float y = vOffset + layout.getY(i); 516 canvas->drawTextOnPath((const char*) glyphs, 1, path, x, y, paint); 517 } 518 } 519private: 520 const Layout& layout; 521 Canvas* canvas; 522 float hOffset; 523 float vOffset; 524 const SkPaint& paint; 525 const SkPath& path; 526}; 527 528static void drawTextOnPath(Canvas* canvas, const char* text, int count, int bidiFlags, 529 const SkPath& path, float hOffset, float vOffset, 530 const SkPaint& paint, TypefaceImpl* typeface) { 531 SkPaint paintCopy(paint); 532 Layout layout; 533 std::string css = MinikinUtils::setLayoutProperties(&layout, &paintCopy, bidiFlags, typeface); 534 layout.doLayout((uint16_t*)text, 0, count, count, css); 535 hOffset += MinikinUtils::hOffsetForTextAlign(&paintCopy, layout, path); 536 537 // Set align to left for drawing, as we don't want individual 538 // glyphs centered or right-aligned; the offset above takes 539 // care of all alignment. 540 paintCopy.setTextAlign(SkPaint::kLeft_Align); 541 542 DrawTextOnPathFunctor f(layout, canvas, hOffset, vOffset, paintCopy, path); 543 MinikinUtils::forFontRun(layout, &paintCopy, f); 544} 545 546static void drawTextOnPathChars(JNIEnv* env, jobject, jlong canvasHandle, jcharArray text, 547 jint index, jint count, jlong pathHandle, jfloat hOffset, 548 jfloat vOffset, jint bidiFlags, jlong paintHandle, 549 jlong typefaceHandle) { 550 SkPath* path = reinterpret_cast<SkPath*>(pathHandle); 551 SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); 552 TypefaceImpl* typeface = reinterpret_cast<TypefaceImpl*>(typefaceHandle); 553 554 jchar* jchars = env->GetCharArrayElements(text, NULL); 555 const char* textArray = reinterpret_cast<const char*>(jchars); 556 557 drawTextOnPath(get_canvas(canvasHandle), textArray + index, count, bidiFlags, *path, 558 hOffset, vOffset, *paint, typeface); 559 560 env->ReleaseCharArrayElements(text, jchars, 0); 561} 562 563static void drawTextOnPathString(JNIEnv* env, jobject, jlong canvasHandle, jstring text, 564 jlong pathHandle, jfloat hOffset, jfloat vOffset, 565 jint bidiFlags, jlong paintHandle, jlong typefaceHandle) { 566 SkPath* path = reinterpret_cast<SkPath*>(pathHandle); 567 SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle); 568 TypefaceImpl* typeface = reinterpret_cast<TypefaceImpl*>(typefaceHandle); 569 570 const jchar* jchars = env->GetStringChars(text, NULL); 571 const char* textArray = reinterpret_cast<const char*>(jchars); 572 int count = env->GetStringLength(text); 573 574 drawTextOnPath(get_canvas(canvasHandle), textArray, count, bidiFlags, *path, 575 hOffset, vOffset, *paint, typeface); 576 577 env->ReleaseStringChars(text, jchars); 578} 579 580static void setDrawFilter(JNIEnv* env, jobject, jlong canvasHandle, jlong filterHandle) { 581 get_canvas(canvasHandle)->setDrawFilter(reinterpret_cast<SkDrawFilter*>(filterHandle)); 582} 583 584static void freeCaches(JNIEnv* env, jobject) { 585 SkGraphics::PurgeFontCache(); 586} 587 588static void freeTextLayoutCaches(JNIEnv* env, jobject) { 589 Layout::purgeCaches(); 590} 591 592}; // namespace CanvasJNI 593 594static JNINativeMethod gMethods[] = { 595 {"finalizer", "(J)V", (void*) CanvasJNI::finalizer}, 596 {"initRaster", "(J)J", (void*) CanvasJNI::initRaster}, 597 {"native_setBitmap", "(JJZ)V", (void*) CanvasJNI::setBitmap}, 598 {"native_isOpaque","(J)Z", (void*) CanvasJNI::isOpaque}, 599 {"native_getWidth","(J)I", (void*) CanvasJNI::getWidth}, 600 {"native_getHeight","(J)I", (void*) CanvasJNI::getHeight}, 601 {"native_save","(JI)I", (void*) CanvasJNI::save}, 602 {"native_saveLayer","(JFFFFJI)I", (void*) CanvasJNI::saveLayer}, 603 {"native_saveLayerAlpha","(JFFFFII)I", (void*) CanvasJNI::saveLayerAlpha}, 604 {"native_getSaveCount","(J)I", (void*) CanvasJNI::getSaveCount}, 605 {"native_restore","(J)V", (void*) CanvasJNI::restore}, 606 {"native_restoreToCount","(JI)V", (void*) CanvasJNI::restoreToCount}, 607 {"native_getCTM", "(JJ)V", (void*)CanvasJNI::getCTM}, 608 {"native_setMatrix","(JJ)V", (void*) CanvasJNI::setMatrix}, 609 {"native_concat","(JJ)V", (void*) CanvasJNI::concat}, 610 {"native_rotate","(JF)V", (void*) CanvasJNI::rotate}, 611 {"native_scale","(JFF)V", (void*) CanvasJNI::scale}, 612 {"native_skew","(JFF)V", (void*) CanvasJNI::skew}, 613 {"native_translate","(JFF)V", (void*) CanvasJNI::translate}, 614 {"native_getClipBounds","(JLandroid/graphics/Rect;)Z", (void*) CanvasJNI::getClipBounds}, 615 {"native_quickReject","(JJ)Z", (void*) CanvasJNI::quickRejectPath}, 616 {"native_quickReject","(JFFFF)Z", (void*)CanvasJNI::quickRejectRect}, 617 {"native_clipRect","(JFFFFI)Z", (void*) CanvasJNI::clipRect}, 618 {"native_clipPath","(JJI)Z", (void*) CanvasJNI::clipPath}, 619 {"native_clipRegion","(JJI)Z", (void*) CanvasJNI::clipRegion}, 620 {"native_drawColor","(JII)V", (void*) CanvasJNI::drawColor}, 621 {"native_drawPaint","(JJ)V", (void*) CanvasJNI::drawPaint}, 622 {"native_drawPoint", "(JFFJ)V", (void*) CanvasJNI::drawPoint}, 623 {"native_drawPoints", "(J[FIIJ)V", (void*) CanvasJNI::drawPoints}, 624 {"native_drawLine", "(JFFFFJ)V", (void*) CanvasJNI::drawLine}, 625 {"native_drawLines", "(J[FIIJ)V", (void*) CanvasJNI::drawLines}, 626 {"native_drawRect","(JFFFFJ)V", (void*) CanvasJNI::drawRect}, 627 {"native_drawRoundRect","(JFFFFFFJ)V", (void*) CanvasJNI::drawRoundRect}, 628 {"native_drawCircle","(JFFFJ)V", (void*) CanvasJNI::drawCircle}, 629 {"native_drawOval","(JFFFFJ)V", (void*) CanvasJNI::drawOval}, 630 {"native_drawArc","(JFFFFFFZJ)V", (void*) CanvasJNI::drawArc}, 631 {"native_drawPath","(JJJ)V", (void*) CanvasJNI::drawPath}, 632 {"nativeDrawVertices", "(JII[FI[FI[II[SIIJ)V", (void*)CanvasJNI::drawVertices}, 633 {"native_drawBitmap","(JJFFJIII)V", (void*) CanvasJNI::drawBitmap}, 634 {"nativeDrawBitmapMatrix", "(JJJJ)V", (void*)CanvasJNI::drawBitmapMatrix}, 635 {"native_drawBitmap","(JJFFFFFFFFJII)V", (void*) CanvasJNI::drawBitmapRect}, 636 {"native_drawBitmap", "(J[IIIFFIIZJ)V", (void*)CanvasJNI::drawBitmapArray}, 637 {"nativeDrawBitmapMesh", "(JJII[FI[IIJ)V", (void*)CanvasJNI::drawBitmapMesh}, 638 {"native_drawText","(J[CIIFFIJJ)V", (void*) CanvasJNI::drawTextChars}, 639 {"native_drawText","(JLjava/lang/String;IIFFIJJ)V", (void*) CanvasJNI::drawTextString}, 640 {"native_drawTextRun","(J[CIIIIFFZJJ)V", (void*) CanvasJNI::drawTextRunChars}, 641 {"native_drawTextRun","(JLjava/lang/String;IIIIFFZJJ)V", (void*) CanvasJNI::drawTextRunString}, 642 {"native_drawTextOnPath","(J[CIIJFFIJJ)V", (void*) CanvasJNI::drawTextOnPathChars}, 643 {"native_drawTextOnPath","(JLjava/lang/String;JFFIJJ)V", (void*) CanvasJNI::drawTextOnPathString}, 644 {"nativeSetDrawFilter", "(JJ)V", (void*) CanvasJNI::setDrawFilter}, 645 {"freeCaches", "()V", (void*) CanvasJNI::freeCaches}, 646 {"freeTextLayoutCaches", "()V", (void*) CanvasJNI::freeTextLayoutCaches} 647}; 648 649int register_android_graphics_Canvas(JNIEnv* env) { 650 return AndroidRuntime::registerNativeMethods(env, "android/graphics/Canvas", gMethods, NELEM(gMethods)); 651} 652 653}; // namespace android 654