core/jni/android/graphics/Paint.cpp

   1 /* libs/android_runtime/android/graphics/Paint.cpp
   2 **
   3 ** Copyright 2006, The Android Open Source Project
   4 **
   5 ** Licensed under the Apache License, Version 2.0 (the "License");
   6 ** you may not use this file except in compliance with the License.
   7 ** You may obtain a copy of the License at
   8 **
   9 **     http://www.apache.org/licenses/LICENSE-2.0
  10 **
  11 ** Unless required by applicable law or agreed to in writing, software
  12 ** distributed under the License is distributed on an "AS IS" BASIS,
  13 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 ** See the License for the specific language governing permissions and
  15 ** limitations under the License.
  16 */
  17
  18 #define LOG_TAG "Paint"
  19
  20 #include <utils/Log.h>
  21
  22 #include "jni.h"
  23 #include "GraphicsJNI.h"
  24 #include "core_jni_helpers.h"
  25 #include <ScopedStringChars.h>
  26 #include <ScopedUtfChars.h>
  27
  28 #include "SkBlurDrawLooper.h"
  29 #include "SkColorFilter.h"
  30 #include "SkMaskFilter.h"
  31 #include "SkPath.h"
  32 #include "SkRasterizer.h"
  33 #include "SkShader.h"
  34 #include "SkTypeface.h"
  35 #include "SkXfermode.h"
  36 #include "unicode/uloc.h"
  37 #include "unicode/ushape.h"
  38 #include "utils/Blur.h"
  39
  40 #include <hwui/MinikinSkia.h>
  41 #include <hwui/MinikinUtils.h>
  42 #include <hwui/Paint.h>
  43 #include <hwui/Typeface.h>
  44 #include <minikin/GraphemeBreak.h>
  45 #include <minikin/Measurement.h>
  46 #include <unicode/utf16.h>
  47
  48 #include <cassert>
  49 #include <cstring>
  50 #include <memory>
  51 #include <vector>
  52
  53 namespace android {
  54
  55 struct JMetricsID {
  56     jfieldID    top;
  57     jfieldID    ascent;
  58     jfieldID    descent;
  59     jfieldID    bottom;
  60     jfieldID    leading;
  61 };
  62
  63 static jclass   gFontMetrics_class;
  64 static JMetricsID gFontMetrics_fieldID;
  65
  66 static jclass   gFontMetricsInt_class;
  67 static JMetricsID gFontMetricsInt_fieldID;
  68
  69 static void defaultSettingsForAndroid(Paint* paint) {
  70     // GlyphID encoding is required because we are using Harfbuzz shaping
  71     paint->setTextEncoding(Paint::kGlyphID_TextEncoding);
  72 }
  73
  74 namespace PaintGlue {
  75     enum MoveOpt {
  76         AFTER, AT_OR_AFTER, BEFORE, AT_OR_BEFORE, AT
  77     };
  78
  79     static void deletePaint(Paint* paint) {
  80         delete paint;
  81     }
  82
  83     static jlong getNativeFinalizer(JNIEnv*, jobject) {
  84         return static_cast<jlong>(reinterpret_cast<uintptr_t>(&deletePaint));
  85     }
  86
  87     static jlong init(JNIEnv* env, jobject) {
  88         static_assert(1 <<  0 == SkPaint::kAntiAlias_Flag,          "paint_flags_mismatch");
  89         static_assert(1 <<  2 == SkPaint::kDither_Flag,             "paint_flags_mismatch");
  90         static_assert(1 <<  3 == SkPaint::kUnderlineText_Flag,      "paint_flags_mismatch");
  91         static_assert(1 <<  4 == SkPaint::kStrikeThruText_Flag,     "paint_flags_mismatch");
  92         static_assert(1 <<  5 == SkPaint::kFakeBoldText_Flag,       "paint_flags_mismatch");
  93         static_assert(1 <<  6 == SkPaint::kLinearText_Flag,         "paint_flags_mismatch");
  94         static_assert(1 <<  7 == SkPaint::kSubpixelText_Flag,       "paint_flags_mismatch");
  95         static_assert(1 <<  8 == SkPaint::kDevKernText_Flag,        "paint_flags_mismatch");
  96         static_assert(1 << 10 == SkPaint::kEmbeddedBitmapText_Flag, "paint_flags_mismatch");
  97
  98         Paint* obj = new Paint();
  99         defaultSettingsForAndroid(obj);
 100         return reinterpret_cast<jlong>(obj);
 101     }
 102
 103     static jlong initWithPaint(JNIEnv* env, jobject clazz, jlong paintHandle) {
 104         Paint* paint = reinterpret_cast<Paint*>(paintHandle);
 105         Paint* obj = new Paint(*paint);
 106         return reinterpret_cast<jlong>(obj);
 107     }
 108
 109     static void reset(JNIEnv* env, jobject clazz, jlong objHandle) {
 110         Paint* obj = reinterpret_cast<Paint*>(objHandle);
 111         obj->reset();
 112         defaultSettingsForAndroid(obj);
 113     }
 114
 115     static void assign(JNIEnv* env, jobject clazz, jlong dstPaintHandle, jlong srcPaintHandle) {
 116         Paint* dst = reinterpret_cast<Paint*>(dstPaintHandle);
 117         const Paint* src = reinterpret_cast<Paint*>(srcPaintHandle);
 118         *dst = *src;
 119     }
 120
 121     // Equivalent to the Java Paint's FILTER_BITMAP_FLAG.
 122     static const uint32_t sFilterBitmapFlag = 0x02;
 123
 124     static jint getFlags(JNIEnv* env, jobject, jlong paintHandle) {
 125         Paint* nativePaint = reinterpret_cast<Paint*>(paintHandle);
 126         uint32_t result = nativePaint->getFlags();
 127         result &= ~sFilterBitmapFlag; // Filtering no longer stored in this bit. Mask away.
 128         if (nativePaint->getFilterQuality() != kNone_SkFilterQuality) {
 129             result |= sFilterBitmapFlag;
 130         }
 131         return static_cast<jint>(result);
 132     }
 133
 134     static void setFlags(JNIEnv* env, jobject, jlong paintHandle, jint flags) {
 135         Paint* nativePaint = reinterpret_cast<Paint*>(paintHandle);
 136         // Instead of modifying 0x02, change the filter level.
 137         nativePaint->setFilterQuality(flags & sFilterBitmapFlag
 138                 ? kLow_SkFilterQuality
 139                 : kNone_SkFilterQuality);
 140         // Don't pass through filter flag, which is no longer stored in paint's flags.
 141         flags &= ~sFilterBitmapFlag;
 142         // Use the existing value for 0x02.
 143         const uint32_t existing0x02Flag = nativePaint->getFlags() & sFilterBitmapFlag;
 144         flags |= existing0x02Flag;
 145         nativePaint->setFlags(flags);
 146     }
 147
 148     static jint getHinting(JNIEnv* env, jobject, jlong paintHandle) {
 149         return reinterpret_cast<Paint*>(paintHandle)->getHinting()
 150                 == Paint::kNo_Hinting ? 0 : 1;
 151     }
 152
 153     static void setHinting(JNIEnv* env, jobject, jlong paintHandle, jint mode) {
 154         reinterpret_cast<Paint*>(paintHandle)->setHinting(
 155                 mode == 0 ? Paint::kNo_Hinting : Paint::kNormal_Hinting);
 156     }
 157
 158     static void setAntiAlias(JNIEnv* env, jobject, jlong paintHandle, jboolean aa) {
 159         reinterpret_cast<Paint*>(paintHandle)->setAntiAlias(aa);
 160     }
 161
 162     static void setLinearText(JNIEnv* env, jobject, jlong paintHandle, jboolean linearText) {
 163         reinterpret_cast<Paint*>(paintHandle)->setLinearText(linearText);
 164     }
 165
 166     static void setSubpixelText(JNIEnv* env, jobject, jlong paintHandle, jboolean subpixelText) {
 167         reinterpret_cast<Paint*>(paintHandle)->setSubpixelText(subpixelText);
 168     }
 169
 170     static void setUnderlineText(JNIEnv* env, jobject, jlong paintHandle, jboolean underlineText) {
 171         reinterpret_cast<Paint*>(paintHandle)->setUnderlineText(underlineText);
 172     }
 173
 174     static void setStrikeThruText(JNIEnv* env, jobject, jlong paintHandle, jboolean strikeThruText) {
 175         reinterpret_cast<Paint*>(paintHandle)->setStrikeThruText(strikeThruText);
 176     }
 177
 178     static void setFakeBoldText(JNIEnv* env, jobject, jlong paintHandle, jboolean fakeBoldText) {
 179         reinterpret_cast<Paint*>(paintHandle)->setFakeBoldText(fakeBoldText);
 180     }
 181
 182     static void setFilterBitmap(JNIEnv* env, jobject, jlong paintHandle, jboolean filterBitmap) {
 183         reinterpret_cast<Paint*>(paintHandle)->setFilterQuality(
 184                 filterBitmap ? kLow_SkFilterQuality : kNone_SkFilterQuality);
 185     }
 186
 187     static void setDither(JNIEnv* env, jobject, jlong paintHandle, jboolean dither) {
 188         reinterpret_cast<Paint*>(paintHandle)->setDither(dither);
 189     }
 190
 191     static jint getStyle(JNIEnv* env, jobject clazz,jlong objHandle) {
 192         Paint* obj = reinterpret_cast<Paint*>(objHandle);
 193         return static_cast<jint>(obj->getStyle());
 194     }
 195
 196     static void setStyle(JNIEnv* env, jobject clazz, jlong objHandle, jint styleHandle) {
 197         Paint* obj = reinterpret_cast<Paint*>(objHandle);
 198         Paint::Style style = static_cast<Paint::Style>(styleHandle);
 199         obj->setStyle(style);
 200     }
 201
 202     static jint getColor(JNIEnv* env, jobject, jlong paintHandle) {
 203         int color;
 204         color = reinterpret_cast<Paint*>(paintHandle)->getColor();
 205         return static_cast<jint>(color);
 206     }
 207
 208     static jint getAlpha(JNIEnv* env, jobject, jlong paintHandle) {
 209         int alpha;
 210         alpha = reinterpret_cast<Paint*>(paintHandle)->getAlpha();
 211         return static_cast<jint>(alpha);
 212     }
 213
 214     static void setColor(JNIEnv* env, jobject, jlong paintHandle, jint color) {
 215         reinterpret_cast<Paint*>(paintHandle)->setColor(color);
 216     }
 217
 218     static void setAlpha(JNIEnv* env, jobject, jlong paintHandle, jint a) {
 219         reinterpret_cast<Paint*>(paintHandle)->setAlpha(a);
 220     }
 221
 222     static jfloat getStrokeWidth(JNIEnv* env, jobject, jlong paintHandle) {
 223         return SkScalarToFloat(reinterpret_cast<Paint*>(paintHandle)->getStrokeWidth());
 224     }
 225
 226     static void setStrokeWidth(JNIEnv* env, jobject, jlong paintHandle, jfloat width) {
 227         reinterpret_cast<Paint*>(paintHandle)->setStrokeWidth(width);
 228     }
 229
 230     static jfloat getStrokeMiter(JNIEnv* env, jobject, jlong paintHandle) {
 231         return SkScalarToFloat(reinterpret_cast<Paint*>(paintHandle)->getStrokeMiter());
 232     }
 233
 234     static void setStrokeMiter(JNIEnv* env, jobject, jlong paintHandle, jfloat miter) {
 235         reinterpret_cast<Paint*>(paintHandle)->setStrokeMiter(miter);
 236     }
 237
 238     static jint getStrokeCap(JNIEnv* env, jobject clazz, jlong objHandle) {
 239         Paint* obj = reinterpret_cast<Paint*>(objHandle);
 240         return static_cast<jint>(obj->getStrokeCap());
 241     }
 242
 243     static void setStrokeCap(JNIEnv* env, jobject clazz, jlong objHandle, jint capHandle) {
 244         Paint* obj = reinterpret_cast<Paint*>(objHandle);
 245         Paint::Cap cap = static_cast<Paint::Cap>(capHandle);
 246         obj->setStrokeCap(cap);
 247     }
 248
 249     static jint getStrokeJoin(JNIEnv* env, jobject clazz, jlong objHandle) {
 250         Paint* obj = reinterpret_cast<Paint*>(objHandle);
 251         return static_cast<jint>(obj->getStrokeJoin());
 252     }
 253
 254     static void setStrokeJoin(JNIEnv* env, jobject clazz, jlong objHandle, jint joinHandle) {
 255         Paint* obj = reinterpret_cast<Paint*>(objHandle);
 256         Paint::Join join = (Paint::Join) joinHandle;
 257         obj->setStrokeJoin(join);
 258     }
 259
 260     static jboolean getFillPath(JNIEnv* env, jobject clazz, jlong objHandle, jlong srcHandle, jlong dstHandle) {
 261         Paint* obj = reinterpret_cast<Paint*>(objHandle);
 262         SkPath* src = reinterpret_cast<SkPath*>(srcHandle);
 263         SkPath* dst = reinterpret_cast<SkPath*>(dstHandle);
 264         return obj->getFillPath(*src, dst) ? JNI_TRUE : JNI_FALSE;
 265     }
 266
 267     static jlong setShader(JNIEnv* env, jobject clazz, jlong objHandle, jlong shaderHandle) {
 268         Paint* obj = reinterpret_cast<Paint*>(objHandle);
 269         SkShader* shader = reinterpret_cast<SkShader*>(shaderHandle);
 270         return reinterpret_cast<jlong>(obj->setShader(shader));
 271     }
 272
 273     static jlong setColorFilter(JNIEnv* env, jobject clazz, jlong objHandle, jlong filterHandle) {
 274         Paint* obj = reinterpret_cast<Paint *>(objHandle);
 275         SkColorFilter* filter  = reinterpret_cast<SkColorFilter *>(filterHandle);
 276         return reinterpret_cast<jlong>(obj->setColorFilter(filter));
 277     }
 278
 279     static jlong setXfermode(JNIEnv* env, jobject clazz, jlong objHandle, jlong xfermodeHandle) {
 280         Paint* obj = reinterpret_cast<Paint*>(objHandle);
 281         SkXfermode* xfermode = reinterpret_cast<SkXfermode*>(xfermodeHandle);
 282         return reinterpret_cast<jlong>(obj->setXfermode(xfermode));
 283     }
 284
 285     static jlong setPathEffect(JNIEnv* env, jobject clazz, jlong objHandle, jlong effectHandle) {
 286         Paint* obj = reinterpret_cast<Paint*>(objHandle);
 287         SkPathEffect* effect  = reinterpret_cast<SkPathEffect*>(effectHandle);
 288         return reinterpret_cast<jlong>(obj->setPathEffect(effect));
 289     }
 290
 291     static jlong setMaskFilter(JNIEnv* env, jobject clazz, jlong objHandle, jlong maskfilterHandle) {
 292         Paint* obj = reinterpret_cast<Paint*>(objHandle);
 293         SkMaskFilter* maskfilter  = reinterpret_cast<SkMaskFilter*>(maskfilterHandle);
 294         return reinterpret_cast<jlong>(obj->setMaskFilter(maskfilter));
 295     }
 296
 297     static jlong setTypeface(JNIEnv* env, jobject clazz, jlong objHandle, jlong typefaceHandle) {
 298         // TODO: in Paint refactoring, set typeface on android Paint, not Paint
 299         return NULL;
 300     }
 301
 302     static jlong setRasterizer(JNIEnv* env, jobject clazz, jlong objHandle, jlong rasterizerHandle) {
 303         Paint* obj = reinterpret_cast<Paint*>(objHandle);
 304         SkAutoTUnref<SkRasterizer> rasterizer(GraphicsJNI::refNativeRasterizer(rasterizerHandle));
 305         return reinterpret_cast<jlong>(obj->setRasterizer(rasterizer));
 306     }
 307
 308     static jint getTextAlign(JNIEnv* env, jobject clazz, jlong objHandle) {
 309         Paint* obj = reinterpret_cast<Paint*>(objHandle);
 310         return static_cast<jint>(obj->getTextAlign());
 311     }
 312
 313     static void setTextAlign(JNIEnv* env, jobject clazz, jlong objHandle, jint alignHandle) {
 314         Paint* obj = reinterpret_cast<Paint*>(objHandle);
 315         Paint::Align align = static_cast<Paint::Align>(alignHandle);
 316         obj->setTextAlign(align);
 317     }
 318
 319     static jint setTextLocales(JNIEnv* env, jobject clazz, jlong objHandle, jstring locales) {
 320         Paint* obj = reinterpret_cast<Paint*>(objHandle);
 321         ScopedUtfChars localesChars(env, locales);
 322         jint minikinLangListId = FontStyle::registerLanguageList(localesChars.c_str());
 323         obj->setMinikinLangListId(minikinLangListId);
 324         return minikinLangListId;
 325     }
 326
 327     static void setTextLocalesByMinikinLangListId(JNIEnv* env, jobject clazz, jlong objHandle,
 328             jint minikinLangListId) {
 329         Paint* obj = reinterpret_cast<Paint*>(objHandle);
 330         obj->setMinikinLangListId(minikinLangListId);
 331     }
 332
 333     static jboolean isElegantTextHeight(JNIEnv* env, jobject, jlong paintHandle) {
 334         Paint* obj = reinterpret_cast<Paint*>(paintHandle);
 335         return obj->getFontVariant() == VARIANT_ELEGANT;
 336     }
 337
 338     static void setElegantTextHeight(JNIEnv* env, jobject, jlong paintHandle, jboolean aa) {
 339         Paint* obj = reinterpret_cast<Paint*>(paintHandle);
 340         obj->setFontVariant(aa ? VARIANT_ELEGANT : VARIANT_DEFAULT);
 341     }
 342
 343     static jfloat getTextSize(JNIEnv* env, jobject, jlong paintHandle) {
 344         return SkScalarToFloat(reinterpret_cast<Paint*>(paintHandle)->getTextSize());
 345     }
 346
 347     static void setTextSize(JNIEnv* env, jobject, jlong paintHandle, jfloat textSize) {
 348         reinterpret_cast<Paint*>(paintHandle)->setTextSize(textSize);
 349     }
 350
 351     static jfloat getTextScaleX(JNIEnv* env, jobject, jlong paintHandle) {
 352         return SkScalarToFloat(reinterpret_cast<Paint*>(paintHandle)->getTextScaleX());
 353     }
 354
 355     static void setTextScaleX(JNIEnv* env, jobject, jlong paintHandle, jfloat scaleX) {
 356         reinterpret_cast<Paint*>(paintHandle)->setTextScaleX(scaleX);
 357     }
 358
 359     static jfloat getTextSkewX(JNIEnv* env, jobject, jlong paintHandle) {
 360         return SkScalarToFloat(reinterpret_cast<Paint*>(paintHandle)->getTextSkewX());
 361     }
 362
 363     static void setTextSkewX(JNIEnv* env, jobject, jlong paintHandle, jfloat skewX) {
 364         reinterpret_cast<Paint*>(paintHandle)->setTextSkewX(skewX);
 365     }
 366
 367     static jfloat getLetterSpacing(JNIEnv* env, jobject clazz, jlong paintHandle) {
 368         Paint* paint = reinterpret_cast<Paint*>(paintHandle);
 369         return paint->getLetterSpacing();
 370     }
 371
 372     static void setLetterSpacing(JNIEnv* env, jobject clazz, jlong paintHandle, jfloat letterSpacing) {
 373         Paint* paint = reinterpret_cast<Paint*>(paintHandle);
 374         paint->setLetterSpacing(letterSpacing);
 375     }
 376
 377     static void setFontFeatureSettings(JNIEnv* env, jobject clazz, jlong paintHandle, jstring settings) {
 378         Paint* paint = reinterpret_cast<Paint*>(paintHandle);
 379         if (!settings) {
 380             paint->setFontFeatureSettings(std::string());
 381         } else {
 382             ScopedUtfChars settingsChars(env, settings);
 383             paint->setFontFeatureSettings(std::string(settingsChars.c_str(), settingsChars.size()));
 384         }
 385     }
 386
 387     static jint getHyphenEdit(JNIEnv* env, jobject clazz, jlong paintHandle, jint hyphen) {
 388         Paint* paint = reinterpret_cast<Paint*>(paintHandle);
 389         return paint->getHyphenEdit();
 390     }
 391
 392     static void setHyphenEdit(JNIEnv* env, jobject clazz, jlong paintHandle, jint hyphen) {
 393         Paint* paint = reinterpret_cast<Paint*>(paintHandle);
 394         paint->setHyphenEdit((uint32_t)hyphen);
 395     }
 396
 397     static SkScalar getMetricsInternal(jlong paintHandle, jlong typefaceHandle,
 398             Paint::FontMetrics *metrics) {
 399         const int kElegantTop = 2500;
 400         const int kElegantBottom = -1000;
 401         const int kElegantAscent = 1900;
 402         const int kElegantDescent = -500;
 403         const int kElegantLeading = 0;
 404         Paint* paint = reinterpret_cast<Paint*>(paintHandle);
 405         Typeface* typeface = reinterpret_cast<Typeface*>(typefaceHandle);
 406         typeface = Typeface::resolveDefault(typeface);
 407         FakedFont baseFont = typeface->fFontCollection->baseFontFaked(typeface->fStyle);
 408         float saveSkewX = paint->getTextSkewX();
 409         bool savefakeBold = paint->isFakeBoldText();
 410         MinikinFontSkia::populateSkPaint(paint, baseFont.font, baseFont.fakery);
 411         SkScalar spacing = paint->getFontMetrics(metrics);
 412         // The populateSkPaint call may have changed fake bold / text skew
 413         // because we want to measure with those effects applied, so now
 414         // restore the original settings.
 415         paint->setTextSkewX(saveSkewX);
 416         paint->setFakeBoldText(savefakeBold);
 417         if (paint->getFontVariant() == VARIANT_ELEGANT) {
 418             SkScalar size = paint->getTextSize();
 419             metrics->fTop = -size * kElegantTop / 2048;
 420             metrics->fBottom = -size * kElegantBottom / 2048;
 421             metrics->fAscent = -size * kElegantAscent / 2048;
 422             metrics->fDescent = -size * kElegantDescent / 2048;
 423             metrics->fLeading = size * kElegantLeading / 2048;
 424             spacing = metrics->fDescent - metrics->fAscent + metrics->fLeading;
 425         }
 426         return spacing;
 427     }
 428
 429     static jfloat ascent(JNIEnv* env, jobject, jlong paintHandle, jlong typefaceHandle) {
 430         Paint::FontMetrics metrics;
 431         getMetricsInternal(paintHandle, typefaceHandle, &metrics);
 432         return SkScalarToFloat(metrics.fAscent);
 433     }
 434
 435     static jfloat descent(JNIEnv* env, jobject, jlong paintHandle, jlong typefaceHandle) {
 436         Paint::FontMetrics metrics;
 437         getMetricsInternal(paintHandle, typefaceHandle, &metrics);
 438         return SkScalarToFloat(metrics.fDescent);
 439     }
 440
 441     static jfloat getFontMetrics(JNIEnv* env, jobject, jlong paintHandle,
 442             jlong typefaceHandle, jobject metricsObj) {
 443         Paint::FontMetrics metrics;
 444         SkScalar spacing = getMetricsInternal(paintHandle, typefaceHandle, &metrics);
 445
 446         if (metricsObj) {
 447             SkASSERT(env->IsInstanceOf(metricsObj, gFontMetrics_class));
 448             env->SetFloatField(metricsObj, gFontMetrics_fieldID.top, SkScalarToFloat(metrics.fTop));
 449             env->SetFloatField(metricsObj, gFontMetrics_fieldID.ascent, SkScalarToFloat(metrics.fAscent));
 450             env->SetFloatField(metricsObj, gFontMetrics_fieldID.descent, SkScalarToFloat(metrics.fDescent));
 451             env->SetFloatField(metricsObj, gFontMetrics_fieldID.bottom, SkScalarToFloat(metrics.fBottom));
 452             env->SetFloatField(metricsObj, gFontMetrics_fieldID.leading, SkScalarToFloat(metrics.fLeading));
 453         }
 454         return SkScalarToFloat(spacing);
 455     }
 456
 457     static jint getFontMetricsInt(JNIEnv* env, jobject, jlong paintHandle,
 458             jlong typefaceHandle, jobject metricsObj) {
 459         Paint::FontMetrics metrics;
 460
 461         getMetricsInternal(paintHandle, typefaceHandle, &metrics);
 462         int ascent = SkScalarRoundToInt(metrics.fAscent);
 463         int descent = SkScalarRoundToInt(metrics.fDescent);
 464         int leading = SkScalarRoundToInt(metrics.fLeading);
 465
 466         if (metricsObj) {
 467             SkASSERT(env->IsInstanceOf(metricsObj, gFontMetricsInt_class));
 468             env->SetIntField(metricsObj, gFontMetricsInt_fieldID.top, SkScalarFloorToInt(metrics.fTop));
 469             env->SetIntField(metricsObj, gFontMetricsInt_fieldID.ascent, ascent);
 470             env->SetIntField(metricsObj, gFontMetricsInt_fieldID.descent, descent);
 471             env->SetIntField(metricsObj, gFontMetricsInt_fieldID.bottom, SkScalarCeilToInt(metrics.fBottom));
 472             env->SetIntField(metricsObj, gFontMetricsInt_fieldID.leading, leading);
 473         }
 474         return descent - ascent + leading;
 475     }
 476
 477     static jfloat doTextAdvances(JNIEnv *env, Paint *paint, Typeface* typeface,
 478             const jchar *text, jint start, jint count, jint contextCount, jint bidiFlags,
 479             jfloatArray advances, jint advancesIndex) {
 480         NPE_CHECK_RETURN_ZERO(env, text);
 481
 482         if ((start | count | contextCount | advancesIndex) < 0 || contextCount < count) {
 483             doThrowAIOOBE(env);
 484             return 0;
 485         }
 486         if (count == 0) {
 487             return 0;
 488         }
 489         if (advances) {
 490             size_t advancesLength = env->GetArrayLength(advances);
 491             if ((size_t)(count  + advancesIndex) > advancesLength) {
 492                 doThrowAIOOBE(env);
 493                 return 0;
 494             }
 495         }
 496         std::unique_ptr<jfloat[]> advancesArray;
 497         if (advances) {
 498             advancesArray.reset(new jfloat[count]);
 499         }
 500         const float advance = MinikinUtils::measureText(paint, bidiFlags, typeface, text,
 501                 start, count, contextCount, advancesArray.get());
 502         if (advances) {
 503             env->SetFloatArrayRegion(advances, advancesIndex, count, advancesArray.get());
 504         }
 505         return advance;
 506     }
 507
 508     static jfloat getTextAdvances___CIIIII_FI(JNIEnv* env, jobject clazz, jlong paintHandle,
 509             jlong typefaceHandle,
 510             jcharArray text, jint index, jint count, jint contextIndex, jint contextCount,
 511             jint bidiFlags, jfloatArray advances, jint advancesIndex) {
 512         Paint* paint = reinterpret_cast<Paint*>(paintHandle);
 513         Typeface* typeface = reinterpret_cast<Typeface*>(typefaceHandle);
 514         jchar* textArray = env->GetCharArrayElements(text, NULL);
 515         jfloat result = doTextAdvances(env, paint, typeface, textArray + contextIndex,
 516                 index - contextIndex, count, contextCount, bidiFlags, advances, advancesIndex);
 517         env->ReleaseCharArrayElements(text, textArray, JNI_ABORT);
 518         return result;
 519     }
 520
 521     static jfloat getTextAdvances__StringIIIII_FI(JNIEnv* env, jobject clazz, jlong paintHandle,
 522             jlong typefaceHandle,
 523             jstring text, jint start, jint end, jint contextStart, jint contextEnd, jint bidiFlags,
 524             jfloatArray advances, jint advancesIndex) {
 525         Paint* paint = reinterpret_cast<Paint*>(paintHandle);
 526         Typeface* typeface = reinterpret_cast<Typeface*>(typefaceHandle);
 527         const jchar* textArray = env->GetStringChars(text, NULL);
 528         jfloat result = doTextAdvances(env, paint, typeface, textArray + contextStart,
 529                 start - contextStart, end - start, contextEnd - contextStart, bidiFlags,
 530                 advances, advancesIndex);
 531         env->ReleaseStringChars(text, textArray);
 532         return result;
 533     }
 534
 535     static jint doTextRunCursor(JNIEnv *env, Paint* paint, const jchar *text, jint start,
 536             jint count, jint flags, jint offset, jint opt) {
 537         GraphemeBreak::MoveOpt moveOpt = GraphemeBreak::MoveOpt(opt);
 538         size_t result = GraphemeBreak::getTextRunCursor(text, start, count, offset, moveOpt);
 539         return static_cast<jint>(result);
 540     }
 541
 542     static jint getTextRunCursor___C(JNIEnv* env, jobject clazz, jlong paintHandle, jcharArray text,
 543             jint contextStart, jint contextCount, jint dir, jint offset, jint cursorOpt) {
 544         Paint* paint = reinterpret_cast<Paint*>(paintHandle);
 545         jchar* textArray = env->GetCharArrayElements(text, NULL);
 546         jint result = doTextRunCursor(env, paint, textArray, contextStart, contextCount, dir,
 547                 offset, cursorOpt);
 548         env->ReleaseCharArrayElements(text, textArray, JNI_ABORT);
 549         return result;
 550     }
 551
 552     static jint getTextRunCursor__String(JNIEnv* env, jobject clazz, jlong paintHandle, jstring text,
 553             jint contextStart, jint contextEnd, jint dir, jint offset, jint cursorOpt) {
 554         Paint* paint = reinterpret_cast<Paint*>(paintHandle);
 555         const jchar* textArray = env->GetStringChars(text, NULL);
 556         jint result = doTextRunCursor(env, paint, textArray, contextStart,
 557                 contextEnd - contextStart, dir, offset, cursorOpt);
 558         env->ReleaseStringChars(text, textArray);
 559         return result;
 560     }
 561
 562     class GetTextFunctor {
 563     public:
 564         GetTextFunctor(const Layout& layout, SkPath* path, jfloat x, jfloat y, Paint* paint,
 565                     uint16_t* glyphs, SkPoint* pos)
 566                 : layout(layout), path(path), x(x), y(y), paint(paint), glyphs(glyphs), pos(pos) {
 567         }
 568
 569         void operator()(size_t start, size_t end) {
 570             for (size_t i = start; i < end; i++) {
 571                 glyphs[i] = layout.getGlyphId(i);
 572                 pos[i].fX = x + layout.getX(i);
 573                 pos[i].fY = y + layout.getY(i);
 574             }
 575             if (start == 0) {
 576                 paint->getPosTextPath(glyphs + start, (end - start) << 1, pos + start, path);
 577             } else {
 578                 paint->getPosTextPath(glyphs + start, (end - start) << 1, pos + start, &tmpPath);
 579                 path->addPath(tmpPath);
 580             }
 581         }
 582     private:
 583         const Layout& layout;
 584         SkPath* path;
 585         jfloat x;
 586         jfloat y;
 587         Paint* paint;
 588         uint16_t* glyphs;
 589         SkPoint* pos;
 590         SkPath tmpPath;
 591     };
 592
 593     static void getTextPath(JNIEnv* env, Paint* paint, Typeface* typeface, const jchar* text,
 594             jint count, jint bidiFlags, jfloat x, jfloat y, SkPath* path) {
 595         Layout layout;
 596         MinikinUtils::doLayout(&layout, paint, bidiFlags, typeface, text, 0, count, count);
 597         size_t nGlyphs = layout.nGlyphs();
 598         uint16_t* glyphs = new uint16_t[nGlyphs];
 599         SkPoint* pos = new SkPoint[nGlyphs];
 600
 601         x += MinikinUtils::xOffsetForTextAlign(paint, layout);
 602         Paint::Align align = paint->getTextAlign();
 603         paint->setTextAlign(Paint::kLeft_Align);
 604         paint->setTextEncoding(Paint::kGlyphID_TextEncoding);
 605         GetTextFunctor f(layout, path, x, y, paint, glyphs, pos);
 606         MinikinUtils::forFontRun(layout, paint, f);
 607         paint->setTextAlign(align);
 608         delete[] glyphs;
 609         delete[] pos;
 610     }
 611
 612     static void getTextPath___C(JNIEnv* env, jobject clazz, jlong paintHandle,
 613             jlong typefaceHandle, jint bidiFlags,
 614             jcharArray text, jint index, jint count, jfloat x, jfloat y, jlong pathHandle) {
 615         Paint* paint = reinterpret_cast<Paint*>(paintHandle);
 616         Typeface* typeface = reinterpret_cast<Typeface*>(typefaceHandle);
 617         SkPath* path = reinterpret_cast<SkPath*>(pathHandle);
 618         const jchar* textArray = env->GetCharArrayElements(text, NULL);
 619         getTextPath(env, paint, typeface, textArray + index, count, bidiFlags, x, y, path);
 620         env->ReleaseCharArrayElements(text, const_cast<jchar*>(textArray), JNI_ABORT);
 621     }
 622
 623     static void getTextPath__String(JNIEnv* env, jobject clazz, jlong paintHandle,
 624             jlong typefaceHandle, jint bidiFlags,
 625             jstring text, jint start, jint end, jfloat x, jfloat y, jlong pathHandle) {
 626         Paint* paint = reinterpret_cast<Paint*>(paintHandle);
 627         Typeface* typeface = reinterpret_cast<Typeface*>(typefaceHandle);
 628         SkPath* path = reinterpret_cast<SkPath*>(pathHandle);
 629         const jchar* textArray = env->GetStringChars(text, NULL);
 630         getTextPath(env, paint, typeface, textArray + start, end - start, bidiFlags, x, y, path);
 631         env->ReleaseStringChars(text, textArray);
 632     }
 633
 634     static void setShadowLayer(JNIEnv* env, jobject clazz, jlong paintHandle, jfloat radius,
 635                                jfloat dx, jfloat dy, jint color) {
 636         Paint* paint = reinterpret_cast<Paint*>(paintHandle);
 637         if (radius <= 0) {
 638             paint->setLooper(NULL);
 639         }
 640         else {
 641             SkScalar sigma = android::uirenderer::Blur::convertRadiusToSigma(radius);
 642             paint->setLooper(SkBlurDrawLooper::Create((SkColor)color, sigma, dx, dy))->unref();
 643         }
 644     }
 645
 646     static jboolean hasShadowLayer(JNIEnv* env, jobject clazz, jlong paintHandle) {
 647         Paint* paint = reinterpret_cast<Paint*>(paintHandle);
 648         return paint->getLooper() && paint->getLooper()->asABlurShadow(NULL);
 649     }
 650
 651     static int breakText(JNIEnv* env, const Paint& paint, Typeface* typeface, const jchar text[],
 652                          int count, float maxWidth, jint bidiFlags, jfloatArray jmeasured,
 653                          const bool forwardScan) {
 654         size_t measuredCount = 0;
 655         float measured = 0;
 656
 657         std::unique_ptr<float[]> advancesArray(new float[count]);
 658         MinikinUtils::measureText(&paint, bidiFlags, typeface, text, 0, count, count,
 659                 advancesArray.get());
 660
 661         for (int i = 0; i < count; i++) {
 662             // traverse in the given direction
 663             int index = forwardScan ? i : (count - i - 1);
 664             float width = advancesArray[index];
 665             if (measured + width > maxWidth) {
 666                 break;
 667             }
 668             // properly handle clusters when scanning backwards
 669             if (forwardScan || width != 0.0f) {
 670                 measuredCount = i + 1;
 671             }
 672             measured += width;
 673         }
 674
 675         if (jmeasured && env->GetArrayLength(jmeasured) > 0) {
 676             AutoJavaFloatArray autoMeasured(env, jmeasured, 1);
 677             jfloat* array = autoMeasured.ptr();
 678             array[0] = measured;
 679         }
 680         return measuredCount;
 681     }
 682
 683     static jint breakTextC(JNIEnv* env, jobject clazz, jlong paintHandle, jlong typefaceHandle, jcharArray jtext,
 684             jint index, jint count, jfloat maxWidth, jint bidiFlags, jfloatArray jmeasuredWidth) {
 685         NPE_CHECK_RETURN_ZERO(env, jtext);
 686
 687         Paint* paint = reinterpret_cast<Paint*>(paintHandle);
 688         Typeface* typeface = reinterpret_cast<Typeface*>(typefaceHandle);
 689
 690         bool forwardTextDirection;
 691         if (count < 0) {
 692             forwardTextDirection = false;
 693             count = -count;
 694         }
 695         else {
 696             forwardTextDirection = true;
 697         }
 698
 699         if ((index < 0) || (index + count > env->GetArrayLength(jtext))) {
 700             doThrowAIOOBE(env);
 701             return 0;
 702         }
 703
 704         const jchar* text = env->GetCharArrayElements(jtext, NULL);
 705         count = breakText(env, *paint, typeface, text + index, count, maxWidth,
 706                           bidiFlags, jmeasuredWidth, forwardTextDirection);
 707         env->ReleaseCharArrayElements(jtext, const_cast<jchar*>(text),
 708                                       JNI_ABORT);
 709         return count;
 710     }
 711
 712     static jint breakTextS(JNIEnv* env, jobject clazz, jlong paintHandle, jlong typefaceHandle, jstring jtext,
 713                 jboolean forwards, jfloat maxWidth, jint bidiFlags, jfloatArray jmeasuredWidth) {
 714         NPE_CHECK_RETURN_ZERO(env, jtext);
 715
 716         Paint* paint = reinterpret_cast<Paint*>(paintHandle);
 717         Typeface* typeface = reinterpret_cast<Typeface*>(typefaceHandle);
 718
 719         int count = env->GetStringLength(jtext);
 720         const jchar* text = env->GetStringChars(jtext, NULL);
 721         count = breakText(env, *paint, typeface, text, count, maxWidth, bidiFlags, jmeasuredWidth, forwards);
 722         env->ReleaseStringChars(jtext, text);
 723         return count;
 724     }
 725
 726     static void doTextBounds(JNIEnv* env, const jchar* text, int count, jobject bounds,
 727             const Paint& paint, Typeface* typeface, jint bidiFlags) {
 728         SkRect  r;
 729         SkIRect ir;
 730
 731         Layout layout;
 732         MinikinUtils::doLayout(&layout, &paint, bidiFlags, typeface, text, 0, count, count);
 733         MinikinRect rect;
 734         layout.getBounds(&rect);
 735         r.fLeft = rect.mLeft;
 736         r.fTop = rect.mTop;
 737         r.fRight = rect.mRight;
 738         r.fBottom = rect.mBottom;
 739         r.roundOut(&ir);
 740         GraphicsJNI::irect_to_jrect(ir, env, bounds);
 741     }
 742
 743     static void getStringBounds(JNIEnv* env, jobject, jlong paintHandle, jlong typefaceHandle,
 744                                 jstring text, jint start, jint end, jint bidiFlags, jobject bounds) {
 745         const Paint* paint = reinterpret_cast<Paint*>(paintHandle);
 746         Typeface* typeface = reinterpret_cast<Typeface*>(typefaceHandle);
 747         const jchar* textArray = env->GetStringChars(text, NULL);
 748         doTextBounds(env, textArray + start, end - start, bounds, *paint, typeface, bidiFlags);
 749         env->ReleaseStringChars(text, textArray);
 750     }
 751
 752     static void getCharArrayBounds(JNIEnv* env, jobject, jlong paintHandle, jlong typefaceHandle,
 753                         jcharArray text, jint index, jint count, jint bidiFlags, jobject bounds) {
 754         const Paint* paint = reinterpret_cast<Paint*>(paintHandle);
 755         Typeface* typeface = reinterpret_cast<Typeface*>(typefaceHandle);
 756         const jchar* textArray = env->GetCharArrayElements(text, NULL);
 757         doTextBounds(env, textArray + index, count, bounds, *paint, typeface, bidiFlags);
 758         env->ReleaseCharArrayElements(text, const_cast<jchar*>(textArray),
 759                                       JNI_ABORT);
 760     }
 761
 762     static jboolean layoutContainsNotdef(const Layout& layout) {
 763         for (size_t i = 0; i < layout.nGlyphs(); i++) {
 764             if (layout.getGlyphId(i) == 0) {
 765                 return true;
 766             }
 767         }
 768         return false;
 769     }
 770
 771     // Returns true if the given string is exact one pair of regional indicators.
 772     static bool isFlag(const jchar* str, size_t length) {
 773         const jchar RI_LEAD_SURROGATE = 0xD83C;
 774         const jchar RI_TRAIL_SURROGATE_MIN = 0xDDE6;
 775         const jchar RI_TRAIL_SURROGATE_MAX = 0xDDFF;
 776
 777         if (length != 4) {
 778             return false;
 779         }
 780         if (str[0] != RI_LEAD_SURROGATE || str[2] != RI_LEAD_SURROGATE) {
 781             return false;
 782         }
 783         return RI_TRAIL_SURROGATE_MIN <= str[1] && str[1] <= RI_TRAIL_SURROGATE_MAX &&
 784             RI_TRAIL_SURROGATE_MIN <= str[3] && str[3] <= RI_TRAIL_SURROGATE_MAX;
 785     }
 786
 787     static jboolean hasGlyph(JNIEnv *env, jclass, jlong paintHandle, jlong typefaceHandle,
 788             jint bidiFlags, jstring string) {
 789         const Paint* paint = reinterpret_cast<Paint*>(paintHandle);
 790         Typeface* typeface = reinterpret_cast<Typeface*>(typefaceHandle);
 791         ScopedStringChars str(env, string);
 792
 793         /* Start by rejecting unsupported base code point and variation selector pairs. */
 794         size_t nChars = 0;
 795         const uint32_t kStartOfString = 0xFFFFFFFF;
 796         uint32_t prevCp = kStartOfString;
 797         for (size_t i = 0; i < str.size(); i++) {
 798             jchar cu = str[i];
 799             uint32_t cp = cu;
 800             if (U16_IS_TRAIL(cu)) {
 801                 // invalid UTF-16, unpaired trailing surrogate
 802                 return false;
 803             } else if (U16_IS_LEAD(cu)) {
 804                 if (i + 1 == str.size()) {
 805                     // invalid UTF-16, unpaired leading surrogate at end of string
 806                     return false;
 807                 }
 808                 i++;
 809                 jchar cu2 = str[i];
 810                 if (!U16_IS_TRAIL(cu2)) {
 811                     // invalid UTF-16, unpaired leading surrogate
 812                     return false;
 813                 }
 814                 cp = U16_GET_SUPPLEMENTARY(cu, cu2);
 815             }
 816
 817             if (prevCp != kStartOfString &&
 818                 ((0xFE00 <= cp && cp <= 0xFE0F) || (0xE0100 <= cp && cp <= 0xE01EF))) {
 819                 bool hasVS = MinikinUtils::hasVariationSelector(typeface, prevCp, cp);
 820                 if (!hasVS) {
 821                     // No font has a glyph for the code point and variation selector pair.
 822                     return false;
 823                 } else if (nChars == 1 && i + 1 == str.size()) {
 824                     // The string is just a codepoint and a VS, we have an authoritative answer
 825                     return true;
 826                 }
 827             }
 828             nChars++;
 829             prevCp = cp;
 830         }
 831         Layout layout;
 832         MinikinUtils::doLayout(&layout, paint, bidiFlags, typeface, str.get(), 0, str.size(),
 833                 str.size());
 834         size_t nGlyphs = layout.nGlyphs();
 835         if (nGlyphs != 1 && nChars > 1) {
 836             // multiple-character input, and was not a ligature
 837             // TODO: handle ZWJ/ZWNJ characters specially so we can detect certain ligatures
 838             // in joining scripts, such as Arabic and Mongolian.
 839             return false;
 840         }
 841
 842         if (nGlyphs == 0 || layoutContainsNotdef(layout)) {
 843             return false;  // The collection doesn't have a glyph.
 844         }
 845
 846         if (nChars == 2 && isFlag(str.get(), str.size())) {
 847             // Some font may have a special glyph for unsupported regional indicator pairs.
 848             // To return false for this case, need to compare the glyph id with the one of ZZ
 849             // since ZZ is reserved for unknown or invalid territory.
 850             // U+1F1FF (REGIONAL INDICATOR SYMBOL LETTER Z) is \uD83C\uDDFF in UTF16.
 851             static const jchar ZZ_FLAG_STR[] = { 0xD83C, 0xDDFF, 0xD83C, 0xDDFF };
 852             Layout zzLayout;
 853             MinikinUtils::doLayout(&zzLayout, paint, bidiFlags, typeface, ZZ_FLAG_STR, 0, 4, 4);
 854             if (zzLayout.nGlyphs() != 1 || layoutContainsNotdef(zzLayout)) {
 855                 // The font collection doesn't have a glyph for unknown flag. Just return true.
 856                 return true;
 857             }
 858             return zzLayout.getGlyphId(0) != layout.getGlyphId(0);
 859         }
 860         return true;
 861     }
 862
 863     static jfloat doRunAdvance(const Paint* paint, Typeface* typeface, const jchar buf[],
 864             jint start, jint count, jint bufSize, jboolean isRtl, jint offset) {
 865         int bidiFlags = isRtl ? kBidi_Force_RTL : kBidi_Force_LTR;
 866         if (offset == start + count) {
 867             return MinikinUtils::measureText(paint, bidiFlags, typeface, buf, start, count,
 868                     bufSize, nullptr);
 869         }
 870         std::unique_ptr<float[]> advancesArray(new float[count]);
 871         MinikinUtils::measureText(paint, bidiFlags, typeface, buf, start, count, bufSize,
 872                 advancesArray.get());
 873         return getRunAdvance(advancesArray.get(), buf, start, count, offset);
 874     }
 875
 876     static jfloat getRunAdvance___CIIIIZI_F(JNIEnv *env, jclass, jlong paintHandle,
 877             jlong typefaceHandle, jcharArray text, jint start, jint end, jint contextStart,
 878             jint contextEnd, jboolean isRtl, jint offset) {
 879         const Paint* paint = reinterpret_cast<Paint*>(paintHandle);
 880         Typeface* typeface = reinterpret_cast<Typeface*>(typefaceHandle);
 881         jchar* textArray = (jchar*) env->GetPrimitiveArrayCritical(text, NULL);
 882         jfloat result = doRunAdvance(paint, typeface, textArray + contextStart,
 883                 start - contextStart, end - start, contextEnd - contextStart, isRtl,
 884                 offset - contextStart);
 885         env->ReleasePrimitiveArrayCritical(text, textArray, JNI_ABORT);
 886         return result;
 887     }
 888
 889     static jint doOffsetForAdvance(const Paint* paint, Typeface* typeface, const jchar buf[],
 890             jint start, jint count, jint bufSize, jboolean isRtl, jfloat advance) {
 891         int bidiFlags = isRtl ? kBidi_Force_RTL : kBidi_Force_LTR;
 892         std::unique_ptr<float[]> advancesArray(new float[count]);
 893         MinikinUtils::measureText(paint, bidiFlags, typeface, buf, start, count, bufSize,
 894                 advancesArray.get());
 895         return getOffsetForAdvance(advancesArray.get(), buf, start, count, advance);
 896     }
 897
 898     static jint getOffsetForAdvance___CIIIIZF_I(JNIEnv *env, jclass, jlong paintHandle,
 899             jlong typefaceHandle, jcharArray text, jint start, jint end, jint contextStart,
 900             jint contextEnd, jboolean isRtl, jfloat advance) {
 901         const Paint* paint = reinterpret_cast<Paint*>(paintHandle);
 902         Typeface* typeface = reinterpret_cast<Typeface*>(typefaceHandle);
 903         jchar* textArray = (jchar*) env->GetPrimitiveArrayCritical(text, NULL);
 904         jint result = doOffsetForAdvance(paint, typeface, textArray + contextStart,
 905                 start - contextStart, end - start, contextEnd - contextStart, isRtl, advance);
 906         result += contextStart;
 907         env->ReleasePrimitiveArrayCritical(text, textArray, JNI_ABORT);
 908         return result;
 909     }
 910
 911 }; // namespace PaintGlue
 912
 913 static const JNINativeMethod methods[] = {
 914     {"nGetNativeFinalizer", "()J", (void*) PaintGlue::getNativeFinalizer},
 915     {"nInit","()J", (void*) PaintGlue::init},
 916     {"nInitWithPaint","(J)J", (void*) PaintGlue::initWithPaint},
 917
 918     {"nReset","!(J)V", (void*) PaintGlue::reset},
 919     {"nSet","!(JJ)V", (void*) PaintGlue::assign},
 920     {"nGetFlags","!(J)I", (void*) PaintGlue::getFlags},
 921     {"nSetFlags","!(JI)V", (void*) PaintGlue::setFlags},
 922     {"nGetHinting","!(J)I", (void*) PaintGlue::getHinting},
 923     {"nSetHinting","!(JI)V", (void*) PaintGlue::setHinting},
 924     {"nSetAntiAlias","!(JZ)V", (void*) PaintGlue::setAntiAlias},
 925     {"nSetSubpixelText","!(JZ)V", (void*) PaintGlue::setSubpixelText},
 926     {"nSetLinearText","!(JZ)V", (void*) PaintGlue::setLinearText},
 927     {"nSetUnderlineText","!(JZ)V", (void*) PaintGlue::setUnderlineText},
 928     {"nSetStrikeThruText","!(JZ)V", (void*) PaintGlue::setStrikeThruText},
 929     {"nSetFakeBoldText","!(JZ)V", (void*) PaintGlue::setFakeBoldText},
 930     {"nSetFilterBitmap","!(JZ)V", (void*) PaintGlue::setFilterBitmap},
 931     {"nSetDither","!(JZ)V", (void*) PaintGlue::setDither},
 932     {"nGetStyle","!(J)I", (void*) PaintGlue::getStyle},
 933     {"nSetStyle","!(JI)V", (void*) PaintGlue::setStyle},
 934     {"nGetColor","!(J)I", (void*) PaintGlue::getColor},
 935     {"nSetColor","!(JI)V", (void*) PaintGlue::setColor},
 936     {"nGetAlpha","!(J)I", (void*) PaintGlue::getAlpha},
 937     {"nSetAlpha","!(JI)V", (void*) PaintGlue::setAlpha},
 938     {"nGetStrokeWidth","!(J)F", (void*) PaintGlue::getStrokeWidth},
 939     {"nSetStrokeWidth","!(JF)V", (void*) PaintGlue::setStrokeWidth},
 940     {"nGetStrokeMiter","!(J)F", (void*) PaintGlue::getStrokeMiter},
 941     {"nSetStrokeMiter","!(JF)V", (void*) PaintGlue::setStrokeMiter},
 942     {"nGetStrokeCap","!(J)I", (void*) PaintGlue::getStrokeCap},
 943     {"nSetStrokeCap","!(JI)V", (void*) PaintGlue::setStrokeCap},
 944     {"nGetStrokeJoin","!(J)I", (void*) PaintGlue::getStrokeJoin},
 945     {"nSetStrokeJoin","!(JI)V", (void*) PaintGlue::setStrokeJoin},
 946     {"nGetFillPath","!(JJJ)Z", (void*) PaintGlue::getFillPath},
 947     {"nSetShader","!(JJ)J", (void*) PaintGlue::setShader},
 948     {"nSetColorFilter","!(JJ)J", (void*) PaintGlue::setColorFilter},
 949     {"nSetXfermode","!(JJ)J", (void*) PaintGlue::setXfermode},
 950     {"nSetPathEffect","!(JJ)J", (void*) PaintGlue::setPathEffect},
 951     {"nSetMaskFilter","!(JJ)J", (void*) PaintGlue::setMaskFilter},
 952     {"nSetTypeface","!(JJ)J", (void*) PaintGlue::setTypeface},
 953     {"nSetRasterizer","!(JJ)J", (void*) PaintGlue::setRasterizer},
 954     {"nGetTextAlign","!(J)I", (void*) PaintGlue::getTextAlign},
 955     {"nSetTextAlign","!(JI)V", (void*) PaintGlue::setTextAlign},
 956     {"nSetTextLocales","!(JLjava/lang/String;)I", (void*) PaintGlue::setTextLocales},
 957     {"nSetTextLocalesByMinikinLangListId","!(JI)V",
 958             (void*) PaintGlue::setTextLocalesByMinikinLangListId},
 959     {"nIsElegantTextHeight","!(J)Z", (void*) PaintGlue::isElegantTextHeight},
 960     {"nSetElegantTextHeight","!(JZ)V", (void*) PaintGlue::setElegantTextHeight},
 961     {"nGetTextSize","!(J)F", (void*) PaintGlue::getTextSize},
 962     {"nSetTextSize","!(JF)V", (void*) PaintGlue::setTextSize},
 963     {"nGetTextScaleX","!(J)F", (void*) PaintGlue::getTextScaleX},
 964     {"nSetTextScaleX","!(JF)V", (void*) PaintGlue::setTextScaleX},
 965     {"nGetTextSkewX","!(J)F", (void*) PaintGlue::getTextSkewX},
 966     {"nSetTextSkewX","!(JF)V", (void*) PaintGlue::setTextSkewX},
 967     {"nGetLetterSpacing","!(J)F", (void*) PaintGlue::getLetterSpacing},
 968     {"nSetLetterSpacing","!(JF)V", (void*) PaintGlue::setLetterSpacing},
 969     {"nSetFontFeatureSettings","(JLjava/lang/String;)V",
 970             (void*) PaintGlue::setFontFeatureSettings},
 971     {"nGetHyphenEdit", "!(J)I", (void*) PaintGlue::getHyphenEdit},
 972     {"nSetHyphenEdit", "!(JI)V", (void*) PaintGlue::setHyphenEdit},
 973     {"nAscent","!(JJ)F", (void*) PaintGlue::ascent},
 974     {"nDescent","!(JJ)F", (void*) PaintGlue::descent},
 975
 976     {"nGetFontMetrics", "!(JJLandroid/graphics/Paint$FontMetrics;)F",
 977             (void*)PaintGlue::getFontMetrics},
 978     {"nGetFontMetricsInt", "!(JJLandroid/graphics/Paint$FontMetricsInt;)I",
 979             (void*)PaintGlue::getFontMetricsInt},
 980
 981     {"nBreakText","(JJ[CIIFI[F)I", (void*) PaintGlue::breakTextC},
 982     {"nBreakText","(JJLjava/lang/String;ZFI[F)I", (void*) PaintGlue::breakTextS},
 983     {"nGetTextAdvances","(JJ[CIIIII[FI)F",
 984             (void*) PaintGlue::getTextAdvances___CIIIII_FI},
 985     {"nGetTextAdvances","(JJLjava/lang/String;IIIII[FI)F",
 986             (void*) PaintGlue::getTextAdvances__StringIIIII_FI},
 987
 988     {"nGetTextRunCursor", "(J[CIIIII)I", (void*) PaintGlue::getTextRunCursor___C},
 989     {"nGetTextRunCursor", "(JLjava/lang/String;IIIII)I",
 990             (void*) PaintGlue::getTextRunCursor__String},
 991     {"nGetTextPath", "(JJI[CIIFFJ)V", (void*) PaintGlue::getTextPath___C},
 992     {"nGetTextPath", "(JJILjava/lang/String;IIFFJ)V", (void*) PaintGlue::getTextPath__String},
 993     {"nGetStringBounds", "(JJLjava/lang/String;IIILandroid/graphics/Rect;)V",
 994             (void*) PaintGlue::getStringBounds },
 995     {"nGetCharArrayBounds", "(JJ[CIIILandroid/graphics/Rect;)V",
 996             (void*) PaintGlue::getCharArrayBounds },
 997     {"nHasGlyph", "(JJILjava/lang/String;)Z", (void*) PaintGlue::hasGlyph },
 998     {"nGetRunAdvance", "(JJ[CIIIIZI)F", (void*) PaintGlue::getRunAdvance___CIIIIZI_F},
 999     {"nGetOffsetForAdvance", "(JJ[CIIIIZF)I",
1000             (void*) PaintGlue::getOffsetForAdvance___CIIIIZF_I},
1001
1002     {"nSetShadowLayer", "!(JFFFI)V", (void*)PaintGlue::setShadowLayer},
1003     {"nHasShadowLayer", "!(J)Z", (void*)PaintGlue::hasShadowLayer}
1004 };
1005
1006 int register_android_graphics_Paint(JNIEnv* env) {
1007     gFontMetrics_class = FindClassOrDie(env, "android/graphics/Paint$FontMetrics");
1008     gFontMetrics_class = MakeGlobalRefOrDie(env, gFontMetrics_class);
1009
1010     gFontMetrics_fieldID.top = GetFieldIDOrDie(env, gFontMetrics_class, "top", "F");
1011     gFontMetrics_fieldID.ascent = GetFieldIDOrDie(env, gFontMetrics_class, "ascent", "F");
1012     gFontMetrics_fieldID.descent = GetFieldIDOrDie(env, gFontMetrics_class, "descent", "F");
1013     gFontMetrics_fieldID.bottom = GetFieldIDOrDie(env, gFontMetrics_class, "bottom", "F");
1014     gFontMetrics_fieldID.leading = GetFieldIDOrDie(env, gFontMetrics_class, "leading", "F");
1015
1016     gFontMetricsInt_class = FindClassOrDie(env, "android/graphics/Paint$FontMetricsInt");
1017     gFontMetricsInt_class = MakeGlobalRefOrDie(env, gFontMetricsInt_class);
1018
1019     gFontMetricsInt_fieldID.top = GetFieldIDOrDie(env, gFontMetricsInt_class, "top", "I");
1020     gFontMetricsInt_fieldID.ascent = GetFieldIDOrDie(env, gFontMetricsInt_class, "ascent", "I");
1021     gFontMetricsInt_fieldID.descent = GetFieldIDOrDie(env, gFontMetricsInt_class, "descent", "I");
1022     gFontMetricsInt_fieldID.bottom = GetFieldIDOrDie(env, gFontMetricsInt_class, "bottom", "I");
1023     gFontMetricsInt_fieldID.leading = GetFieldIDOrDie(env, gFontMetricsInt_class, "leading", "I");
1024
1025     return RegisterMethodsOrDie(env, "android/graphics/Paint", methods, NELEM(methods));
1026 }
1027
1028 }