/* libs/android_runtime/android/graphics/Paint.cpp ** ** Copyright 2006, The Android Open Source Project ** ** Licensed under the Apache License, Version 2.0 (the "License"); ** you may not use this file except in compliance with the License. ** You may obtain a copy of the License at ** ** http://www.apache.org/licenses/LICENSE-2.0 ** ** Unless required by applicable law or agreed to in writing, software ** distributed under the License is distributed on an "AS IS" BASIS, ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ** See the License for the specific language governing permissions and ** limitations under the License. */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "ColorFilter.h" #include "GraphicsJNI.h" #include "SkBlendMode.h" #include "SkColorFilter.h" #include "SkColorSpace.h" #include "SkFont.h" #include "SkFontMetrics.h" #include "SkFontTypes.h" #include "SkMaskFilter.h" #include "SkPath.h" #include "SkPathEffect.h" #include "SkPathUtils.h" #include "SkShader.h" #include "unicode/uloc.h" #include "utils/Blur.h" namespace android { namespace { void copyMinikinRectToSkRect(const minikin::MinikinRect& minikinRect, SkRect* skRect) { skRect->fLeft = minikinRect.mLeft; skRect->fTop = minikinRect.mTop; skRect->fRight = minikinRect.mRight; skRect->fBottom = minikinRect.mBottom; } } // namespace static void getPosTextPath(const SkFont& font, const uint16_t glyphs[], int count, const SkPoint pos[], SkPath* dst) { dst->reset(); struct Rec { SkPath* fDst; const SkPoint* fPos; } rec = { dst, pos }; font.getPaths(glyphs, count, [](const SkPath* src, const SkMatrix& mx, void* ctx) { Rec* rec = (Rec*)ctx; if (src) { SkMatrix tmp(mx); tmp.postTranslate(rec->fPos->fX, rec->fPos->fY); rec->fDst->addPath(*src, tmp); } rec->fPos += 1; }, &rec); } namespace PaintGlue { enum MoveOpt { AFTER, AT_OR_AFTER, BEFORE, AT_OR_BEFORE, AT }; static void deletePaint(Paint* paint) { delete paint; } static jlong getNativeFinalizer(JNIEnv*, jobject) { return static_cast(reinterpret_cast(&deletePaint)); } static jlong init(JNIEnv* env, jobject) { return reinterpret_cast(new Paint); } static jlong initWithPaint(JNIEnv* env, jobject clazz, jlong paintHandle) { Paint* paint = reinterpret_cast(paintHandle); Paint* obj = new Paint(*paint); return reinterpret_cast(obj); } static int breakText(JNIEnv* env, const Paint& paint, const Typeface* typeface, const jchar text[], int count, float maxWidth, jint bidiFlags, jfloatArray jmeasured, const bool forwardScan) { size_t measuredCount = 0; float measured = 0; std::unique_ptr advancesArray(new float[count]); MinikinUtils::measureText(&paint, static_cast(bidiFlags), typeface, text, 0, count, count, advancesArray.get(), nullptr, nullptr); for (int i = 0; i < count; i++) { // traverse in the given direction int index = forwardScan ? i : (count - i - 1); float width = advancesArray[index]; if (measured + width > maxWidth) { break; } // properly handle clusters when scanning backwards if (forwardScan || width != 0.0f) { measuredCount = i + 1; } measured += width; } if (jmeasured && env->GetArrayLength(jmeasured) > 0) { AutoJavaFloatArray autoMeasured(env, jmeasured, 1); jfloat* array = autoMeasured.ptr(); array[0] = measured; } return measuredCount; } static jint breakTextC(JNIEnv* env, jobject clazz, jlong paintHandle, jcharArray jtext, jint index, jint count, jfloat maxWidth, jint bidiFlags, jfloatArray jmeasuredWidth) { NPE_CHECK_RETURN_ZERO(env, jtext); Paint* paint = reinterpret_cast(paintHandle); const Typeface* typeface = paint->getAndroidTypeface(); bool forwardTextDirection; if (count < 0) { forwardTextDirection = false; count = -count; } else { forwardTextDirection = true; } if ((index < 0) || (index + count > env->GetArrayLength(jtext))) { doThrowAIOOBE(env); return 0; } const jchar* text = env->GetCharArrayElements(jtext, nullptr); count = breakText(env, *paint, typeface, text + index, count, maxWidth, bidiFlags, jmeasuredWidth, forwardTextDirection); env->ReleaseCharArrayElements(jtext, const_cast(text), JNI_ABORT); return count; } static jint breakTextS(JNIEnv* env, jobject clazz, jlong paintHandle, jstring jtext, jboolean forwards, jfloat maxWidth, jint bidiFlags, jfloatArray jmeasuredWidth) { NPE_CHECK_RETURN_ZERO(env, jtext); Paint* paint = reinterpret_cast(paintHandle); const Typeface* typeface = paint->getAndroidTypeface(); int count = env->GetStringLength(jtext); const jchar* text = env->GetStringChars(jtext, nullptr); count = breakText(env, *paint, typeface, text, count, maxWidth, bidiFlags, jmeasuredWidth, forwards); env->ReleaseStringChars(jtext, text); return count; } static jfloat doTextAdvances(JNIEnv *env, Paint *paint, const Typeface* typeface, const jchar *text, jint start, jint count, jint contextCount, jint bidiFlags, jfloatArray advances, jint advancesIndex) { NPE_CHECK_RETURN_ZERO(env, text); if ((start | count | contextCount | advancesIndex) < 0 || contextCount < count) { doThrowAIOOBE(env); return 0; } if (count == 0) { return 0; } if (advances) { size_t advancesLength = env->GetArrayLength(advances); if ((size_t)(count + advancesIndex) > advancesLength) { doThrowAIOOBE(env); return 0; } } std::unique_ptr advancesArray; if (advances) { advancesArray.reset(new jfloat[count]); } const float advance = MinikinUtils::measureText( paint, static_cast(bidiFlags), typeface, text, start, count, contextCount, advancesArray.get(), nullptr, nullptr); if (advances) { env->SetFloatArrayRegion(advances, advancesIndex, count, advancesArray.get()); } return advance; } static jfloat getTextAdvances___CIIIII_FI(JNIEnv* env, jobject clazz, jlong paintHandle, jcharArray text, jint index, jint count, jint contextIndex, jint contextCount, jint bidiFlags, jfloatArray advances, jint advancesIndex) { Paint* paint = reinterpret_cast(paintHandle); const Typeface* typeface = paint->getAndroidTypeface(); jchar* textArray = env->GetCharArrayElements(text, nullptr); jfloat result = doTextAdvances(env, paint, typeface, textArray + contextIndex, index - contextIndex, count, contextCount, bidiFlags, advances, advancesIndex); env->ReleaseCharArrayElements(text, textArray, JNI_ABORT); return result; } static jfloat getTextAdvances__StringIIIII_FI(JNIEnv* env, jobject clazz, jlong paintHandle, jstring text, jint start, jint end, jint contextStart, jint contextEnd, jint bidiFlags, jfloatArray advances, jint advancesIndex) { Paint* paint = reinterpret_cast(paintHandle); const Typeface* typeface = paint->getAndroidTypeface(); const jchar* textArray = env->GetStringChars(text, nullptr); jfloat result = doTextAdvances(env, paint, typeface, textArray + contextStart, start - contextStart, end - start, contextEnd - contextStart, bidiFlags, advances, advancesIndex); env->ReleaseStringChars(text, textArray); return result; } static jint doTextRunCursor(JNIEnv *env, Paint* paint, const Typeface* typeface, const jchar *text, jint start, jint count, jint dir, jint offset, jint opt) { minikin::GraphemeBreak::MoveOpt moveOpt = minikin::GraphemeBreak::MoveOpt(opt); minikin::Bidi bidiFlags = dir == 1 ? minikin::Bidi::FORCE_RTL : minikin::Bidi::FORCE_LTR; std::unique_ptr advancesArray(new float[count]); MinikinUtils::measureText(paint, bidiFlags, typeface, text, start, count, start + count, advancesArray.get(), nullptr, nullptr); size_t result = minikin::GraphemeBreak::getTextRunCursor(advancesArray.get(), text, start, count, offset, moveOpt); return static_cast(result); } static jint getTextRunCursor___C(JNIEnv* env, jobject clazz, jlong paintHandle, jcharArray text, jint contextStart, jint contextCount, jint dir, jint offset, jint cursorOpt) { Paint* paint = reinterpret_cast(paintHandle); const Typeface* typeface = paint->getAndroidTypeface(); jchar* textArray = env->GetCharArrayElements(text, nullptr); jint result = doTextRunCursor(env, paint, typeface, textArray, contextStart, contextCount, dir, offset, cursorOpt); env->ReleaseCharArrayElements(text, textArray, JNI_ABORT); return result; } static jint getTextRunCursor__String(JNIEnv* env, jobject clazz, jlong paintHandle, jstring text, jint contextStart, jint contextEnd, jint dir, jint offset, jint cursorOpt) { Paint* paint = reinterpret_cast(paintHandle); const Typeface* typeface = paint->getAndroidTypeface(); const jchar* textArray = env->GetStringChars(text, nullptr); jint result = doTextRunCursor(env, paint, typeface, textArray, contextStart, contextEnd - contextStart, dir, offset, cursorOpt); env->ReleaseStringChars(text, textArray); return result; } class GetTextFunctor { public: GetTextFunctor(const minikin::Layout& layout, SkPath* path, jfloat x, jfloat y, Paint* paint, uint16_t* glyphs, SkPoint* pos) : layout(layout), path(path), x(x), y(y), paint(paint), glyphs(glyphs), pos(pos) { } void operator()(size_t start, size_t end) { for (size_t i = start; i < end; i++) { glyphs[i] = layout.getGlyphId(i); pos[i].fX = x + layout.getX(i); pos[i].fY = y + layout.getY(i); } const SkFont& font = paint->getSkFont(); if (start == 0) { getPosTextPath(font, glyphs, end, pos, path); } else { getPosTextPath(font, glyphs + start, end - start, pos + start, &tmpPath); path->addPath(tmpPath); } } private: const minikin::Layout& layout; SkPath* path; jfloat x; jfloat y; Paint* paint; uint16_t* glyphs; SkPoint* pos; SkPath tmpPath; }; static void getTextPath(JNIEnv* env, Paint* paint, const Typeface* typeface, const jchar* text, jint count, jint bidiFlags, jfloat x, jfloat y, SkPath* path) { minikin::Layout layout = MinikinUtils::doLayout( paint, static_cast(bidiFlags), typeface, text, count, // text buffer 0, count, // draw range 0, count, // context range nullptr); size_t nGlyphs = layout.nGlyphs(); uint16_t* glyphs = new uint16_t[nGlyphs]; SkPoint* pos = new SkPoint[nGlyphs]; x += MinikinUtils::xOffsetForTextAlign(paint, layout); Paint::Align align = paint->getTextAlign(); paint->setTextAlign(Paint::kLeft_Align); GetTextFunctor f(layout, path, x, y, paint, glyphs, pos); MinikinUtils::forFontRun(layout, paint, f); paint->setTextAlign(align); delete[] glyphs; delete[] pos; } static void getTextPath___C(JNIEnv* env, jobject clazz, jlong paintHandle, jint bidiFlags, jcharArray text, jint index, jint count, jfloat x, jfloat y, jlong pathHandle) { Paint* paint = reinterpret_cast(paintHandle); const Typeface* typeface = paint->getAndroidTypeface(); SkPath* path = reinterpret_cast(pathHandle); const jchar* textArray = env->GetCharArrayElements(text, nullptr); getTextPath(env, paint, typeface, textArray + index, count, bidiFlags, x, y, path); env->ReleaseCharArrayElements(text, const_cast(textArray), JNI_ABORT); } static void getTextPath__String(JNIEnv* env, jobject clazz, jlong paintHandle, jint bidiFlags, jstring text, jint start, jint end, jfloat x, jfloat y, jlong pathHandle) { Paint* paint = reinterpret_cast(paintHandle); const Typeface* typeface = paint->getAndroidTypeface(); SkPath* path = reinterpret_cast(pathHandle); const jchar* textArray = env->GetStringChars(text, nullptr); getTextPath(env, paint, typeface, textArray + start, end - start, bidiFlags, x, y, path); env->ReleaseStringChars(text, textArray); } static void doTextBounds(JNIEnv* env, const jchar* text, int count, jobject bounds, const Paint& paint, const Typeface* typeface, jint bidiFlagsInt) { SkRect r; SkIRect ir; minikin::MinikinRect rect; minikin::Bidi bidiFlags = static_cast(bidiFlagsInt); MinikinUtils::getBounds(&paint, bidiFlags, typeface, text, count, &rect); r.fLeft = rect.mLeft; r.fTop = rect.mTop; r.fRight = rect.mRight; r.fBottom = rect.mBottom; r.roundOut(&ir); GraphicsJNI::irect_to_jrect(ir, env, bounds); } static void getStringBounds(JNIEnv* env, jobject, jlong paintHandle, jstring text, jint start, jint end, jint bidiFlags, jobject bounds) { const Paint* paint = reinterpret_cast(paintHandle); const Typeface* typeface = paint->getAndroidTypeface(); const jchar* textArray = env->GetStringChars(text, nullptr); doTextBounds(env, textArray + start, end - start, bounds, *paint, typeface, bidiFlags); env->ReleaseStringChars(text, textArray); } static void getCharArrayBounds(JNIEnv* env, jobject, jlong paintHandle, jcharArray text, jint index, jint count, jint bidiFlags, jobject bounds) { const Paint* paint = reinterpret_cast(paintHandle); const Typeface* typeface = paint->getAndroidTypeface(); const jchar* textArray = env->GetCharArrayElements(text, nullptr); doTextBounds(env, textArray + index, count, bounds, *paint, typeface, bidiFlags); env->ReleaseCharArrayElements(text, const_cast(textArray), JNI_ABORT); } // Returns true if the given string is exact one pair of regional indicators. static bool isFlag(const jchar* str, size_t length) { const jchar RI_LEAD_SURROGATE = 0xD83C; const jchar RI_TRAIL_SURROGATE_MIN = 0xDDE6; const jchar RI_TRAIL_SURROGATE_MAX = 0xDDFF; if (length != 4) { return false; } if (str[0] != RI_LEAD_SURROGATE || str[2] != RI_LEAD_SURROGATE) { return false; } return RI_TRAIL_SURROGATE_MIN <= str[1] && str[1] <= RI_TRAIL_SURROGATE_MAX && RI_TRAIL_SURROGATE_MIN <= str[3] && str[3] <= RI_TRAIL_SURROGATE_MAX; } static jboolean layoutContainsNotdef(const minikin::Layout& layout) { for (size_t i = 0; i < layout.nGlyphs(); i++) { if (layout.getGlyphId(i) == 0) { return true; } } return false; } // Don't count glyphs that are the recommended "space" glyph and are zero width. // This logic makes assumptions about HarfBuzz layout, but does correctly handle // cases where ligatures form and zero width space glyphs are left in as // placeholders. static size_t countNonSpaceGlyphs(const minikin::Layout& layout) { size_t count = 0; static unsigned int kSpaceGlyphId = 3; for (size_t i = 0; i < layout.nGlyphs(); i++) { if (layout.getGlyphId(i) != kSpaceGlyphId || layout.getCharAdvance(i) != 0.0) { count++; } } return count; } static jboolean hasGlyph(JNIEnv *env, jclass, jlong paintHandle, jint bidiFlags, jstring string) { const Paint* paint = reinterpret_cast(paintHandle); const Typeface* typeface = paint->getAndroidTypeface(); ScopedStringChars str(env, string); /* Start by rejecting unsupported base code point and variation selector pairs. */ size_t nChars = 0; const uint32_t kStartOfString = 0xFFFFFFFF; uint32_t prevCp = kStartOfString; for (size_t i = 0; i < str.size(); i++) { jchar cu = str[i]; uint32_t cp = cu; if (U16_IS_TRAIL(cu)) { // invalid UTF-16, unpaired trailing surrogate return false; } else if (U16_IS_LEAD(cu)) { if (i + 1 == str.size()) { // invalid UTF-16, unpaired leading surrogate at end of string return false; } i++; jchar cu2 = str[i]; if (!U16_IS_TRAIL(cu2)) { // invalid UTF-16, unpaired leading surrogate return false; } cp = U16_GET_SUPPLEMENTARY(cu, cu2); } if (prevCp != kStartOfString && ((0xFE00 <= cp && cp <= 0xFE0F) || (0xE0100 <= cp && cp <= 0xE01EF))) { bool hasVS = MinikinUtils::hasVariationSelector(typeface, prevCp, cp); if (!hasVS) { // No font has a glyph for the code point and variation selector pair. return false; } else if (nChars == 1 && i + 1 == str.size()) { // The string is just a codepoint and a VS, we have an authoritative answer return true; } } nChars++; prevCp = cp; } minikin::Layout layout = MinikinUtils::doLayout(paint, static_cast(bidiFlags), typeface, str.get(), str.size(), // text buffer 0, str.size(), // draw range 0, str.size(), // context range nullptr); size_t nGlyphs = countNonSpaceGlyphs(layout); if (nGlyphs != 1 && nChars > 1) { // multiple-character input, and was not a ligature // TODO: handle ZWJ/ZWNJ characters specially so we can detect certain ligatures // in joining scripts, such as Arabic and Mongolian. return false; } if (nGlyphs == 0 || layoutContainsNotdef(layout)) { return false; // The collection doesn't have a glyph. } if (nChars == 2 && isFlag(str.get(), str.size())) { // Some font may have a special glyph for unsupported regional indicator pairs. // To return false for this case, need to compare the glyph id with the one of ZZ // since ZZ is reserved for unknown or invalid territory. // U+1F1FF (REGIONAL INDICATOR SYMBOL LETTER Z) is \uD83C\uDDFF in UTF16. static const jchar ZZ_FLAG_STR[] = { 0xD83C, 0xDDFF, 0xD83C, 0xDDFF }; minikin::Layout zzLayout = MinikinUtils::doLayout(paint, static_cast(bidiFlags), typeface, ZZ_FLAG_STR, 4, // text buffer 0, 4, // draw range 0, 4, // context range nullptr); if (zzLayout.nGlyphs() != 1 || layoutContainsNotdef(zzLayout)) { // The font collection doesn't have a glyph for unknown flag. Just return true. return true; } return zzLayout.getGlyphId(0) != layout.getGlyphId(0); } return true; } static jfloat doRunAdvance(JNIEnv* env, const Paint* paint, const Typeface* typeface, const jchar buf[], jint start, jint count, jint bufSize, jboolean isRtl, jint offset, jfloatArray advances, jint advancesIndex, SkRect* drawBounds, uint32_t* clusterCount) { if (advances) { size_t advancesLength = env->GetArrayLength(advances); if ((size_t)(count + advancesIndex) > advancesLength) { doThrowAIOOBE(env); return 0; } } minikin::Bidi bidiFlags = isRtl ? minikin::Bidi::FORCE_RTL : minikin::Bidi::FORCE_LTR; minikin::MinikinRect bounds; if (offset == start + count && advances == nullptr) { float result = MinikinUtils::measureText(paint, bidiFlags, typeface, buf, start, count, bufSize, nullptr, drawBounds ? &bounds : nullptr, clusterCount); if (drawBounds) { copyMinikinRectToSkRect(bounds, drawBounds); } return result; } std::unique_ptr advancesArray(new float[count]); MinikinUtils::measureText(paint, bidiFlags, typeface, buf, start, count, bufSize, advancesArray.get(), drawBounds ? &bounds : nullptr, clusterCount); if (drawBounds) { copyMinikinRectToSkRect(bounds, drawBounds); } float result = minikin::getRunAdvance(advancesArray.get(), buf, start, count, offset); if (advances) { minikin::distributeAdvances(advancesArray.get(), buf, start, count); env->SetFloatArrayRegion(advances, advancesIndex, count, advancesArray.get()); } return result; } static jfloat getRunAdvance___CIIIIZI_F(JNIEnv *env, jclass, jlong paintHandle, jcharArray text, jint start, jint end, jint contextStart, jint contextEnd, jboolean isRtl, jint offset) { const Paint* paint = reinterpret_cast(paintHandle); const Typeface* typeface = paint->getAndroidTypeface(); ScopedCharArrayRO textArray(env, text); jfloat result = doRunAdvance(env, paint, typeface, textArray.get() + contextStart, start - contextStart, end - start, contextEnd - contextStart, isRtl, offset - contextStart, nullptr, 0, nullptr, nullptr); return result; } static jfloat getRunCharacterAdvance___CIIIIZI_FI_F(JNIEnv* env, jclass, jlong paintHandle, jcharArray text, jint start, jint end, jint contextStart, jint contextEnd, jboolean isRtl, jint offset, jfloatArray advances, jint advancesIndex, jobject drawBounds, jobject runInfo) { const Paint* paint = reinterpret_cast(paintHandle); const Typeface* typeface = paint->getAndroidTypeface(); ScopedCharArrayRO textArray(env, text); SkRect skDrawBounds; uint32_t clusterCount = 0; jfloat result = doRunAdvance(env, paint, typeface, textArray.get() + contextStart, start - contextStart, end - start, contextEnd - contextStart, isRtl, offset - contextStart, advances, advancesIndex, drawBounds ? &skDrawBounds : nullptr, &clusterCount); if (drawBounds != nullptr) { GraphicsJNI::rect_to_jrectf(skDrawBounds, env, drawBounds); } if (runInfo) { GraphicsJNI::set_cluster_count_to_run_info(env, runInfo, clusterCount); } return result; } static jint doOffsetForAdvance(const Paint* paint, const Typeface* typeface, const jchar buf[], jint start, jint count, jint bufSize, jboolean isRtl, jfloat advance) { minikin::Bidi bidiFlags = isRtl ? minikin::Bidi::FORCE_RTL : minikin::Bidi::FORCE_LTR; std::unique_ptr advancesArray(new float[count]); MinikinUtils::measureText(paint, bidiFlags, typeface, buf, start, count, bufSize, advancesArray.get(), nullptr, nullptr); return minikin::getOffsetForAdvance(advancesArray.get(), buf, start, count, advance); } static jint getOffsetForAdvance___CIIIIZF_I(JNIEnv *env, jclass, jlong paintHandle, jcharArray text, jint start, jint end, jint contextStart, jint contextEnd, jboolean isRtl, jfloat advance) { const Paint* paint = reinterpret_cast(paintHandle); const Typeface* typeface = paint->getAndroidTypeface(); ScopedCharArrayRO textArray(env, text); jint result = doOffsetForAdvance(paint, typeface, textArray.get() + contextStart, start - contextStart, end - start, contextEnd - contextStart, isRtl, advance); result += contextStart; return result; } static SkScalar getMetricsInternal(jlong paintHandle, SkFontMetrics* metrics, bool useLocale) { const int kElegantTop = 2500; const int kElegantBottom = -1000; const int kElegantAscent = 1900; const int kElegantDescent = -500; const int kElegantLeading = 0; Paint* paint = reinterpret_cast(paintHandle); SkFont* font = &paint->getSkFont(); const Typeface* typeface = paint->getAndroidTypeface(); typeface = Typeface::resolveDefault(typeface); minikin::FakedFont baseFont = typeface->fFontCollection->baseFontFaked(typeface->fStyle); float saveSkewX = font->getSkewX(); bool savefakeBold = font->isEmbolden(); MinikinFontSkia::populateSkFont(font, baseFont.typeface().get(), baseFont.fakery); SkScalar spacing = font->getMetrics(metrics); // The populateSkPaint call may have changed fake bold / text skew // because we want to measure with those effects applied, so now // restore the original settings. font->setSkewX(saveSkewX); font->setEmbolden(savefakeBold); if (paint->getFamilyVariant() == minikin::FamilyVariant::ELEGANT) { SkScalar size = font->getSize(); metrics->fTop = -size * kElegantTop / 2048; metrics->fBottom = -size * kElegantBottom / 2048; metrics->fAscent = -size * kElegantAscent / 2048; metrics->fDescent = -size * kElegantDescent / 2048; metrics->fLeading = size * kElegantLeading / 2048; spacing = metrics->fDescent - metrics->fAscent + metrics->fLeading; } if (useLocale) { minikin::MinikinPaint minikinPaint = MinikinUtils::prepareMinikinPaint(paint, typeface); minikin::MinikinExtent extent = typeface->fFontCollection->getReferenceExtentForLocale(minikinPaint); metrics->fAscent = std::min(extent.ascent, metrics->fAscent); metrics->fDescent = std::max(extent.descent, metrics->fDescent); metrics->fTop = std::min(metrics->fAscent, metrics->fTop); metrics->fBottom = std::max(metrics->fDescent, metrics->fBottom); } return spacing; } static void doFontExtent(JNIEnv* env, jlong paintHandle, const jchar buf[], jint start, jint count, jint bufSize, jboolean isRtl, jobject fmi) { const Paint* paint = reinterpret_cast(paintHandle); const Typeface* typeface = paint->getAndroidTypeface(); minikin::Bidi bidiFlags = isRtl ? minikin::Bidi::FORCE_RTL : minikin::Bidi::FORCE_LTR; minikin::MinikinExtent extent = MinikinUtils::getFontExtent(paint, bidiFlags, typeface, buf, start, count, bufSize); SkFontMetrics metrics; getMetricsInternal(paintHandle, &metrics, false /* useLocale */); metrics.fAscent = extent.ascent; metrics.fDescent = extent.descent; // If top/bottom is narrower than ascent/descent, adjust top/bottom to ascent/descent. metrics.fTop = std::min(metrics.fAscent, metrics.fTop); metrics.fBottom = std::max(metrics.fDescent, metrics.fBottom); GraphicsJNI::set_metrics_int(env, fmi, metrics); } static void getFontMetricsIntForText___C(JNIEnv* env, jclass, jlong paintHandle, jcharArray text, jint start, jint count, jint ctxStart, jint ctxCount, jboolean isRtl, jobject fmi) { ScopedCharArrayRO textArray(env, text); doFontExtent(env, paintHandle, textArray.get() + ctxStart, start - ctxStart, count, ctxCount, isRtl, fmi); } static void getFontMetricsIntForText___String(JNIEnv* env, jclass, jlong paintHandle, jstring text, jint start, jint count, jint ctxStart, jint ctxCount, jboolean isRtl, jobject fmi) { ScopedStringChars textChars(env, text); doFontExtent(env, paintHandle, textChars.get() + ctxStart, start - ctxStart, count, ctxCount, isRtl, fmi); } // ------------------ @FastNative --------------------------- static jint setTextLocales(JNIEnv* env, jobject clazz, jlong objHandle, jstring locales) { Paint* obj = reinterpret_cast(objHandle); ScopedUtfChars localesChars(env, locales); jint minikinLocaleListId = minikin::registerLocaleList(localesChars.c_str()); obj->setMinikinLocaleListId(minikinLocaleListId); return minikinLocaleListId; } static void setFontFeatureSettings(JNIEnv* env, jobject clazz, jlong paintHandle, jstring settings) { Paint* paint = reinterpret_cast(paintHandle); if (!settings) { paint->resetFontFeatures(); } else { ScopedUtfChars settingsChars(env, settings); paint->setFontFeatureSettings( std::string_view(settingsChars.c_str(), settingsChars.size())); } } static jfloat getFontMetrics(JNIEnv* env, jobject, jlong paintHandle, jobject metricsObj, jboolean useLocale) { SkFontMetrics metrics; SkScalar spacing = getMetricsInternal(paintHandle, &metrics, useLocale); GraphicsJNI::set_metrics(env, metricsObj, metrics); return SkScalarToFloat(spacing); } static jint getFontMetricsInt(JNIEnv* env, jobject, jlong paintHandle, jobject metricsObj, jboolean useLocale) { SkFontMetrics metrics; getMetricsInternal(paintHandle, &metrics, useLocale); return GraphicsJNI::set_metrics_int(env, metricsObj, metrics); } // ------------------ @CriticalNative --------------------------- static void reset(CRITICAL_JNI_PARAMS_COMMA jlong objHandle) { reinterpret_cast(objHandle)->reset(); } static void assign(CRITICAL_JNI_PARAMS_COMMA jlong dstPaintHandle, jlong srcPaintHandle) { Paint* dst = reinterpret_cast(dstPaintHandle); const Paint* src = reinterpret_cast(srcPaintHandle); *dst = *src; } static jint getFlags(CRITICAL_JNI_PARAMS_COMMA jlong paintHandle) { uint32_t flags = reinterpret_cast(paintHandle)->getJavaFlags(); return static_cast(flags); } static void setFlags(CRITICAL_JNI_PARAMS_COMMA jlong paintHandle, jint flags) { reinterpret_cast(paintHandle)->setJavaFlags(flags); } static jint getHinting(CRITICAL_JNI_PARAMS_COMMA jlong paintHandle) { return (SkFontHinting)reinterpret_cast(paintHandle)->getSkFont().getHinting() == SkFontHinting::kNone ? 0 : 1; } static void setHinting(CRITICAL_JNI_PARAMS_COMMA jlong paintHandle, jint mode) { reinterpret_cast(paintHandle)->getSkFont().setHinting( mode == 0 ? SkFontHinting::kNone : SkFontHinting::kNormal); } static void setAntiAlias(CRITICAL_JNI_PARAMS_COMMA jlong paintHandle, jboolean aa) { reinterpret_cast(paintHandle)->setAntiAlias(aa); } static void setLinearText(CRITICAL_JNI_PARAMS_COMMA jlong paintHandle, jboolean linearText) { reinterpret_cast(paintHandle)->getSkFont().setLinearMetrics(linearText); } static void setSubpixelText(CRITICAL_JNI_PARAMS_COMMA jlong paintHandle, jboolean subpixelText) { reinterpret_cast(paintHandle)->getSkFont().setSubpixel(subpixelText); } static void setUnderlineText(CRITICAL_JNI_PARAMS_COMMA jlong paintHandle, jboolean underlineText) { reinterpret_cast(paintHandle)->setUnderline(underlineText); } static void setStrikeThruText(CRITICAL_JNI_PARAMS_COMMA jlong paintHandle, jboolean strikeThruText) { reinterpret_cast(paintHandle)->setStrikeThru(strikeThruText); } static void setFakeBoldText(CRITICAL_JNI_PARAMS_COMMA jlong paintHandle, jboolean fakeBoldText) { reinterpret_cast(paintHandle)->getSkFont().setEmbolden(fakeBoldText); } static void setFilterBitmap(CRITICAL_JNI_PARAMS_COMMA jlong paintHandle, jboolean filterBitmap) { reinterpret_cast(paintHandle)->setFilterBitmap(filterBitmap); } static void setDither(CRITICAL_JNI_PARAMS_COMMA jlong paintHandle, jboolean dither) { reinterpret_cast(paintHandle)->setDither(dither); } static jint getStyle(CRITICAL_JNI_PARAMS_COMMA jlong objHandle) { Paint* obj = reinterpret_cast(objHandle); return static_cast(obj->getStyle()); } static void setStyle(CRITICAL_JNI_PARAMS_COMMA jlong objHandle, jint styleHandle) { Paint* obj = reinterpret_cast(objHandle); Paint::Style style = static_cast(styleHandle); obj->setStyle(style); } static void setColorLong(CRITICAL_JNI_PARAMS_COMMA jlong paintHandle, jlong colorSpaceHandle, jlong colorLong) { SkColor4f color = GraphicsJNI::convertColorLong(colorLong); sk_sp cs = GraphicsJNI::getNativeColorSpace(colorSpaceHandle); reinterpret_cast(paintHandle)->setColor4f(color, cs.get()); } static void setColor(CRITICAL_JNI_PARAMS_COMMA jlong paintHandle, jint color) { reinterpret_cast(paintHandle)->setColor(color); } static void setAlpha(CRITICAL_JNI_PARAMS_COMMA jlong paintHandle, jint a) { reinterpret_cast(paintHandle)->setAlpha(a); } static jfloat getStrokeWidth(CRITICAL_JNI_PARAMS_COMMA jlong paintHandle) { return SkScalarToFloat(reinterpret_cast(paintHandle)->getStrokeWidth()); } static void setStrokeWidth(CRITICAL_JNI_PARAMS_COMMA jlong paintHandle, jfloat width) { reinterpret_cast(paintHandle)->setStrokeWidth(width); } static jfloat getStrokeMiter(CRITICAL_JNI_PARAMS_COMMA jlong paintHandle) { return SkScalarToFloat(reinterpret_cast(paintHandle)->getStrokeMiter()); } static void setStrokeMiter(CRITICAL_JNI_PARAMS_COMMA jlong paintHandle, jfloat miter) { reinterpret_cast(paintHandle)->setStrokeMiter(miter); } static jint getStrokeCap(CRITICAL_JNI_PARAMS_COMMA jlong objHandle) { Paint* obj = reinterpret_cast(objHandle); return static_cast(obj->getStrokeCap()); } static void setStrokeCap(CRITICAL_JNI_PARAMS_COMMA jlong objHandle, jint capHandle) { Paint* obj = reinterpret_cast(objHandle); Paint::Cap cap = static_cast(capHandle); obj->setStrokeCap(cap); } static jint getStrokeJoin(CRITICAL_JNI_PARAMS_COMMA jlong objHandle) { Paint* obj = reinterpret_cast(objHandle); return static_cast(obj->getStrokeJoin()); } static void setStrokeJoin(CRITICAL_JNI_PARAMS_COMMA jlong objHandle, jint joinHandle) { Paint* obj = reinterpret_cast(objHandle); Paint::Join join = (Paint::Join) joinHandle; obj->setStrokeJoin(join); } static jboolean getFillPath(CRITICAL_JNI_PARAMS_COMMA jlong objHandle, jlong srcHandle, jlong dstHandle) { Paint* obj = reinterpret_cast(objHandle); SkPath* src = reinterpret_cast(srcHandle); SkPath* dst = reinterpret_cast(dstHandle); return skpathutils::FillPathWithPaint(*src, *obj, dst) ? JNI_TRUE : JNI_FALSE; } static jlong setShader(CRITICAL_JNI_PARAMS_COMMA jlong objHandle, jlong shaderHandle) { Paint* obj = reinterpret_cast(objHandle); SkShader* shader = reinterpret_cast(shaderHandle); obj->setShader(sk_ref_sp(shader)); return reinterpret_cast(obj->getShader()); } static jlong setColorFilter(CRITICAL_JNI_PARAMS_COMMA jlong objHandle, jlong filterHandle) { Paint* obj = reinterpret_cast(objHandle); auto colorFilter = uirenderer::ColorFilter::fromJava(filterHandle); auto skColorFilter = colorFilter != nullptr ? colorFilter->getInstance() : sk_sp(); obj->setColorFilter(skColorFilter); return filterHandle; } static void setXfermode(CRITICAL_JNI_PARAMS_COMMA jlong paintHandle, jint xfermodeHandle) { // validate that the Java enum values match our expectations static_assert(0 == static_cast(SkBlendMode::kClear), "xfermode_mismatch"); static_assert(1 == static_cast(SkBlendMode::kSrc), "xfermode_mismatch"); static_assert(2 == static_cast(SkBlendMode::kDst), "xfermode_mismatch"); static_assert(3 == static_cast(SkBlendMode::kSrcOver), "xfermode_mismatch"); static_assert(4 == static_cast(SkBlendMode::kDstOver), "xfermode_mismatch"); static_assert(5 == static_cast(SkBlendMode::kSrcIn), "xfermode_mismatch"); static_assert(6 == static_cast(SkBlendMode::kDstIn), "xfermode_mismatch"); static_assert(7 == static_cast(SkBlendMode::kSrcOut), "xfermode_mismatch"); static_assert(8 == static_cast(SkBlendMode::kDstOut), "xfermode_mismatch"); static_assert(9 == static_cast(SkBlendMode::kSrcATop), "xfermode_mismatch"); static_assert(10 == static_cast(SkBlendMode::kDstATop), "xfermode_mismatch"); static_assert(11 == static_cast(SkBlendMode::kXor), "xfermode_mismatch"); static_assert(12 == static_cast(SkBlendMode::kPlus), "xfermode_mismatch"); static_assert(13 == static_cast(SkBlendMode::kModulate), "xfermode_mismatch"); static_assert(14 == static_cast(SkBlendMode::kScreen), "xfermode_mismatch"); static_assert(15 == static_cast(SkBlendMode::kOverlay), "xfermode_mismatch"); static_assert(16 == static_cast(SkBlendMode::kDarken), "xfermode_mismatch"); static_assert(17 == static_cast(SkBlendMode::kLighten), "xfermode_mismatch"); static_assert(18 == static_cast(SkBlendMode::kColorDodge), "xfermode mismatch"); static_assert(19 == static_cast(SkBlendMode::kColorBurn), "xfermode mismatch"); static_assert(20 == static_cast(SkBlendMode::kHardLight), "xfermode mismatch"); static_assert(21 == static_cast(SkBlendMode::kSoftLight), "xfermode mismatch"); static_assert(22 == static_cast(SkBlendMode::kDifference), "xfermode mismatch"); static_assert(23 == static_cast(SkBlendMode::kExclusion), "xfermode mismatch"); static_assert(24 == static_cast(SkBlendMode::kMultiply), "xfermode mismatch"); static_assert(25 == static_cast(SkBlendMode::kHue), "xfermode mismatch"); static_assert(26 == static_cast(SkBlendMode::kSaturation), "xfermode mismatch"); static_assert(27 == static_cast(SkBlendMode::kColor), "xfermode mismatch"); static_assert(28 == static_cast(SkBlendMode::kLuminosity), "xfermode mismatch"); SkBlendMode mode = static_cast(xfermodeHandle); Paint* paint = reinterpret_cast(paintHandle); paint->setBlendMode(mode); } static jlong setPathEffect(CRITICAL_JNI_PARAMS_COMMA jlong objHandle, jlong effectHandle) { Paint* obj = reinterpret_cast(objHandle); SkPathEffect* effect = reinterpret_cast(effectHandle); obj->setPathEffect(sk_ref_sp(effect)); return reinterpret_cast(obj->getPathEffect()); } static jlong setMaskFilter(CRITICAL_JNI_PARAMS_COMMA jlong objHandle, jlong maskfilterHandle) { Paint* obj = reinterpret_cast(objHandle); SkMaskFilter* maskfilter = reinterpret_cast(maskfilterHandle); obj->setMaskFilter(sk_ref_sp(maskfilter)); return reinterpret_cast(obj->getMaskFilter()); } static void setTypeface(CRITICAL_JNI_PARAMS_COMMA jlong objHandle, jlong typefaceHandle) { Paint* paint = reinterpret_cast(objHandle); paint->setAndroidTypeface(reinterpret_cast(typefaceHandle)); } static jint getTextAlign(CRITICAL_JNI_PARAMS_COMMA jlong objHandle) { Paint* obj = reinterpret_cast(objHandle); return static_cast(obj->getTextAlign()); } static void setTextAlign(CRITICAL_JNI_PARAMS_COMMA jlong objHandle, jint alignHandle) { Paint* obj = reinterpret_cast(objHandle); Paint::Align align = static_cast(alignHandle); obj->setTextAlign(align); } static void setTextLocalesByMinikinLocaleListId(CRITICAL_JNI_PARAMS_COMMA jlong objHandle, jint minikinLocaleListId) { Paint* obj = reinterpret_cast(objHandle); obj->setMinikinLocaleListId(minikinLocaleListId); } // Note: Following three values must be equal to the ones in Java file: Paint.java. constexpr jint ELEGANT_TEXT_HEIGHT_UNSET = -1; constexpr jint ELEGANT_TEXT_HEIGHT_ENABLED = 0; constexpr jint ELEGANT_TEXT_HEIGHT_DISABLED = 1; static jint getElegantTextHeight(CRITICAL_JNI_PARAMS_COMMA jlong paintHandle) { Paint* obj = reinterpret_cast(paintHandle); const std::optional& familyVariant = obj->getFamilyVariant(); if (familyVariant.has_value()) { if (familyVariant.value() == minikin::FamilyVariant::ELEGANT) { return ELEGANT_TEXT_HEIGHT_ENABLED; } else { return ELEGANT_TEXT_HEIGHT_DISABLED; } } else { return ELEGANT_TEXT_HEIGHT_UNSET; } } static void setElegantTextHeight(CRITICAL_JNI_PARAMS_COMMA jlong paintHandle, jint value) { Paint* obj = reinterpret_cast(paintHandle); switch (value) { case ELEGANT_TEXT_HEIGHT_ENABLED: obj->setFamilyVariant(minikin::FamilyVariant::ELEGANT); return; case ELEGANT_TEXT_HEIGHT_DISABLED: obj->setFamilyVariant(minikin::FamilyVariant::DEFAULT); return; case ELEGANT_TEXT_HEIGHT_UNSET: default: obj->resetFamilyVariant(); return; } } static jfloat getTextSize(CRITICAL_JNI_PARAMS_COMMA jlong paintHandle) { return SkScalarToFloat(reinterpret_cast(paintHandle)->getSkFont().getSize()); } static void setTextSize(CRITICAL_JNI_PARAMS_COMMA jlong paintHandle, jfloat textSize) { if (textSize >= 0) { reinterpret_cast(paintHandle)->getSkFont().setSize(textSize); } } static jfloat getTextScaleX(CRITICAL_JNI_PARAMS_COMMA jlong paintHandle) { return SkScalarToFloat(reinterpret_cast(paintHandle)->getSkFont().getScaleX()); } static void setTextScaleX(CRITICAL_JNI_PARAMS_COMMA jlong paintHandle, jfloat scaleX) { reinterpret_cast(paintHandle)->getSkFont().setScaleX(scaleX); } static jfloat getTextSkewX(CRITICAL_JNI_PARAMS_COMMA jlong paintHandle) { return SkScalarToFloat(reinterpret_cast(paintHandle)->getSkFont().getSkewX()); } static void setTextSkewX(CRITICAL_JNI_PARAMS_COMMA jlong paintHandle, jfloat skewX) { reinterpret_cast(paintHandle)->getSkFont().setSkewX(skewX); } static jfloat getLetterSpacing(CRITICAL_JNI_PARAMS_COMMA jlong paintHandle) { Paint* paint = reinterpret_cast(paintHandle); return paint->getLetterSpacing(); } static void setLetterSpacing(CRITICAL_JNI_PARAMS_COMMA jlong paintHandle, jfloat letterSpacing) { Paint* paint = reinterpret_cast(paintHandle); paint->setLetterSpacing(letterSpacing); } static jfloat getWordSpacing(CRITICAL_JNI_PARAMS_COMMA jlong paintHandle) { Paint* paint = reinterpret_cast(paintHandle); return paint->getWordSpacing(); } static void setWordSpacing(CRITICAL_JNI_PARAMS_COMMA jlong paintHandle, jfloat wordSpacing) { Paint* paint = reinterpret_cast(paintHandle); paint->setWordSpacing(wordSpacing); } static jint getStartHyphenEdit(CRITICAL_JNI_PARAMS_COMMA jlong paintHandle, jint hyphen) { Paint* paint = reinterpret_cast(paintHandle); return static_cast(paint->getStartHyphenEdit()); } static jint getEndHyphenEdit(CRITICAL_JNI_PARAMS_COMMA jlong paintHandle, jint hyphen) { Paint* paint = reinterpret_cast(paintHandle); return static_cast(paint->getEndHyphenEdit()); } static void setStartHyphenEdit(CRITICAL_JNI_PARAMS_COMMA jlong paintHandle, jint hyphen) { Paint* paint = reinterpret_cast(paintHandle); paint->setStartHyphenEdit((uint32_t)hyphen); } static void setEndHyphenEdit(CRITICAL_JNI_PARAMS_COMMA jlong paintHandle, jint hyphen) { Paint* paint = reinterpret_cast(paintHandle); paint->setEndHyphenEdit((uint32_t)hyphen); } static jfloat ascent(CRITICAL_JNI_PARAMS_COMMA jlong paintHandle) { SkFontMetrics metrics; getMetricsInternal(paintHandle, &metrics, false /* useLocale */); return SkScalarToFloat(metrics.fAscent); } static jfloat descent(CRITICAL_JNI_PARAMS_COMMA jlong paintHandle) { SkFontMetrics metrics; getMetricsInternal(paintHandle, &metrics, false /* useLocale */); return SkScalarToFloat(metrics.fDescent); } static jfloat getUnderlinePosition(CRITICAL_JNI_PARAMS_COMMA jlong paintHandle) { SkFontMetrics metrics; getMetricsInternal(paintHandle, &metrics, false /* useLocale */); SkScalar position; if (metrics.hasUnderlinePosition(&position)) { return SkScalarToFloat(position); } else { const SkScalar textSize = reinterpret_cast(paintHandle)->getSkFont().getSize(); return SkScalarToFloat(Paint::kStdUnderline_Top * textSize); } } static jfloat getUnderlineThickness(CRITICAL_JNI_PARAMS_COMMA jlong paintHandle) { SkFontMetrics metrics; getMetricsInternal(paintHandle, &metrics, false /* useLocale */); SkScalar thickness; if (metrics.hasUnderlineThickness(&thickness)) { return SkScalarToFloat(thickness); } else { const SkScalar textSize = reinterpret_cast(paintHandle)->getSkFont().getSize(); return SkScalarToFloat(Paint::kStdUnderline_Thickness * textSize); } } static jfloat getStrikeThruPosition(CRITICAL_JNI_PARAMS_COMMA jlong paintHandle) { const SkScalar textSize = reinterpret_cast(paintHandle)->getSkFont().getSize(); return SkScalarToFloat(Paint::kStdStrikeThru_Top * textSize); } static jfloat getStrikeThruThickness(CRITICAL_JNI_PARAMS_COMMA jlong paintHandle) { const SkScalar textSize = reinterpret_cast(paintHandle)->getSkFont().getSize(); return SkScalarToFloat(Paint::kStdStrikeThru_Thickness * textSize); } static void setShadowLayer(CRITICAL_JNI_PARAMS_COMMA jlong paintHandle, jfloat radius, jfloat dx, jfloat dy, jlong colorSpaceHandle, jlong colorLong) { SkColor4f color = GraphicsJNI::convertColorLong(colorLong); sk_sp cs = GraphicsJNI::getNativeColorSpace(colorSpaceHandle); Paint* paint = reinterpret_cast(paintHandle); if (radius <= 0) { paint->setLooper(nullptr); } else { SkScalar sigma = android::uirenderer::Blur::convertRadiusToSigma(radius); paint->setLooper(BlurDrawLooper::Make(color, cs.get(), sigma, {dx, dy})); } } static jboolean hasShadowLayer(CRITICAL_JNI_PARAMS_COMMA jlong paintHandle) { Paint* paint = reinterpret_cast(paintHandle); return paint->getLooper() != nullptr; } static jboolean equalsForTextMeasurement(CRITICAL_JNI_PARAMS_COMMA jlong lPaint, jlong rPaint) { if (lPaint == rPaint) { return true; } Paint* leftPaint = reinterpret_cast(lPaint); Paint* rightPaint = reinterpret_cast(rPaint); const Typeface* leftTypeface = Typeface::resolveDefault(leftPaint->getAndroidTypeface()); const Typeface* rightTypeface = Typeface::resolveDefault(rightPaint->getAndroidTypeface()); minikin::MinikinPaint leftMinikinPaint = MinikinUtils::prepareMinikinPaint(leftPaint, leftTypeface); minikin::MinikinPaint rightMinikinPaint = MinikinUtils::prepareMinikinPaint(rightPaint, rightTypeface); return leftMinikinPaint == rightMinikinPaint; } }; // namespace PaintGlue static const JNINativeMethod methods[] = { {"nGetNativeFinalizer", "()J", (void*)PaintGlue::getNativeFinalizer}, {"nInit", "()J", (void*)PaintGlue::init}, {"nInitWithPaint", "(J)J", (void*)PaintGlue::initWithPaint}, {"nBreakText", "(J[CIIFI[F)I", (void*)PaintGlue::breakTextC}, {"nBreakText", "(JLjava/lang/String;ZFI[F)I", (void*)PaintGlue::breakTextS}, {"nGetTextAdvances", "(J[CIIIII[FI)F", (void*)PaintGlue::getTextAdvances___CIIIII_FI}, {"nGetTextAdvances", "(JLjava/lang/String;IIIII[FI)F", (void*)PaintGlue::getTextAdvances__StringIIIII_FI}, {"nGetTextRunCursor", "(J[CIIIII)I", (void*)PaintGlue::getTextRunCursor___C}, {"nGetTextRunCursor", "(JLjava/lang/String;IIIII)I", (void*)PaintGlue::getTextRunCursor__String}, {"nGetTextPath", "(JI[CIIFFJ)V", (void*)PaintGlue::getTextPath___C}, {"nGetTextPath", "(JILjava/lang/String;IIFFJ)V", (void*)PaintGlue::getTextPath__String}, {"nGetStringBounds", "(JLjava/lang/String;IIILandroid/graphics/Rect;)V", (void*)PaintGlue::getStringBounds}, {"nGetCharArrayBounds", "(J[CIIILandroid/graphics/Rect;)V", (void*)PaintGlue::getCharArrayBounds}, {"nHasGlyph", "(JILjava/lang/String;)Z", (void*)PaintGlue::hasGlyph}, {"nGetRunAdvance", "(J[CIIIIZI)F", (void*)PaintGlue::getRunAdvance___CIIIIZI_F}, {"nGetRunCharacterAdvance", "(J[CIIIIZI[FILandroid/graphics/RectF;Landroid/graphics/Paint$RunInfo;)F", (void*)PaintGlue::getRunCharacterAdvance___CIIIIZI_FI_F}, {"nGetOffsetForAdvance", "(J[CIIIIZF)I", (void*)PaintGlue::getOffsetForAdvance___CIIIIZF_I}, {"nGetFontMetricsIntForText", "(J[CIIIIZLandroid/graphics/Paint$FontMetricsInt;)V", (void*)PaintGlue::getFontMetricsIntForText___C}, {"nGetFontMetricsIntForText", "(JLjava/lang/String;IIIIZLandroid/graphics/Paint$FontMetricsInt;)V", (void*)PaintGlue::getFontMetricsIntForText___String}, // --------------- @FastNative ---------------------- {"nSetTextLocales", "(JLjava/lang/String;)I", (void*)PaintGlue::setTextLocales}, {"nSetFontFeatureSettings", "(JLjava/lang/String;)V", (void*)PaintGlue::setFontFeatureSettings}, {"nGetFontMetrics", "(JLandroid/graphics/Paint$FontMetrics;Z)F", (void*)PaintGlue::getFontMetrics}, {"nGetFontMetricsInt", "(JLandroid/graphics/Paint$FontMetricsInt;Z)I", (void*)PaintGlue::getFontMetricsInt}, // --------------- @CriticalNative ------------------ {"nReset", "(J)V", (void*)PaintGlue::reset}, {"nSet", "(JJ)V", (void*)PaintGlue::assign}, {"nGetFlags", "(J)I", (void*)PaintGlue::getFlags}, {"nSetFlags", "(JI)V", (void*)PaintGlue::setFlags}, {"nGetHinting", "(J)I", (void*)PaintGlue::getHinting}, {"nSetHinting", "(JI)V", (void*)PaintGlue::setHinting}, {"nSetAntiAlias", "(JZ)V", (void*)PaintGlue::setAntiAlias}, {"nSetSubpixelText", "(JZ)V", (void*)PaintGlue::setSubpixelText}, {"nSetLinearText", "(JZ)V", (void*)PaintGlue::setLinearText}, {"nSetUnderlineText", "(JZ)V", (void*)PaintGlue::setUnderlineText}, {"nSetStrikeThruText", "(JZ)V", (void*)PaintGlue::setStrikeThruText}, {"nSetFakeBoldText", "(JZ)V", (void*)PaintGlue::setFakeBoldText}, {"nSetFilterBitmap", "(JZ)V", (void*)PaintGlue::setFilterBitmap}, {"nSetDither", "(JZ)V", (void*)PaintGlue::setDither}, {"nGetStyle", "(J)I", (void*)PaintGlue::getStyle}, {"nSetStyle", "(JI)V", (void*)PaintGlue::setStyle}, {"nSetColor", "(JI)V", (void*)PaintGlue::setColor}, {"nSetColor", "(JJJ)V", (void*)PaintGlue::setColorLong}, {"nSetAlpha", "(JI)V", (void*)PaintGlue::setAlpha}, {"nGetStrokeWidth", "(J)F", (void*)PaintGlue::getStrokeWidth}, {"nSetStrokeWidth", "(JF)V", (void*)PaintGlue::setStrokeWidth}, {"nGetStrokeMiter", "(J)F", (void*)PaintGlue::getStrokeMiter}, {"nSetStrokeMiter", "(JF)V", (void*)PaintGlue::setStrokeMiter}, {"nGetStrokeCap", "(J)I", (void*)PaintGlue::getStrokeCap}, {"nSetStrokeCap", "(JI)V", (void*)PaintGlue::setStrokeCap}, {"nGetStrokeJoin", "(J)I", (void*)PaintGlue::getStrokeJoin}, {"nSetStrokeJoin", "(JI)V", (void*)PaintGlue::setStrokeJoin}, {"nGetFillPath", "(JJJ)Z", (void*)PaintGlue::getFillPath}, {"nSetShader", "(JJ)J", (void*)PaintGlue::setShader}, {"nSetColorFilter", "(JJ)J", (void*)PaintGlue::setColorFilter}, {"nSetXfermode", "(JI)V", (void*)PaintGlue::setXfermode}, {"nSetPathEffect", "(JJ)J", (void*)PaintGlue::setPathEffect}, {"nSetMaskFilter", "(JJ)J", (void*)PaintGlue::setMaskFilter}, {"nSetTypeface", "(JJ)V", (void*)PaintGlue::setTypeface}, {"nGetTextAlign", "(J)I", (void*)PaintGlue::getTextAlign}, {"nSetTextAlign", "(JI)V", (void*)PaintGlue::setTextAlign}, {"nSetTextLocalesByMinikinLocaleListId", "(JI)V", (void*)PaintGlue::setTextLocalesByMinikinLocaleListId}, {"nGetElegantTextHeight", "(J)I", (void*)PaintGlue::getElegantTextHeight}, {"nSetElegantTextHeight", "(JI)V", (void*)PaintGlue::setElegantTextHeight}, {"nGetTextSize", "(J)F", (void*)PaintGlue::getTextSize}, {"nSetTextSize", "(JF)V", (void*)PaintGlue::setTextSize}, {"nGetTextScaleX", "(J)F", (void*)PaintGlue::getTextScaleX}, {"nSetTextScaleX", "(JF)V", (void*)PaintGlue::setTextScaleX}, {"nGetTextSkewX", "(J)F", (void*)PaintGlue::getTextSkewX}, {"nSetTextSkewX", "(JF)V", (void*)PaintGlue::setTextSkewX}, {"nGetLetterSpacing", "(J)F", (void*)PaintGlue::getLetterSpacing}, {"nSetLetterSpacing", "(JF)V", (void*)PaintGlue::setLetterSpacing}, {"nGetWordSpacing", "(J)F", (void*)PaintGlue::getWordSpacing}, {"nSetWordSpacing", "(JF)V", (void*)PaintGlue::setWordSpacing}, {"nGetStartHyphenEdit", "(J)I", (void*)PaintGlue::getStartHyphenEdit}, {"nGetEndHyphenEdit", "(J)I", (void*)PaintGlue::getEndHyphenEdit}, {"nSetStartHyphenEdit", "(JI)V", (void*)PaintGlue::setStartHyphenEdit}, {"nSetEndHyphenEdit", "(JI)V", (void*)PaintGlue::setEndHyphenEdit}, {"nAscent", "(J)F", (void*)PaintGlue::ascent}, {"nDescent", "(J)F", (void*)PaintGlue::descent}, {"nGetUnderlinePosition", "(J)F", (void*)PaintGlue::getUnderlinePosition}, {"nGetUnderlineThickness", "(J)F", (void*)PaintGlue::getUnderlineThickness}, {"nGetStrikeThruPosition", "(J)F", (void*)PaintGlue::getStrikeThruPosition}, {"nGetStrikeThruThickness", "(J)F", (void*)PaintGlue::getStrikeThruThickness}, {"nSetShadowLayer", "(JFFFJJ)V", (void*)PaintGlue::setShadowLayer}, {"nHasShadowLayer", "(J)Z", (void*)PaintGlue::hasShadowLayer}, {"nEqualsForTextMeasurement", "(JJ)Z", (void*)PaintGlue::equalsForTextMeasurement}, }; int register_android_graphics_Paint(JNIEnv* env) { return RegisterMethodsOrDie(env, "android/graphics/Paint", methods, NELEM(methods)); } }