android_graphics_Canvas.cpp revision 8dfaa4904205772cdceee63ef3989bcdedf1a914
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 "core_jni_helpers.h" 20 21#include "Canvas.h" 22#include "SkDrawFilter.h" 23#include "SkGraphics.h" 24#include "SkPorterDuff.h" 25#include "Paint.h" 26#include "TypefaceImpl.h" 27 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 Paint* paint = reinterpret_cast<Paint*>(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 Paint* paint = reinterpret_cast<Paint*>(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 Paint* paint = reinterpret_cast<Paint*>(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 Paint* paint = reinterpret_cast<Paint*>(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 Paint* paint = reinterpret_cast<Paint*>(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 Paint* paint = reinterpret_cast<Paint*>(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 Paint* paint = reinterpret_cast<Paint*>(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 Paint* paint = reinterpret_cast<Paint*>(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 Paint* paint = reinterpret_cast<Paint*>(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 Paint* paint = reinterpret_cast<Paint*>(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 Paint* paint = reinterpret_cast<Paint*>(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 Paint* paint = reinterpret_cast<Paint*>(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 Paint* paint = reinterpret_cast<Paint*>(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 Paint* paint = reinterpret_cast<Paint*>(paintHandle); 317 318 if (canvasDensity == bitmapDensity || canvasDensity == 0 || bitmapDensity == 0) { 319 if (screenDensity != 0 && screenDensity != bitmapDensity) { 320 Paint filteredPaint; 321 if (paint) { 322 filteredPaint = *paint; 323 } 324 filteredPaint.setFilterLevel(Paint::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 Paint filteredPaint; 336 if (paint) { 337 filteredPaint = *paint; 338 } 339 filteredPaint.setFilterLevel(Paint::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 Paint* paint = reinterpret_cast<Paint*>(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 Paint* paint = reinterpret_cast<Paint*>(paintHandle); 361 362 if (screenDensity != 0 && screenDensity != bitmapDensity) { 363 Paint filteredPaint; 364 if (paint) { 365 filteredPaint = *paint; 366 } 367 filteredPaint.setFilterLevel(Paint::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.tryAllocPixels(info)) { 387 return; 388 } 389 390 if (!GraphicsJNI::SetPixels(env, jcolors, offset, stride, 0, 0, width, height, bitmap)) { 391 return; 392 } 393 394 const Paint* paint = reinterpret_cast<Paint*>(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 Paint* paint = reinterpret_cast<Paint*>(paintHandle); 407 get_canvas(canvasHandle)->drawBitmapMesh(*bitmap, meshWidth, meshHeight, 408 vertA.ptr(), colorA.ptr(), paint); 409} 410 411class DrawTextFunctor { 412public: 413 DrawTextFunctor(const Layout& layout, Canvas* canvas, uint16_t* glyphs, float* pos, 414 const SkPaint& paint, float x, float y, MinikinRect& bounds, 415 float totalAdvance) 416 : layout(layout), canvas(canvas), glyphs(glyphs), pos(pos), paint(paint), 417 x(x), y(y), bounds(bounds), totalAdvance(totalAdvance) { } 418 419 void operator()(size_t start, size_t end) { 420 if (canvas->drawTextAbsolutePos()) { 421 for (size_t i = start; i < end; i++) { 422 glyphs[i] = layout.getGlyphId(i); 423 pos[2 * i] = x + layout.getX(i); 424 pos[2 * i + 1] = y + layout.getY(i); 425 } 426 } else { 427 for (size_t i = start; i < end; i++) { 428 glyphs[i] = layout.getGlyphId(i); 429 pos[2 * i] = layout.getX(i); 430 pos[2 * i + 1] = layout.getY(i); 431 } 432 } 433 434 size_t glyphCount = end - start; 435 canvas->drawText(glyphs + start, pos + (2 * start), glyphCount, paint, x, y, 436 bounds.mLeft, bounds.mTop, bounds.mRight, bounds.mBottom, 437 totalAdvance); 438 } 439private: 440 const Layout& layout; 441 Canvas* canvas; 442 uint16_t* glyphs; 443 float* pos; 444 const SkPaint& paint; 445 float x; 446 float y; 447 MinikinRect& bounds; 448 float totalAdvance; 449}; 450 451// Same values used by Skia 452#define kStdStrikeThru_Offset (-6.0f / 21.0f) 453#define kStdUnderline_Offset (1.0f / 9.0f) 454#define kStdUnderline_Thickness (1.0f / 18.0f) 455 456void drawTextDecorations(Canvas* canvas, float x, float y, float length, const SkPaint& paint) { 457 uint32_t flags; 458 SkDrawFilter* drawFilter = canvas->getDrawFilter(); 459 if (drawFilter) { 460 SkPaint paintCopy(paint); 461 drawFilter->filter(&paintCopy, SkDrawFilter::kText_Type); 462 flags = paintCopy.getFlags(); 463 } else { 464 flags = paint.getFlags(); 465 } 466 if (flags & (SkPaint::kUnderlineText_Flag | SkPaint::kStrikeThruText_Flag)) { 467 SkScalar left = x; 468 SkScalar right = x + length; 469 float textSize = paint.getTextSize(); 470 float strokeWidth = fmax(textSize * kStdUnderline_Thickness, 1.0f); 471 if (flags & SkPaint::kUnderlineText_Flag) { 472 SkScalar top = y + textSize * kStdUnderline_Offset - 0.5f * strokeWidth; 473 SkScalar bottom = y + textSize * kStdUnderline_Offset + 0.5f * strokeWidth; 474 canvas->drawRect(left, top, right, bottom, paint); 475 } 476 if (flags & SkPaint::kStrikeThruText_Flag) { 477 SkScalar top = y + textSize * kStdStrikeThru_Offset - 0.5f * strokeWidth; 478 SkScalar bottom = y + textSize * kStdStrikeThru_Offset + 0.5f * strokeWidth; 479 canvas->drawRect(left, top, right, bottom, paint); 480 } 481 } 482} 483 484void drawText(Canvas* canvas, const uint16_t* text, int start, int count, int contextCount, 485 float x, float y, int bidiFlags, const Paint& origPaint, TypefaceImpl* typeface) { 486 // minikin may modify the original paint 487 Paint paint(origPaint); 488 489 Layout layout; 490 MinikinUtils::doLayout(&layout, &paint, bidiFlags, typeface, text, start, count, contextCount); 491 492 size_t nGlyphs = layout.nGlyphs(); 493 uint16_t* glyphs = new uint16_t[nGlyphs]; 494 float* pos = new float[nGlyphs * 2]; 495 496 x += MinikinUtils::xOffsetForTextAlign(&paint, layout); 497 498 MinikinRect bounds; 499 layout.getBounds(&bounds); 500 if (!canvas->drawTextAbsolutePos()) { 501 bounds.offset(x, y); 502 } 503 504 DrawTextFunctor f(layout, canvas, glyphs, pos, paint, x, y, bounds, layout.getAdvance()); 505 MinikinUtils::forFontRun(layout, &paint, f); 506 507 drawTextDecorations(canvas, x, y, layout.getAdvance(), paint); 508 509 delete[] glyphs; 510 delete[] pos; 511} 512 513static void drawTextChars(JNIEnv* env, jobject, jlong canvasHandle, jcharArray text, 514 jint index, jint count, jfloat x, jfloat y, jint bidiFlags, 515 jlong paintHandle, jlong typefaceHandle) { 516 Paint* paint = reinterpret_cast<Paint*>(paintHandle); 517 TypefaceImpl* typeface = reinterpret_cast<TypefaceImpl*>(typefaceHandle); 518 jchar* jchars = env->GetCharArrayElements(text, NULL); 519 drawText(get_canvas(canvasHandle), jchars + index, 0, count, count, x, y, 520 bidiFlags, *paint, typeface); 521 env->ReleaseCharArrayElements(text, jchars, JNI_ABORT); 522} 523 524static void drawTextString(JNIEnv* env, jobject, jlong canvasHandle, jstring text, 525 jint start, jint end, jfloat x, jfloat y, jint bidiFlags, 526 jlong paintHandle, jlong typefaceHandle) { 527 Paint* paint = reinterpret_cast<Paint*>(paintHandle); 528 TypefaceImpl* typeface = reinterpret_cast<TypefaceImpl*>(typefaceHandle); 529 const int count = end - start; 530 const jchar* jchars = env->GetStringChars(text, NULL); 531 drawText(get_canvas(canvasHandle), jchars + start, 0, count, count, x, y, 532 bidiFlags, *paint, typeface); 533 env->ReleaseStringChars(text, jchars); 534} 535 536static void drawTextRunChars(JNIEnv* env, jobject, jlong canvasHandle, jcharArray text, jint index, 537 jint count, jint contextIndex, jint contextCount, jfloat x, jfloat y, 538 jboolean isRtl, jlong paintHandle, jlong typefaceHandle) { 539 Paint* paint = reinterpret_cast<Paint*>(paintHandle); 540 TypefaceImpl* typeface = reinterpret_cast<TypefaceImpl*>(typefaceHandle); 541 542 const int bidiFlags = isRtl ? kBidi_Force_RTL : kBidi_Force_LTR; 543 jchar* jchars = env->GetCharArrayElements(text, NULL); 544 drawText(get_canvas(canvasHandle), jchars + contextIndex, index - contextIndex, count, 545 contextCount, x, y, bidiFlags, *paint, typeface); 546 env->ReleaseCharArrayElements(text, jchars, JNI_ABORT); 547} 548 549static void drawTextRunString(JNIEnv* env, jobject obj, jlong canvasHandle, jstring text, 550 jint start, jint end, jint contextStart, jint contextEnd, 551 jfloat x, jfloat y, jboolean isRtl, jlong paintHandle, 552 jlong typefaceHandle) { 553 Paint* paint = reinterpret_cast<Paint*>(paintHandle); 554 TypefaceImpl* typeface = reinterpret_cast<TypefaceImpl*>(typefaceHandle); 555 556 int bidiFlags = isRtl ? kBidi_Force_RTL : kBidi_Force_LTR; 557 jint count = end - start; 558 jint contextCount = contextEnd - contextStart; 559 const jchar* jchars = env->GetStringChars(text, NULL); 560 drawText(get_canvas(canvasHandle), jchars + contextStart, start - contextStart, count, 561 contextCount, x, y, bidiFlags, *paint, typeface); 562 env->ReleaseStringChars(text, jchars); 563} 564 565class DrawTextOnPathFunctor { 566public: 567 DrawTextOnPathFunctor(const Layout& layout, Canvas* canvas, float hOffset, 568 float vOffset, const Paint& paint, const SkPath& path) 569 : layout(layout), canvas(canvas), hOffset(hOffset), vOffset(vOffset), 570 paint(paint), path(path) { 571 } 572 void operator()(size_t start, size_t end) { 573 uint16_t glyphs[1]; 574 for (size_t i = start; i < end; i++) { 575 glyphs[0] = layout.getGlyphId(i); 576 float x = hOffset + layout.getX(i); 577 float y = vOffset + layout.getY(i); 578 canvas->drawTextOnPath(glyphs, 1, path, x, y, paint); 579 } 580 } 581private: 582 const Layout& layout; 583 Canvas* canvas; 584 float hOffset; 585 float vOffset; 586 const Paint& paint; 587 const SkPath& path; 588}; 589 590static void drawTextOnPath(Canvas* canvas, const uint16_t* text, int count, int bidiFlags, 591 const SkPath& path, float hOffset, float vOffset, 592 const Paint& paint, TypefaceImpl* typeface) { 593 Paint paintCopy(paint); 594 Layout layout; 595 MinikinUtils::doLayout(&layout, &paintCopy, bidiFlags, typeface, text, 0, count, count); 596 hOffset += MinikinUtils::hOffsetForTextAlign(&paintCopy, layout, path); 597 598 // Set align to left for drawing, as we don't want individual 599 // glyphs centered or right-aligned; the offset above takes 600 // care of all alignment. 601 paintCopy.setTextAlign(Paint::kLeft_Align); 602 603 DrawTextOnPathFunctor f(layout, canvas, hOffset, vOffset, paintCopy, path); 604 MinikinUtils::forFontRun(layout, &paintCopy, f); 605} 606 607static void drawTextOnPathChars(JNIEnv* env, jobject, jlong canvasHandle, jcharArray text, 608 jint index, jint count, jlong pathHandle, jfloat hOffset, 609 jfloat vOffset, jint bidiFlags, jlong paintHandle, 610 jlong typefaceHandle) { 611 SkPath* path = reinterpret_cast<SkPath*>(pathHandle); 612 Paint* paint = reinterpret_cast<Paint*>(paintHandle); 613 TypefaceImpl* typeface = reinterpret_cast<TypefaceImpl*>(typefaceHandle); 614 615 jchar* jchars = env->GetCharArrayElements(text, NULL); 616 617 drawTextOnPath(get_canvas(canvasHandle), jchars + index, count, bidiFlags, *path, 618 hOffset, vOffset, *paint, typeface); 619 620 env->ReleaseCharArrayElements(text, jchars, 0); 621} 622 623static void drawTextOnPathString(JNIEnv* env, jobject, jlong canvasHandle, jstring text, 624 jlong pathHandle, jfloat hOffset, jfloat vOffset, 625 jint bidiFlags, jlong paintHandle, jlong typefaceHandle) { 626 SkPath* path = reinterpret_cast<SkPath*>(pathHandle); 627 Paint* paint = reinterpret_cast<Paint*>(paintHandle); 628 TypefaceImpl* typeface = reinterpret_cast<TypefaceImpl*>(typefaceHandle); 629 630 const jchar* jchars = env->GetStringChars(text, NULL); 631 int count = env->GetStringLength(text); 632 633 drawTextOnPath(get_canvas(canvasHandle), jchars, count, bidiFlags, *path, 634 hOffset, vOffset, *paint, typeface); 635 636 env->ReleaseStringChars(text, jchars); 637} 638 639static void setDrawFilter(JNIEnv* env, jobject, jlong canvasHandle, jlong filterHandle) { 640 get_canvas(canvasHandle)->setDrawFilter(reinterpret_cast<SkDrawFilter*>(filterHandle)); 641} 642 643static void freeCaches(JNIEnv* env, jobject) { 644 SkGraphics::PurgeFontCache(); 645} 646 647static void freeTextLayoutCaches(JNIEnv* env, jobject) { 648 Layout::purgeCaches(); 649} 650 651}; // namespace CanvasJNI 652 653static JNINativeMethod gMethods[] = { 654 {"finalizer", "(J)V", (void*) CanvasJNI::finalizer}, 655 {"initRaster", "(J)J", (void*) CanvasJNI::initRaster}, 656 {"native_setBitmap", "(JJZ)V", (void*) CanvasJNI::setBitmap}, 657 {"native_isOpaque","(J)Z", (void*) CanvasJNI::isOpaque}, 658 {"native_getWidth","(J)I", (void*) CanvasJNI::getWidth}, 659 {"native_getHeight","(J)I", (void*) CanvasJNI::getHeight}, 660 {"native_save","(JI)I", (void*) CanvasJNI::save}, 661 {"native_saveLayer","(JFFFFJI)I", (void*) CanvasJNI::saveLayer}, 662 {"native_saveLayerAlpha","(JFFFFII)I", (void*) CanvasJNI::saveLayerAlpha}, 663 {"native_getSaveCount","(J)I", (void*) CanvasJNI::getSaveCount}, 664 {"native_restore","(J)V", (void*) CanvasJNI::restore}, 665 {"native_restoreToCount","(JI)V", (void*) CanvasJNI::restoreToCount}, 666 {"native_getCTM", "(JJ)V", (void*)CanvasJNI::getCTM}, 667 {"native_setMatrix","(JJ)V", (void*) CanvasJNI::setMatrix}, 668 {"native_concat","(JJ)V", (void*) CanvasJNI::concat}, 669 {"native_rotate","(JF)V", (void*) CanvasJNI::rotate}, 670 {"native_scale","(JFF)V", (void*) CanvasJNI::scale}, 671 {"native_skew","(JFF)V", (void*) CanvasJNI::skew}, 672 {"native_translate","(JFF)V", (void*) CanvasJNI::translate}, 673 {"native_getClipBounds","(JLandroid/graphics/Rect;)Z", (void*) CanvasJNI::getClipBounds}, 674 {"native_quickReject","(JJ)Z", (void*) CanvasJNI::quickRejectPath}, 675 {"native_quickReject","(JFFFF)Z", (void*)CanvasJNI::quickRejectRect}, 676 {"native_clipRect","(JFFFFI)Z", (void*) CanvasJNI::clipRect}, 677 {"native_clipPath","(JJI)Z", (void*) CanvasJNI::clipPath}, 678 {"native_clipRegion","(JJI)Z", (void*) CanvasJNI::clipRegion}, 679 {"native_drawColor","(JII)V", (void*) CanvasJNI::drawColor}, 680 {"native_drawPaint","(JJ)V", (void*) CanvasJNI::drawPaint}, 681 {"native_drawPoint", "(JFFJ)V", (void*) CanvasJNI::drawPoint}, 682 {"native_drawPoints", "(J[FIIJ)V", (void*) CanvasJNI::drawPoints}, 683 {"native_drawLine", "(JFFFFJ)V", (void*) CanvasJNI::drawLine}, 684 {"native_drawLines", "(J[FIIJ)V", (void*) CanvasJNI::drawLines}, 685 {"native_drawRect","(JFFFFJ)V", (void*) CanvasJNI::drawRect}, 686 {"native_drawRoundRect","(JFFFFFFJ)V", (void*) CanvasJNI::drawRoundRect}, 687 {"native_drawCircle","(JFFFJ)V", (void*) CanvasJNI::drawCircle}, 688 {"native_drawOval","(JFFFFJ)V", (void*) CanvasJNI::drawOval}, 689 {"native_drawArc","(JFFFFFFZJ)V", (void*) CanvasJNI::drawArc}, 690 {"native_drawPath","(JJJ)V", (void*) CanvasJNI::drawPath}, 691 {"nativeDrawVertices", "(JII[FI[FI[II[SIIJ)V", (void*)CanvasJNI::drawVertices}, 692 {"native_drawBitmap","(JJFFJIII)V", (void*) CanvasJNI::drawBitmap}, 693 {"nativeDrawBitmapMatrix", "(JJJJ)V", (void*)CanvasJNI::drawBitmapMatrix}, 694 {"native_drawBitmap","(JJFFFFFFFFJII)V", (void*) CanvasJNI::drawBitmapRect}, 695 {"native_drawBitmap", "(J[IIIFFIIZJ)V", (void*)CanvasJNI::drawBitmapArray}, 696 {"nativeDrawBitmapMesh", "(JJII[FI[IIJ)V", (void*)CanvasJNI::drawBitmapMesh}, 697 {"native_drawText","(J[CIIFFIJJ)V", (void*) CanvasJNI::drawTextChars}, 698 {"native_drawText","(JLjava/lang/String;IIFFIJJ)V", (void*) CanvasJNI::drawTextString}, 699 {"native_drawTextRun","(J[CIIIIFFZJJ)V", (void*) CanvasJNI::drawTextRunChars}, 700 {"native_drawTextRun","(JLjava/lang/String;IIIIFFZJJ)V", (void*) CanvasJNI::drawTextRunString}, 701 {"native_drawTextOnPath","(J[CIIJFFIJJ)V", (void*) CanvasJNI::drawTextOnPathChars}, 702 {"native_drawTextOnPath","(JLjava/lang/String;JFFIJJ)V", (void*) CanvasJNI::drawTextOnPathString}, 703 {"nativeSetDrawFilter", "(JJ)V", (void*) CanvasJNI::setDrawFilter}, 704 {"freeCaches", "()V", (void*) CanvasJNI::freeCaches}, 705 {"freeTextLayoutCaches", "()V", (void*) CanvasJNI::freeTextLayoutCaches} 706}; 707 708int register_android_graphics_Canvas(JNIEnv* env) { 709 return RegisterMethodsOrDie(env, "android/graphics/Canvas", gMethods, NELEM(gMethods)); 710} 711 712}; // namespace android 713