blob: 286f06a6bad8f369957e6ef521c24f5b0ce6bbbb [file] [log] [blame]
The Android Open Source Project9066cfe2009-03-03 19:31:44 -08001/* libs/android_runtime/android/graphics/Paint.cpp
2**
3** Copyright 2006, The Android Open Source Project
4**
Elliott Hughes8451b252011-04-07 19:17:57 -07005** 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
The Android Open Source Project9066cfe2009-03-03 19:31:44 -08008**
Elliott Hughes8451b252011-04-07 19:17:57 -07009** http://www.apache.org/licenses/LICENSE-2.0
The Android Open Source Project9066cfe2009-03-03 19:31:44 -080010**
Elliott Hughes8451b252011-04-07 19:17:57 -070011** 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
The Android Open Source Project9066cfe2009-03-03 19:31:44 -080015** limitations under the License.
16*/
17
Nader Jawadf0ea9e12023-05-02 15:18:00 -070018#include <hwui/BlurDrawLooper.h>
19#include <hwui/MinikinSkia.h>
20#include <hwui/MinikinUtils.h>
21#include <hwui/Paint.h>
22#include <hwui/Typeface.h>
23#include <minikin/GraphemeBreak.h>
24#include <minikin/LocaleList.h>
25#include <minikin/Measurement.h>
26#include <minikin/MinikinPaint.h>
27#include <nativehelper/ScopedPrimitiveArray.h>
Steven Moreland2279b252017-07-19 09:50:45 -070028#include <nativehelper/ScopedStringChars.h>
29#include <nativehelper/ScopedUtfChars.h>
Nader Jawadf0ea9e12023-05-02 15:18:00 -070030#include <unicode/utf16.h>
31#include <utils/Log.h>
The Android Open Source Project9066cfe2009-03-03 19:31:44 -080032
Nader Jawadf0ea9e12023-05-02 15:18:00 -070033#include <cassert>
34#include <cstring>
35#include <memory>
Seigo Nonaka9bda91a2023-10-28 19:11:22 +090036#include <string_view>
Nader Jawadf0ea9e12023-05-02 15:18:00 -070037#include <vector>
38
39#include "ColorFilter.h"
40#include "GraphicsJNI.h"
41#include "SkBlendMode.h"
The Android Open Source Project9066cfe2009-03-03 19:31:44 -080042#include "SkColorFilter.h"
Kevin Lubick07d6aae2022-04-01 14:03:11 -040043#include "SkColorSpace.h"
Mike Reedf6d86ac2019-01-18 14:13:23 -050044#include "SkFont.h"
Mike Reed0ea09a42019-01-25 13:04:14 -050045#include "SkFontMetrics.h"
Mike Reeddad2f892018-11-05 16:13:54 -050046#include "SkFontTypes.h"
The Android Open Source Project9066cfe2009-03-03 19:31:44 -080047#include "SkMaskFilter.h"
Derek Sollenbergereba81d02015-10-26 10:22:37 -040048#include "SkPath.h"
Mike Reed260ab722016-10-07 15:59:20 -040049#include "SkPathEffect.h"
Kevin Lubick8df9a682022-12-14 18:52:56 +000050#include "SkPathUtils.h"
The Android Open Source Project9066cfe2009-03-03 19:31:44 -080051#include "SkShader.h"
Billy Hewlettac1cbaf2012-07-18 09:51:45 -070052#include "unicode/uloc.h"
Derek Sollenbergerc29a0a42014-03-31 13:52:39 -040053#include "utils/Blur.h"
Doug Felt0c702b82010-05-14 10:55:42 -070054
The Android Open Source Project9066cfe2009-03-03 19:31:44 -080055namespace android {
56
Seigo Nonaka6e39daf2023-08-19 11:36:26 +090057namespace {
58
59void copyMinikinRectToSkRect(const minikin::MinikinRect& minikinRect, SkRect* skRect) {
60 skRect->fLeft = minikinRect.mLeft;
61 skRect->fTop = minikinRect.mTop;
62 skRect->fRight = minikinRect.mRight;
63 skRect->fBottom = minikinRect.mBottom;
64}
65
66} // namespace
67
Mike Reedf6d86ac2019-01-18 14:13:23 -050068static void getPosTextPath(const SkFont& font, const uint16_t glyphs[], int count,
69 const SkPoint pos[], SkPath* dst) {
Mike Reedbacaa1d2019-01-29 08:07:50 -050070 dst->reset();
Mike Reedf6d86ac2019-01-18 14:13:23 -050071 struct Rec {
72 SkPath* fDst;
73 const SkPoint* fPos;
74 } rec = { dst, pos };
75 font.getPaths(glyphs, count, [](const SkPath* src, const SkMatrix& mx, void* ctx) {
76 Rec* rec = (Rec*)ctx;
77 if (src) {
78 SkMatrix tmp(mx);
79 tmp.postTranslate(rec->fPos->fX, rec->fPos->fY);
80 rec->fDst->addPath(*src, tmp);
81 }
82 rec->fPos += 1;
83 }, &rec);
Mike Reed3d63e012009-07-27 09:50:31 -040084}
85
John Reckdbffd252015-10-01 14:46:12 -070086namespace PaintGlue {
Doug Felt0c702b82010-05-14 10:55:42 -070087 enum MoveOpt {
88 AFTER, AT_OR_AFTER, BEFORE, AT_OR_BEFORE, AT
89 };
The Android Open Source Project9066cfe2009-03-03 19:31:44 -080090
Richard Uhler775873a2015-12-29 12:37:39 -080091 static void deletePaint(Paint* paint) {
92 delete paint;
93 }
94
95 static jlong getNativeFinalizer(JNIEnv*, jobject) {
96 return static_cast<jlong>(reinterpret_cast<uintptr_t>(&deletePaint));
The Android Open Source Project9066cfe2009-03-03 19:31:44 -080097 }
98
John Reckdbffd252015-10-01 14:46:12 -070099 static jlong init(JNIEnv* env, jobject) {
Mike Reedf6d86ac2019-01-18 14:13:23 -0500100 return reinterpret_cast<jlong>(new Paint);
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800101 }
102
Ashok Bhat36bef0b2014-01-20 20:08:01 +0000103 static jlong initWithPaint(JNIEnv* env, jobject clazz, jlong paintHandle) {
Behdad Esfahbod6ba30b82014-07-15 16:22:32 -0400104 Paint* paint = reinterpret_cast<Paint*>(paintHandle);
105 Paint* obj = new Paint(*paint);
Ashok Bhat36bef0b2014-01-20 20:08:01 +0000106 return reinterpret_cast<jlong>(obj);
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800107 }
Elliott Hughes8451b252011-04-07 19:17:57 -0700108
Seigo Nonaka318ca042017-08-01 16:36:18 -0700109 static int breakText(JNIEnv* env, const Paint& paint, const Typeface* typeface,
110 const jchar text[], int count, float maxWidth, jint bidiFlags, jfloatArray jmeasured,
John Reckf2285972016-09-30 14:10:05 -0700111 const bool forwardScan) {
112 size_t measuredCount = 0;
113 float measured = 0;
Elliott Hughes8451b252011-04-07 19:17:57 -0700114
John Reckf2285972016-09-30 14:10:05 -0700115 std::unique_ptr<float[]> advancesArray(new float[count]);
Seigo Nonaka6e39daf2023-08-19 11:36:26 +0900116 MinikinUtils::measureText(&paint, static_cast<minikin::Bidi>(bidiFlags), typeface, text, 0,
Seigo Nonakadd617182023-12-07 08:56:31 +0900117 count, count, advancesArray.get(), nullptr, nullptr);
Elliott Hughes8451b252011-04-07 19:17:57 -0700118
John Reckf2285972016-09-30 14:10:05 -0700119 for (int i = 0; i < count; i++) {
120 // traverse in the given direction
121 int index = forwardScan ? i : (count - i - 1);
122 float width = advancesArray[index];
123 if (measured + width > maxWidth) {
124 break;
125 }
126 // properly handle clusters when scanning backwards
127 if (forwardScan || width != 0.0f) {
128 measuredCount = i + 1;
129 }
130 measured += width;
Mike Reed4c9355c2014-05-07 11:48:37 -0400131 }
Elliott Hughes8451b252011-04-07 19:17:57 -0700132
John Reckf2285972016-09-30 14:10:05 -0700133 if (jmeasured && env->GetArrayLength(jmeasured) > 0) {
134 AutoJavaFloatArray autoMeasured(env, jmeasured, 1);
135 jfloat* array = autoMeasured.ptr();
136 array[0] = measured;
Behdad Esfahbod805f6ebf2014-07-29 18:43:03 -0400137 }
John Reckf2285972016-09-30 14:10:05 -0700138 return measuredCount;
Behdad Esfahbod805f6ebf2014-07-29 18:43:03 -0400139 }
140
Seigo Nonaka318ca042017-08-01 16:36:18 -0700141 static jint breakTextC(JNIEnv* env, jobject clazz, jlong paintHandle, jcharArray jtext,
142 jint index, jint count, jfloat maxWidth, jint bidiFlags, jfloatArray jmeasuredWidth) {
John Reckf2285972016-09-30 14:10:05 -0700143 NPE_CHECK_RETURN_ZERO(env, jtext);
Raph Levien210a1892015-03-09 14:42:14 -0700144
John Reckdbffd252015-10-01 14:46:12 -0700145 Paint* paint = reinterpret_cast<Paint*>(paintHandle);
Seigo Nonaka318ca042017-08-01 16:36:18 -0700146 const Typeface* typeface = paint->getAndroidTypeface();
John Reckf2285972016-09-30 14:10:05 -0700147
148 bool forwardTextDirection;
149 if (count < 0) {
150 forwardTextDirection = false;
151 count = -count;
Raph Levien53c00772014-04-14 14:11:02 -0700152 }
John Reckf2285972016-09-30 14:10:05 -0700153 else {
154 forwardTextDirection = true;
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800155 }
John Reckf2285972016-09-30 14:10:05 -0700156
157 if ((index < 0) || (index + count > env->GetArrayLength(jtext))) {
158 doThrowAIOOBE(env);
159 return 0;
160 }
161
162 const jchar* text = env->GetCharArrayElements(jtext, nullptr);
163 count = breakText(env, *paint, typeface, text + index, count, maxWidth,
164 bidiFlags, jmeasuredWidth, forwardTextDirection);
165 env->ReleaseCharArrayElements(jtext, const_cast<jchar*>(text),
166 JNI_ABORT);
167 return count;
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800168 }
Elliott Hughes8451b252011-04-07 19:17:57 -0700169
Seigo Nonaka318ca042017-08-01 16:36:18 -0700170 static jint breakTextS(JNIEnv* env, jobject clazz, jlong paintHandle, jstring jtext,
171 jboolean forwards, jfloat maxWidth, jint bidiFlags, jfloatArray jmeasuredWidth) {
John Reckf2285972016-09-30 14:10:05 -0700172 NPE_CHECK_RETURN_ZERO(env, jtext);
Elliott Hughes8451b252011-04-07 19:17:57 -0700173
John Reckf2285972016-09-30 14:10:05 -0700174 Paint* paint = reinterpret_cast<Paint*>(paintHandle);
Seigo Nonaka318ca042017-08-01 16:36:18 -0700175 const Typeface* typeface = paint->getAndroidTypeface();
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800176
John Reckf2285972016-09-30 14:10:05 -0700177 int count = env->GetStringLength(jtext);
178 const jchar* text = env->GetStringChars(jtext, nullptr);
179 count = breakText(env, *paint, typeface, text, count, maxWidth, bidiFlags, jmeasuredWidth, forwards);
180 env->ReleaseStringChars(jtext, text);
181 return count;
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800182 }
183
Seigo Nonaka318ca042017-08-01 16:36:18 -0700184 static jfloat doTextAdvances(JNIEnv *env, Paint *paint, const Typeface* typeface,
Keisuke Kuroyanagi536afe62015-09-29 13:52:45 -0700185 const jchar *text, jint start, jint count, jint contextCount, jint bidiFlags,
186 jfloatArray advances, jint advancesIndex) {
Fabrice Di Meglio6ab90ed2011-08-08 16:19:38 -0700187 NPE_CHECK_RETURN_ZERO(env, text);
188
189 if ((start | count | contextCount | advancesIndex) < 0 || contextCount < count) {
190 doThrowAIOOBE(env);
191 return 0;
192 }
193 if (count == 0) {
194 return 0;
195 }
196 if (advances) {
197 size_t advancesLength = env->GetArrayLength(advances);
Keisuke Kuroyanagi536afe62015-09-29 13:52:45 -0700198 if ((size_t)(count + advancesIndex) > advancesLength) {
Fabrice Di Meglio6ab90ed2011-08-08 16:19:38 -0700199 doThrowAIOOBE(env);
200 return 0;
201 }
202 }
Keisuke Kuroyanagia3024bd2015-09-16 20:02:15 -0700203 std::unique_ptr<jfloat[]> advancesArray;
204 if (advances) {
205 advancesArray.reset(new jfloat[count]);
206 }
Seigo Nonaka6e39daf2023-08-19 11:36:26 +0900207 const float advance = MinikinUtils::measureText(
208 paint, static_cast<minikin::Bidi>(bidiFlags), typeface, text, start, count,
Seigo Nonakadd617182023-12-07 08:56:31 +0900209 contextCount, advancesArray.get(), nullptr, nullptr);
Keisuke Kuroyanagia3024bd2015-09-16 20:02:15 -0700210 if (advances) {
Keisuke Kuroyanagi536afe62015-09-29 13:52:45 -0700211 env->SetFloatArrayRegion(advances, advancesIndex, count, advancesArray.get());
Doug Felt0c702b82010-05-14 10:55:42 -0700212 }
Keisuke Kuroyanagia3024bd2015-09-16 20:02:15 -0700213 return advance;
Doug Felt0c702b82010-05-14 10:55:42 -0700214 }
215
Keisuke Kuroyanagi536afe62015-09-29 13:52:45 -0700216 static jfloat getTextAdvances___CIIIII_FI(JNIEnv* env, jobject clazz, jlong paintHandle,
Doug Felt0c702b82010-05-14 10:55:42 -0700217 jcharArray text, jint index, jint count, jint contextIndex, jint contextCount,
Keisuke Kuroyanagi536afe62015-09-29 13:52:45 -0700218 jint bidiFlags, jfloatArray advances, jint advancesIndex) {
Behdad Esfahbod6ba30b82014-07-15 16:22:32 -0400219 Paint* paint = reinterpret_cast<Paint*>(paintHandle);
Seigo Nonaka318ca042017-08-01 16:36:18 -0700220 const Typeface* typeface = paint->getAndroidTypeface();
John Reckf2285972016-09-30 14:10:05 -0700221 jchar* textArray = env->GetCharArrayElements(text, nullptr);
Keisuke Kuroyanagi536afe62015-09-29 13:52:45 -0700222 jfloat result = doTextAdvances(env, paint, typeface, textArray + contextIndex,
223 index - contextIndex, count, contextCount, bidiFlags, advances, advancesIndex);
Doug Felt0c702b82010-05-14 10:55:42 -0700224 env->ReleaseCharArrayElements(text, textArray, JNI_ABORT);
225 return result;
226 }
227
Keisuke Kuroyanagi536afe62015-09-29 13:52:45 -0700228 static jfloat getTextAdvances__StringIIIII_FI(JNIEnv* env, jobject clazz, jlong paintHandle,
Keisuke Kuroyanagi536afe62015-09-29 13:52:45 -0700229 jstring text, jint start, jint end, jint contextStart, jint contextEnd, jint bidiFlags,
Fabrice Di Meglio665f02c2013-03-20 14:56:05 -0700230 jfloatArray advances, jint advancesIndex) {
Behdad Esfahbod6ba30b82014-07-15 16:22:32 -0400231 Paint* paint = reinterpret_cast<Paint*>(paintHandle);
Seigo Nonaka318ca042017-08-01 16:36:18 -0700232 const Typeface* typeface = paint->getAndroidTypeface();
John Reckf2285972016-09-30 14:10:05 -0700233 const jchar* textArray = env->GetStringChars(text, nullptr);
Keisuke Kuroyanagi536afe62015-09-29 13:52:45 -0700234 jfloat result = doTextAdvances(env, paint, typeface, textArray + contextStart,
235 start - contextStart, end - start, contextEnd - contextStart, bidiFlags,
Fabrice Di Meglio665f02c2013-03-20 14:56:05 -0700236 advances, advancesIndex);
Fabrice Di Meglioeee49c62011-03-24 17:21:23 -0700237 env->ReleaseStringChars(text, textArray);
238 return result;
239 }
240
Seigo Nonaka318ca042017-08-01 16:36:18 -0700241 static jint doTextRunCursor(JNIEnv *env, Paint* paint, const Typeface* typeface,
242 const jchar *text, jint start, jint count, jint dir, jint offset, jint opt) {
Seigo Nonakaae1aa852016-06-09 19:42:51 +0900243 minikin::GraphemeBreak::MoveOpt moveOpt = minikin::GraphemeBreak::MoveOpt(opt);
Seigo Nonaka7c93e862017-10-25 16:34:48 -0700244 minikin::Bidi bidiFlags = dir == 1 ? minikin::Bidi::FORCE_RTL : minikin::Bidi::FORCE_LTR;
Roozbeh Pournader5d74b1c2017-03-13 21:41:15 -0700245 std::unique_ptr<float[]> advancesArray(new float[count]);
246 MinikinUtils::measureText(paint, bidiFlags, typeface, text, start, count, start + count,
Seigo Nonakadd617182023-12-07 08:56:31 +0900247 advancesArray.get(), nullptr, nullptr);
Roozbeh Pournader5d74b1c2017-03-13 21:41:15 -0700248 size_t result = minikin::GraphemeBreak::getTextRunCursor(advancesArray.get(), text,
249 start, count, offset, moveOpt);
Raph Leviene368b6b2014-06-15 17:37:57 -0700250 return static_cast<jint>(result);
Doug Felt0c702b82010-05-14 10:55:42 -0700251 }
252
Seigo Nonaka318ca042017-08-01 16:36:18 -0700253 static jint getTextRunCursor___C(JNIEnv* env, jobject clazz, jlong paintHandle, jcharArray text,
254 jint contextStart, jint contextCount, jint dir, jint offset, jint cursorOpt) {
Behdad Esfahbod6ba30b82014-07-15 16:22:32 -0400255 Paint* paint = reinterpret_cast<Paint*>(paintHandle);
Seigo Nonaka318ca042017-08-01 16:36:18 -0700256 const Typeface* typeface = paint->getAndroidTypeface();
John Reckf2285972016-09-30 14:10:05 -0700257 jchar* textArray = env->GetCharArrayElements(text, nullptr);
Roozbeh Pournader5d74b1c2017-03-13 21:41:15 -0700258 jint result = doTextRunCursor(env, paint, typeface, textArray,
259 contextStart, contextCount, dir, offset, cursorOpt);
Doug Felt0c702b82010-05-14 10:55:42 -0700260 env->ReleaseCharArrayElements(text, textArray, JNI_ABORT);
261 return result;
262 }
263
Roozbeh Pournader5d74b1c2017-03-13 21:41:15 -0700264 static jint getTextRunCursor__String(JNIEnv* env, jobject clazz, jlong paintHandle,
Seigo Nonaka318ca042017-08-01 16:36:18 -0700265 jstring text, jint contextStart, jint contextEnd, jint dir, jint offset,
266 jint cursorOpt) {
Behdad Esfahbod6ba30b82014-07-15 16:22:32 -0400267 Paint* paint = reinterpret_cast<Paint*>(paintHandle);
Seigo Nonaka318ca042017-08-01 16:36:18 -0700268 const Typeface* typeface = paint->getAndroidTypeface();
John Reckf2285972016-09-30 14:10:05 -0700269 const jchar* textArray = env->GetStringChars(text, nullptr);
Roozbeh Pournader5d74b1c2017-03-13 21:41:15 -0700270 jint result = doTextRunCursor(env, paint, typeface, textArray,
271 contextStart, contextEnd - contextStart, dir, offset, cursorOpt);
Doug Felt0c702b82010-05-14 10:55:42 -0700272 env->ReleaseStringChars(text, textArray);
273 return result;
274 }
275
Raph Levienf2114d52014-06-01 15:54:47 -0700276 class GetTextFunctor {
277 public:
Seigo Nonakaae1aa852016-06-09 19:42:51 +0900278 GetTextFunctor(const minikin::Layout& layout, SkPath* path, jfloat x, jfloat y,
279 Paint* paint, uint16_t* glyphs, SkPoint* pos)
Raph Levienf2114d52014-06-01 15:54:47 -0700280 : layout(layout), path(path), x(x), y(y), paint(paint), glyphs(glyphs), pos(pos) {
281 }
282
Raph Levien1fc0fa82014-06-06 18:05:22 -0700283 void operator()(size_t start, size_t end) {
Raph Levienf2114d52014-06-01 15:54:47 -0700284 for (size_t i = start; i < end; i++) {
285 glyphs[i] = layout.getGlyphId(i);
286 pos[i].fX = x + layout.getX(i);
287 pos[i].fY = y + layout.getY(i);
288 }
Mike Reedf6d86ac2019-01-18 14:13:23 -0500289 const SkFont& font = paint->getSkFont();
Raph Levienf2114d52014-06-01 15:54:47 -0700290 if (start == 0) {
Mike Reedf6d86ac2019-01-18 14:13:23 -0500291 getPosTextPath(font, glyphs, end, pos, path);
Raph Levienf2114d52014-06-01 15:54:47 -0700292 } else {
Mike Reedf6d86ac2019-01-18 14:13:23 -0500293 getPosTextPath(font, glyphs + start, end - start, pos + start, &tmpPath);
Raph Levienf2114d52014-06-01 15:54:47 -0700294 path->addPath(tmpPath);
295 }
296 }
297 private:
Seigo Nonakaae1aa852016-06-09 19:42:51 +0900298 const minikin::Layout& layout;
Raph Levienf2114d52014-06-01 15:54:47 -0700299 SkPath* path;
300 jfloat x;
301 jfloat y;
Behdad Esfahbod6ba30b82014-07-15 16:22:32 -0400302 Paint* paint;
Raph Levienf2114d52014-06-01 15:54:47 -0700303 uint16_t* glyphs;
304 SkPoint* pos;
305 SkPath tmpPath;
306 };
Raph Levienf2114d52014-06-01 15:54:47 -0700307
Seigo Nonaka318ca042017-08-01 16:36:18 -0700308 static void getTextPath(JNIEnv* env, Paint* paint, const Typeface* typeface, const jchar* text,
Raph Levienf2114d52014-06-01 15:54:47 -0700309 jint count, jint bidiFlags, jfloat x, jfloat y, SkPath* path) {
Seigo Nonakac7064142017-02-10 16:53:31 +0900310 minikin::Layout layout = MinikinUtils::doLayout(
Seigo Nonaka3a4217f2018-05-02 12:56:16 -0700311 paint, static_cast<minikin::Bidi>(bidiFlags), typeface,
312 text, count, // text buffer
313 0, count, // draw range
314 0, count, // context range
Seigo Nonaka83143d02018-03-14 17:08:28 -0700315 nullptr);
Raph Levienf2114d52014-06-01 15:54:47 -0700316 size_t nGlyphs = layout.nGlyphs();
317 uint16_t* glyphs = new uint16_t[nGlyphs];
318 SkPoint* pos = new SkPoint[nGlyphs];
319
320 x += MinikinUtils::xOffsetForTextAlign(paint, layout);
Behdad Esfahbod6ba30b82014-07-15 16:22:32 -0400321 Paint::Align align = paint->getTextAlign();
322 paint->setTextAlign(Paint::kLeft_Align);
Raph Levienf2114d52014-06-01 15:54:47 -0700323 GetTextFunctor f(layout, path, x, y, paint, glyphs, pos);
Raph Levien1fc0fa82014-06-06 18:05:22 -0700324 MinikinUtils::forFontRun(layout, paint, f);
Raph Levienf2114d52014-06-01 15:54:47 -0700325 paint->setTextAlign(align);
326 delete[] glyphs;
327 delete[] pos;
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800328 }
Doug Feltf7cb1f72010-07-01 16:20:43 -0700329
Seigo Nonaka318ca042017-08-01 16:36:18 -0700330 static void getTextPath___C(JNIEnv* env, jobject clazz, jlong paintHandle, jint bidiFlags,
Ashok Bhat36bef0b2014-01-20 20:08:01 +0000331 jcharArray text, jint index, jint count, jfloat x, jfloat y, jlong pathHandle) {
Behdad Esfahbod6ba30b82014-07-15 16:22:32 -0400332 Paint* paint = reinterpret_cast<Paint*>(paintHandle);
Seigo Nonaka318ca042017-08-01 16:36:18 -0700333 const Typeface* typeface = paint->getAndroidTypeface();
Ashok Bhat36bef0b2014-01-20 20:08:01 +0000334 SkPath* path = reinterpret_cast<SkPath*>(pathHandle);
John Reckf2285972016-09-30 14:10:05 -0700335 const jchar* textArray = env->GetCharArrayElements(text, nullptr);
Raph Levienf2114d52014-06-01 15:54:47 -0700336 getTextPath(env, paint, typeface, textArray + index, count, bidiFlags, x, y, path);
Doug Feltf7cb1f72010-07-01 16:20:43 -0700337 env->ReleaseCharArrayElements(text, const_cast<jchar*>(textArray), JNI_ABORT);
338 }
339
Seigo Nonaka318ca042017-08-01 16:36:18 -0700340 static void getTextPath__String(JNIEnv* env, jobject clazz, jlong paintHandle, jint bidiFlags,
Ashok Bhat36bef0b2014-01-20 20:08:01 +0000341 jstring text, jint start, jint end, jfloat x, jfloat y, jlong pathHandle) {
Behdad Esfahbod6ba30b82014-07-15 16:22:32 -0400342 Paint* paint = reinterpret_cast<Paint*>(paintHandle);
Seigo Nonaka318ca042017-08-01 16:36:18 -0700343 const Typeface* typeface = paint->getAndroidTypeface();
Ashok Bhat36bef0b2014-01-20 20:08:01 +0000344 SkPath* path = reinterpret_cast<SkPath*>(pathHandle);
John Reckf2285972016-09-30 14:10:05 -0700345 const jchar* textArray = env->GetStringChars(text, nullptr);
Raph Levienf2114d52014-06-01 15:54:47 -0700346 getTextPath(env, paint, typeface, textArray + start, end - start, bidiFlags, x, y, path);
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800347 env->ReleaseStringChars(text, textArray);
348 }
Doug Feltf7cb1f72010-07-01 16:20:43 -0700349
Raph Levien854363e2014-06-03 19:56:05 -0700350 static void doTextBounds(JNIEnv* env, const jchar* text, int count, jobject bounds,
Seigo Nonaka96860de2020-09-22 23:40:18 -0700351 const Paint& paint, const Typeface* typeface, jint bidiFlagsInt) {
Romain Guy059e12c2012-11-28 17:35:51 -0800352 SkRect r;
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800353 SkIRect ir;
Elliott Hughes8451b252011-04-07 19:17:57 -0700354
Seigo Nonakaae1aa852016-06-09 19:42:51 +0900355 minikin::MinikinRect rect;
Seigo Nonaka96860de2020-09-22 23:40:18 -0700356 minikin::Bidi bidiFlags = static_cast<minikin::Bidi>(bidiFlagsInt);
357 MinikinUtils::getBounds(&paint, bidiFlags, typeface, text, count, &rect);
Raph Levien854363e2014-06-03 19:56:05 -0700358 r.fLeft = rect.mLeft;
359 r.fTop = rect.mTop;
360 r.fRight = rect.mRight;
361 r.fBottom = rect.mBottom;
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800362 r.roundOut(&ir);
363 GraphicsJNI::irect_to_jrect(ir, env, bounds);
364 }
365
Seigo Nonaka318ca042017-08-01 16:36:18 -0700366 static void getStringBounds(JNIEnv* env, jobject, jlong paintHandle, jstring text, jint start,
367 jint end, jint bidiFlags, jobject bounds) {
John Reckdbffd252015-10-01 14:46:12 -0700368 const Paint* paint = reinterpret_cast<Paint*>(paintHandle);
Seigo Nonaka318ca042017-08-01 16:36:18 -0700369 const Typeface* typeface = paint->getAndroidTypeface();
John Reckf2285972016-09-30 14:10:05 -0700370 const jchar* textArray = env->GetStringChars(text, nullptr);
Raph Levien854363e2014-06-03 19:56:05 -0700371 doTextBounds(env, textArray + start, end - start, bounds, *paint, typeface, bidiFlags);
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800372 env->ReleaseStringChars(text, textArray);
373 }
Elliott Hughes8451b252011-04-07 19:17:57 -0700374
Seigo Nonaka318ca042017-08-01 16:36:18 -0700375 static void getCharArrayBounds(JNIEnv* env, jobject, jlong paintHandle, jcharArray text,
376 jint index, jint count, jint bidiFlags, jobject bounds) {
Behdad Esfahbod6ba30b82014-07-15 16:22:32 -0400377 const Paint* paint = reinterpret_cast<Paint*>(paintHandle);
Seigo Nonaka318ca042017-08-01 16:36:18 -0700378 const Typeface* typeface = paint->getAndroidTypeface();
John Reckf2285972016-09-30 14:10:05 -0700379 const jchar* textArray = env->GetCharArrayElements(text, nullptr);
Raph Levien854363e2014-06-03 19:56:05 -0700380 doTextBounds(env, textArray + index, count, bounds, *paint, typeface, bidiFlags);
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800381 env->ReleaseCharArrayElements(text, const_cast<jchar*>(textArray),
382 JNI_ABORT);
383 }
Elliott Hughes8451b252011-04-07 19:17:57 -0700384
John Reckf2285972016-09-30 14:10:05 -0700385 // Returns true if the given string is exact one pair of regional indicators.
386 static bool isFlag(const jchar* str, size_t length) {
387 const jchar RI_LEAD_SURROGATE = 0xD83C;
388 const jchar RI_TRAIL_SURROGATE_MIN = 0xDDE6;
389 const jchar RI_TRAIL_SURROGATE_MAX = 0xDDFF;
390
391 if (length != 4) {
392 return false;
393 }
394 if (str[0] != RI_LEAD_SURROGATE || str[2] != RI_LEAD_SURROGATE) {
395 return false;
396 }
397 return RI_TRAIL_SURROGATE_MIN <= str[1] && str[1] <= RI_TRAIL_SURROGATE_MAX &&
398 RI_TRAIL_SURROGATE_MIN <= str[3] && str[3] <= RI_TRAIL_SURROGATE_MAX;
399 }
400
Seigo Nonakaae1aa852016-06-09 19:42:51 +0900401 static jboolean layoutContainsNotdef(const minikin::Layout& layout) {
Raph Levienf7f969e62015-04-01 14:41:21 -0700402 for (size_t i = 0; i < layout.nGlyphs(); i++) {
403 if (layout.getGlyphId(i) == 0) {
404 return true;
405 }
406 }
407 return false;
408 }
409
Raph Levien6141db32016-07-11 13:59:58 -0700410 // Don't count glyphs that are the recommended "space" glyph and are zero width.
411 // This logic makes assumptions about HarfBuzz layout, but does correctly handle
412 // cases where ligatures form and zero width space glyphs are left in as
413 // placeholders.
414 static size_t countNonSpaceGlyphs(const minikin::Layout& layout) {
415 size_t count = 0;
416 static unsigned int kSpaceGlyphId = 3;
417 for (size_t i = 0; i < layout.nGlyphs(); i++) {
418 if (layout.getGlyphId(i) != kSpaceGlyphId || layout.getCharAdvance(i) != 0.0) {
419 count++;
420 }
421 }
422 return count;
423 }
424
Seigo Nonaka318ca042017-08-01 16:36:18 -0700425 static jboolean hasGlyph(JNIEnv *env, jclass, jlong paintHandle, jint bidiFlags,
426 jstring string) {
Raph Levienf7f969e62015-04-01 14:41:21 -0700427 const Paint* paint = reinterpret_cast<Paint*>(paintHandle);
Seigo Nonaka318ca042017-08-01 16:36:18 -0700428 const Typeface* typeface = paint->getAndroidTypeface();
Raph Levienf7f969e62015-04-01 14:41:21 -0700429 ScopedStringChars str(env, string);
430
Seigo Nonakabb1a9662015-10-21 23:24:25 +0900431 /* Start by rejecting unsupported base code point and variation selector pairs. */
Raph Levienf7f969e62015-04-01 14:41:21 -0700432 size_t nChars = 0;
Seigo Nonakabb1a9662015-10-21 23:24:25 +0900433 const uint32_t kStartOfString = 0xFFFFFFFF;
434 uint32_t prevCp = kStartOfString;
Raph Levienf7f969e62015-04-01 14:41:21 -0700435 for (size_t i = 0; i < str.size(); i++) {
Seigo Nonakabb1a9662015-10-21 23:24:25 +0900436 jchar cu = str[i];
437 uint32_t cp = cu;
438 if (U16_IS_TRAIL(cu)) {
Raph Levienf7f969e62015-04-01 14:41:21 -0700439 // invalid UTF-16, unpaired trailing surrogate
440 return false;
Seigo Nonakabb1a9662015-10-21 23:24:25 +0900441 } else if (U16_IS_LEAD(cu)) {
Raph Levienf7f969e62015-04-01 14:41:21 -0700442 if (i + 1 == str.size()) {
443 // invalid UTF-16, unpaired leading surrogate at end of string
444 return false;
445 }
446 i++;
Seigo Nonakabb1a9662015-10-21 23:24:25 +0900447 jchar cu2 = str[i];
448 if (!U16_IS_TRAIL(cu2)) {
Raph Levienf7f969e62015-04-01 14:41:21 -0700449 // invalid UTF-16, unpaired leading surrogate
450 return false;
451 }
Seigo Nonakabb1a9662015-10-21 23:24:25 +0900452 cp = U16_GET_SUPPLEMENTARY(cu, cu2);
453 }
454
455 if (prevCp != kStartOfString &&
Raph Levien032a3592016-04-14 21:22:37 -0700456 ((0xFE00 <= cp && cp <= 0xFE0F) || (0xE0100 <= cp && cp <= 0xE01EF))) {
457 bool hasVS = MinikinUtils::hasVariationSelector(typeface, prevCp, cp);
458 if (!hasVS) {
459 // No font has a glyph for the code point and variation selector pair.
460 return false;
461 } else if (nChars == 1 && i + 1 == str.size()) {
462 // The string is just a codepoint and a VS, we have an authoritative answer
463 return true;
464 }
Raph Levienf7f969e62015-04-01 14:41:21 -0700465 }
466 nChars++;
Seigo Nonakabb1a9662015-10-21 23:24:25 +0900467 prevCp = cp;
Raph Levienf7f969e62015-04-01 14:41:21 -0700468 }
Seigo Nonaka7c93e862017-10-25 16:34:48 -0700469 minikin::Layout layout = MinikinUtils::doLayout(paint,
Seigo Nonaka3a4217f2018-05-02 12:56:16 -0700470 static_cast<minikin::Bidi>(bidiFlags), typeface,
471 str.get(), str.size(), // text buffer
472 0, str.size(), // draw range
473 0, str.size(), // context range
474 nullptr);
Raph Levien6141db32016-07-11 13:59:58 -0700475 size_t nGlyphs = countNonSpaceGlyphs(layout);
Raph Levienf7f969e62015-04-01 14:41:21 -0700476 if (nGlyphs != 1 && nChars > 1) {
477 // multiple-character input, and was not a ligature
478 // TODO: handle ZWJ/ZWNJ characters specially so we can detect certain ligatures
479 // in joining scripts, such as Arabic and Mongolian.
480 return false;
481 }
Seigo Nonaka589cddc2016-04-05 14:43:14 +0900482
483 if (nGlyphs == 0 || layoutContainsNotdef(layout)) {
484 return false; // The collection doesn't have a glyph.
485 }
486
487 if (nChars == 2 && isFlag(str.get(), str.size())) {
488 // Some font may have a special glyph for unsupported regional indicator pairs.
489 // To return false for this case, need to compare the glyph id with the one of ZZ
490 // since ZZ is reserved for unknown or invalid territory.
491 // U+1F1FF (REGIONAL INDICATOR SYMBOL LETTER Z) is \uD83C\uDDFF in UTF16.
492 static const jchar ZZ_FLAG_STR[] = { 0xD83C, 0xDDFF, 0xD83C, 0xDDFF };
Seigo Nonaka7c93e862017-10-25 16:34:48 -0700493 minikin::Layout zzLayout = MinikinUtils::doLayout(paint,
Seigo Nonaka3a4217f2018-05-02 12:56:16 -0700494 static_cast<minikin::Bidi>(bidiFlags), typeface,
495 ZZ_FLAG_STR, 4, // text buffer
496 0, 4, // draw range
497 0, 4, // context range
Seigo Nonaka83143d02018-03-14 17:08:28 -0700498 nullptr);
Seigo Nonaka589cddc2016-04-05 14:43:14 +0900499 if (zzLayout.nGlyphs() != 1 || layoutContainsNotdef(zzLayout)) {
500 // The font collection doesn't have a glyph for unknown flag. Just return true.
501 return true;
502 }
503 return zzLayout.getGlyphId(0) != layout.getGlyphId(0);
504 }
505 return true;
Raph Levienf7f969e62015-04-01 14:41:21 -0700506 }
507
Haoyu Zhangc8abba42022-06-23 10:29:24 -0700508 static jfloat doRunAdvance(JNIEnv* env, const Paint* paint, const Typeface* typeface,
509 const jchar buf[], jint start, jint count, jint bufSize,
510 jboolean isRtl, jint offset, jfloatArray advances,
Seigo Nonakadd617182023-12-07 08:56:31 +0900511 jint advancesIndex, SkRect* drawBounds, uint32_t* clusterCount) {
Haoyu Zhangc8abba42022-06-23 10:29:24 -0700512 if (advances) {
513 size_t advancesLength = env->GetArrayLength(advances);
514 if ((size_t)(count + advancesIndex) > advancesLength) {
515 doThrowAIOOBE(env);
516 return 0;
517 }
518 }
Seigo Nonaka7c93e862017-10-25 16:34:48 -0700519 minikin::Bidi bidiFlags = isRtl ? minikin::Bidi::FORCE_RTL : minikin::Bidi::FORCE_LTR;
Seigo Nonaka6e39daf2023-08-19 11:36:26 +0900520 minikin::MinikinRect bounds;
Haoyu Zhangc8abba42022-06-23 10:29:24 -0700521 if (offset == start + count && advances == nullptr) {
Seigo Nonakadd617182023-12-07 08:56:31 +0900522 float result = MinikinUtils::measureText(paint, bidiFlags, typeface, buf, start, count,
523 bufSize, nullptr,
524 drawBounds ? &bounds : nullptr, clusterCount);
Seigo Nonaka6e39daf2023-08-19 11:36:26 +0900525 if (drawBounds) {
526 copyMinikinRectToSkRect(bounds, drawBounds);
527 }
528 return result;
Keisuke Kuroyanagi4c8a5262016-02-18 11:31:56 -0800529 }
530 std::unique_ptr<float[]> advancesArray(new float[count]);
531 MinikinUtils::measureText(paint, bidiFlags, typeface, buf, start, count, bufSize,
Seigo Nonakadd617182023-12-07 08:56:31 +0900532 advancesArray.get(), drawBounds ? &bounds : nullptr,
533 clusterCount);
Haoyu Zhangc8abba42022-06-23 10:29:24 -0700534
Seigo Nonaka6e39daf2023-08-19 11:36:26 +0900535 if (drawBounds) {
536 copyMinikinRectToSkRect(bounds, drawBounds);
537 }
Haoyu Zhang852de8272022-07-27 16:48:14 -0700538 float result = minikin::getRunAdvance(advancesArray.get(), buf, start, count, offset);
Haoyu Zhangc8abba42022-06-23 10:29:24 -0700539 if (advances) {
Haoyu Zhang852de8272022-07-27 16:48:14 -0700540 minikin::distributeAdvances(advancesArray.get(), buf, start, count);
Haoyu Zhangc8abba42022-06-23 10:29:24 -0700541 env->SetFloatArrayRegion(advances, advancesIndex, count, advancesArray.get());
542 }
Haoyu Zhang852de8272022-07-27 16:48:14 -0700543 return result;
Raph Leviena027ec52015-04-06 16:21:59 -0700544 }
545
Seigo Nonaka318ca042017-08-01 16:36:18 -0700546 static jfloat getRunAdvance___CIIIIZI_F(JNIEnv *env, jclass, jlong paintHandle, jcharArray text,
547 jint start, jint end, jint contextStart, jint contextEnd, jboolean isRtl, jint offset) {
Raph Leviena027ec52015-04-06 16:21:59 -0700548 const Paint* paint = reinterpret_cast<Paint*>(paintHandle);
Seigo Nonaka318ca042017-08-01 16:36:18 -0700549 const Typeface* typeface = paint->getAndroidTypeface();
Seigo Nonakaee23f612018-01-27 15:08:25 -0800550 ScopedCharArrayRO textArray(env, text);
Haoyu Zhangc8abba42022-06-23 10:29:24 -0700551 jfloat result = doRunAdvance(env, paint, typeface, textArray.get() + contextStart,
552 start - contextStart, end - start, contextEnd - contextStart,
Seigo Nonakadd617182023-12-07 08:56:31 +0900553 isRtl, offset - contextStart, nullptr, 0, nullptr, nullptr);
Haoyu Zhangc8abba42022-06-23 10:29:24 -0700554 return result;
555 }
556
557 static jfloat getRunCharacterAdvance___CIIIIZI_FI_F(JNIEnv* env, jclass, jlong paintHandle,
558 jcharArray text, jint start, jint end,
559 jint contextStart, jint contextEnd,
560 jboolean isRtl, jint offset,
Seigo Nonaka6e39daf2023-08-19 11:36:26 +0900561 jfloatArray advances, jint advancesIndex,
Seigo Nonakadd617182023-12-07 08:56:31 +0900562 jobject drawBounds, jobject runInfo) {
Haoyu Zhangc8abba42022-06-23 10:29:24 -0700563 const Paint* paint = reinterpret_cast<Paint*>(paintHandle);
564 const Typeface* typeface = paint->getAndroidTypeface();
565 ScopedCharArrayRO textArray(env, text);
Seigo Nonaka6e39daf2023-08-19 11:36:26 +0900566 SkRect skDrawBounds;
Seigo Nonakadd617182023-12-07 08:56:31 +0900567 uint32_t clusterCount = 0;
Haoyu Zhangc8abba42022-06-23 10:29:24 -0700568 jfloat result = doRunAdvance(env, paint, typeface, textArray.get() + contextStart,
569 start - contextStart, end - start, contextEnd - contextStart,
Seigo Nonaka6e39daf2023-08-19 11:36:26 +0900570 isRtl, offset - contextStart, advances, advancesIndex,
Seigo Nonakadd617182023-12-07 08:56:31 +0900571 drawBounds ? &skDrawBounds : nullptr, &clusterCount);
Seigo Nonaka6e39daf2023-08-19 11:36:26 +0900572 if (drawBounds != nullptr) {
573 GraphicsJNI::rect_to_jrectf(skDrawBounds, env, drawBounds);
574 }
Seigo Nonakadd617182023-12-07 08:56:31 +0900575 if (runInfo) {
576 GraphicsJNI::set_cluster_count_to_run_info(env, runInfo, clusterCount);
577 }
Raph Leviena027ec52015-04-06 16:21:59 -0700578 return result;
579 }
580
Seigo Nonaka318ca042017-08-01 16:36:18 -0700581 static jint doOffsetForAdvance(const Paint* paint, const Typeface* typeface, const jchar buf[],
Raph Leviena027ec52015-04-06 16:21:59 -0700582 jint start, jint count, jint bufSize, jboolean isRtl, jfloat advance) {
Seigo Nonaka7c93e862017-10-25 16:34:48 -0700583 minikin::Bidi bidiFlags = isRtl ? minikin::Bidi::FORCE_RTL : minikin::Bidi::FORCE_LTR;
Keisuke Kuroyanagi4c8a5262016-02-18 11:31:56 -0800584 std::unique_ptr<float[]> advancesArray(new float[count]);
585 MinikinUtils::measureText(paint, bidiFlags, typeface, buf, start, count, bufSize,
Seigo Nonakadd617182023-12-07 08:56:31 +0900586 advancesArray.get(), nullptr, nullptr);
Seigo Nonakaae1aa852016-06-09 19:42:51 +0900587 return minikin::getOffsetForAdvance(advancesArray.get(), buf, start, count, advance);
Raph Leviena027ec52015-04-06 16:21:59 -0700588 }
Keisuke Kuroyanagi4c8a5262016-02-18 11:31:56 -0800589
Raph Leviena027ec52015-04-06 16:21:59 -0700590 static jint getOffsetForAdvance___CIIIIZF_I(JNIEnv *env, jclass, jlong paintHandle,
Seigo Nonaka318ca042017-08-01 16:36:18 -0700591 jcharArray text, jint start, jint end, jint contextStart, jint contextEnd,
592 jboolean isRtl, jfloat advance) {
Raph Leviena027ec52015-04-06 16:21:59 -0700593 const Paint* paint = reinterpret_cast<Paint*>(paintHandle);
Seigo Nonaka318ca042017-08-01 16:36:18 -0700594 const Typeface* typeface = paint->getAndroidTypeface();
Seigo Nonakaee23f612018-01-27 15:08:25 -0800595 ScopedCharArrayRO textArray(env, text);
596 jint result = doOffsetForAdvance(paint, typeface, textArray.get() + contextStart,
Raph Leviena027ec52015-04-06 16:21:59 -0700597 start - contextStart, end - start, contextEnd - contextStart, isRtl, advance);
598 result += contextStart;
Raph Leviena027ec52015-04-06 16:21:59 -0700599 return result;
600 }
601
Seigo Nonaka59a0baf2023-10-06 15:59:28 +0900602 static SkScalar getMetricsInternal(jlong paintHandle, SkFontMetrics* metrics, bool useLocale) {
John Reckf2285972016-09-30 14:10:05 -0700603 const int kElegantTop = 2500;
604 const int kElegantBottom = -1000;
605 const int kElegantAscent = 1900;
606 const int kElegantDescent = -500;
607 const int kElegantLeading = 0;
608 Paint* paint = reinterpret_cast<Paint*>(paintHandle);
Mike Reedf6d86ac2019-01-18 14:13:23 -0500609 SkFont* font = &paint->getSkFont();
Seigo Nonaka318ca042017-08-01 16:36:18 -0700610 const Typeface* typeface = paint->getAndroidTypeface();
John Reckf2285972016-09-30 14:10:05 -0700611 typeface = Typeface::resolveDefault(typeface);
612 minikin::FakedFont baseFont = typeface->fFontCollection->baseFontFaked(typeface->fStyle);
Mike Reedf6d86ac2019-01-18 14:13:23 -0500613 float saveSkewX = font->getSkewX();
614 bool savefakeBold = font->isEmbolden();
Seigo Nonaka032aac92023-05-26 10:15:53 +0900615 MinikinFontSkia::populateSkFont(font, baseFont.typeface().get(), baseFont.fakery);
Mike Reedf6d86ac2019-01-18 14:13:23 -0500616 SkScalar spacing = font->getMetrics(metrics);
John Reckf2285972016-09-30 14:10:05 -0700617 // The populateSkPaint call may have changed fake bold / text skew
618 // because we want to measure with those effects applied, so now
619 // restore the original settings.
Mike Reedf6d86ac2019-01-18 14:13:23 -0500620 font->setSkewX(saveSkewX);
621 font->setEmbolden(savefakeBold);
Seigo Nonaka0ca492f2018-05-25 14:52:22 -0700622 if (paint->getFamilyVariant() == minikin::FamilyVariant::ELEGANT) {
Mike Reedf6d86ac2019-01-18 14:13:23 -0500623 SkScalar size = font->getSize();
John Reckf2285972016-09-30 14:10:05 -0700624 metrics->fTop = -size * kElegantTop / 2048;
625 metrics->fBottom = -size * kElegantBottom / 2048;
626 metrics->fAscent = -size * kElegantAscent / 2048;
627 metrics->fDescent = -size * kElegantDescent / 2048;
628 metrics->fLeading = size * kElegantLeading / 2048;
629 spacing = metrics->fDescent - metrics->fAscent + metrics->fLeading;
630 }
Seigo Nonaka59a0baf2023-10-06 15:59:28 +0900631
632 if (useLocale) {
633 minikin::MinikinPaint minikinPaint = MinikinUtils::prepareMinikinPaint(paint, typeface);
634 minikin::MinikinExtent extent =
635 typeface->fFontCollection->getReferenceExtentForLocale(minikinPaint);
636 metrics->fAscent = std::min(extent.ascent, metrics->fAscent);
637 metrics->fDescent = std::max(extent.descent, metrics->fDescent);
638 metrics->fTop = std::min(metrics->fAscent, metrics->fTop);
639 metrics->fBottom = std::max(metrics->fDescent, metrics->fBottom);
640 }
641
John Reckf2285972016-09-30 14:10:05 -0700642 return spacing;
643 }
644
Seigo Nonaka78c774d2021-12-10 10:49:43 -0800645 static void doFontExtent(JNIEnv* env, jlong paintHandle, const jchar buf[], jint start,
646 jint count, jint bufSize, jboolean isRtl, jobject fmi) {
647 const Paint* paint = reinterpret_cast<Paint*>(paintHandle);
648 const Typeface* typeface = paint->getAndroidTypeface();
649 minikin::Bidi bidiFlags = isRtl ? minikin::Bidi::FORCE_RTL : minikin::Bidi::FORCE_LTR;
650 minikin::MinikinExtent extent =
651 MinikinUtils::getFontExtent(paint, bidiFlags, typeface, buf, start, count, bufSize);
652
653 SkFontMetrics metrics;
Seigo Nonaka59a0baf2023-10-06 15:59:28 +0900654 getMetricsInternal(paintHandle, &metrics, false /* useLocale */);
Seigo Nonaka78c774d2021-12-10 10:49:43 -0800655
656 metrics.fAscent = extent.ascent;
657 metrics.fDescent = extent.descent;
658
659 // If top/bottom is narrower than ascent/descent, adjust top/bottom to ascent/descent.
660 metrics.fTop = std::min(metrics.fAscent, metrics.fTop);
661 metrics.fBottom = std::max(metrics.fDescent, metrics.fBottom);
662
663 GraphicsJNI::set_metrics_int(env, fmi, metrics);
664 }
665
666 static void getFontMetricsIntForText___C(JNIEnv* env, jclass, jlong paintHandle,
667 jcharArray text, jint start, jint count, jint ctxStart,
668 jint ctxCount, jboolean isRtl, jobject fmi) {
669 ScopedCharArrayRO textArray(env, text);
670
671 doFontExtent(env, paintHandle, textArray.get() + ctxStart, start - ctxStart, count,
672 ctxCount, isRtl, fmi);
673 }
674
675 static void getFontMetricsIntForText___String(JNIEnv* env, jclass, jlong paintHandle,
676 jstring text, jint start, jint count,
677 jint ctxStart, jint ctxCount, jboolean isRtl,
678 jobject fmi) {
679 ScopedStringChars textChars(env, text);
680
681 doFontExtent(env, paintHandle, textChars.get() + ctxStart, start - ctxStart, count,
682 ctxCount, isRtl, fmi);
683 }
684
685 // ------------------ @FastNative ---------------------------
686
687 static jint setTextLocales(JNIEnv* env, jobject clazz, jlong objHandle, jstring locales) {
688 Paint* obj = reinterpret_cast<Paint*>(objHandle);
689 ScopedUtfChars localesChars(env, locales);
690 jint minikinLocaleListId = minikin::registerLocaleList(localesChars.c_str());
691 obj->setMinikinLocaleListId(minikinLocaleListId);
692 return minikinLocaleListId;
693 }
694
695 static void setFontFeatureSettings(JNIEnv* env, jobject clazz, jlong paintHandle,
696 jstring settings) {
697 Paint* paint = reinterpret_cast<Paint*>(paintHandle);
698 if (!settings) {
Seigo Nonaka9bda91a2023-10-28 19:11:22 +0900699 paint->resetFontFeatures();
Seigo Nonaka78c774d2021-12-10 10:49:43 -0800700 } else {
701 ScopedUtfChars settingsChars(env, settings);
Seigo Nonaka9bda91a2023-10-28 19:11:22 +0900702 paint->setFontFeatureSettings(
703 std::string_view(settingsChars.c_str(), settingsChars.size()));
Seigo Nonaka78c774d2021-12-10 10:49:43 -0800704 }
705 }
706
Seigo Nonaka59a0baf2023-10-06 15:59:28 +0900707 static jfloat getFontMetrics(JNIEnv* env, jobject, jlong paintHandle, jobject metricsObj,
708 jboolean useLocale) {
Mike Reedda3488a2018-12-14 12:08:55 -0500709 SkFontMetrics metrics;
Seigo Nonaka59a0baf2023-10-06 15:59:28 +0900710 SkScalar spacing = getMetricsInternal(paintHandle, &metrics, useLocale);
Seigo Nonaka1ed4f642020-09-10 17:19:34 -0700711 GraphicsJNI::set_metrics(env, metricsObj, metrics);
John Reckf2285972016-09-30 14:10:05 -0700712 return SkScalarToFloat(spacing);
713 }
714
Seigo Nonaka59a0baf2023-10-06 15:59:28 +0900715 static jint getFontMetricsInt(JNIEnv* env, jobject, jlong paintHandle, jobject metricsObj,
716 jboolean useLocale) {
Mike Reedda3488a2018-12-14 12:08:55 -0500717 SkFontMetrics metrics;
Seigo Nonaka59a0baf2023-10-06 15:59:28 +0900718 getMetricsInternal(paintHandle, &metrics, useLocale);
Seigo Nonaka1ed4f642020-09-10 17:19:34 -0700719 return GraphicsJNI::set_metrics_int(env, metricsObj, metrics);
John Reckf2285972016-09-30 14:10:05 -0700720 }
721
John Reckf2285972016-09-30 14:10:05 -0700722 // ------------------ @CriticalNative ---------------------------
723
Jerome Gaillard21e7e2d2019-05-14 14:34:46 +0100724 static void reset(CRITICAL_JNI_PARAMS_COMMA jlong objHandle) {
Mike Reedf6d86ac2019-01-18 14:13:23 -0500725 reinterpret_cast<Paint*>(objHandle)->reset();
John Reckf2285972016-09-30 14:10:05 -0700726 }
727
Jerome Gaillard21e7e2d2019-05-14 14:34:46 +0100728 static void assign(CRITICAL_JNI_PARAMS_COMMA jlong dstPaintHandle, jlong srcPaintHandle) {
John Reckf2285972016-09-30 14:10:05 -0700729 Paint* dst = reinterpret_cast<Paint*>(dstPaintHandle);
730 const Paint* src = reinterpret_cast<Paint*>(srcPaintHandle);
731 *dst = *src;
732 }
733
Jerome Gaillard21e7e2d2019-05-14 14:34:46 +0100734 static jint getFlags(CRITICAL_JNI_PARAMS_COMMA jlong paintHandle) {
Mike Reedf6d86ac2019-01-18 14:13:23 -0500735 uint32_t flags = reinterpret_cast<Paint*>(paintHandle)->getJavaFlags();
736 return static_cast<jint>(flags);
John Reckf2285972016-09-30 14:10:05 -0700737 }
738
Jerome Gaillard21e7e2d2019-05-14 14:34:46 +0100739 static void setFlags(CRITICAL_JNI_PARAMS_COMMA jlong paintHandle, jint flags) {
Mike Reedf6d86ac2019-01-18 14:13:23 -0500740 reinterpret_cast<Paint*>(paintHandle)->setJavaFlags(flags);
John Reckf2285972016-09-30 14:10:05 -0700741 }
742
Jerome Gaillard21e7e2d2019-05-14 14:34:46 +0100743 static jint getHinting(CRITICAL_JNI_PARAMS_COMMA jlong paintHandle) {
Mike Reed03acdb12019-01-26 10:17:31 -0500744 return (SkFontHinting)reinterpret_cast<Paint*>(paintHandle)->getSkFont().getHinting()
Ben Wagner0ab44392019-05-09 18:44:34 -0400745 == SkFontHinting::kNone ? 0 : 1;
John Reckf2285972016-09-30 14:10:05 -0700746 }
747
Jerome Gaillard21e7e2d2019-05-14 14:34:46 +0100748 static void setHinting(CRITICAL_JNI_PARAMS_COMMA jlong paintHandle, jint mode) {
Mike Reed03acdb12019-01-26 10:17:31 -0500749 reinterpret_cast<Paint*>(paintHandle)->getSkFont().setHinting(
Ben Wagner0ab44392019-05-09 18:44:34 -0400750 mode == 0 ? SkFontHinting::kNone : SkFontHinting::kNormal);
John Reckf2285972016-09-30 14:10:05 -0700751 }
752
Jerome Gaillard21e7e2d2019-05-14 14:34:46 +0100753 static void setAntiAlias(CRITICAL_JNI_PARAMS_COMMA jlong paintHandle, jboolean aa) {
John Reckf2285972016-09-30 14:10:05 -0700754 reinterpret_cast<Paint*>(paintHandle)->setAntiAlias(aa);
755 }
756
Jerome Gaillard21e7e2d2019-05-14 14:34:46 +0100757 static void setLinearText(CRITICAL_JNI_PARAMS_COMMA jlong paintHandle, jboolean linearText) {
Mike Reedf6d86ac2019-01-18 14:13:23 -0500758 reinterpret_cast<Paint*>(paintHandle)->getSkFont().setLinearMetrics(linearText);
John Reckf2285972016-09-30 14:10:05 -0700759 }
760
Jerome Gaillard21e7e2d2019-05-14 14:34:46 +0100761 static void setSubpixelText(CRITICAL_JNI_PARAMS_COMMA jlong paintHandle, jboolean subpixelText) {
Mike Reedf6d86ac2019-01-18 14:13:23 -0500762 reinterpret_cast<Paint*>(paintHandle)->getSkFont().setSubpixel(subpixelText);
John Reckf2285972016-09-30 14:10:05 -0700763 }
764
Jerome Gaillard21e7e2d2019-05-14 14:34:46 +0100765 static void setUnderlineText(CRITICAL_JNI_PARAMS_COMMA jlong paintHandle, jboolean underlineText) {
Mike Reedf6d86ac2019-01-18 14:13:23 -0500766 reinterpret_cast<Paint*>(paintHandle)->setUnderline(underlineText);
John Reckf2285972016-09-30 14:10:05 -0700767 }
768
Jerome Gaillard21e7e2d2019-05-14 14:34:46 +0100769 static void setStrikeThruText(CRITICAL_JNI_PARAMS_COMMA jlong paintHandle, jboolean strikeThruText) {
Mike Reedf6d86ac2019-01-18 14:13:23 -0500770 reinterpret_cast<Paint*>(paintHandle)->setStrikeThru(strikeThruText);
John Reckf2285972016-09-30 14:10:05 -0700771 }
772
Jerome Gaillard21e7e2d2019-05-14 14:34:46 +0100773 static void setFakeBoldText(CRITICAL_JNI_PARAMS_COMMA jlong paintHandle, jboolean fakeBoldText) {
Mike Reedf6d86ac2019-01-18 14:13:23 -0500774 reinterpret_cast<Paint*>(paintHandle)->getSkFont().setEmbolden(fakeBoldText);
John Reckf2285972016-09-30 14:10:05 -0700775 }
776
Jerome Gaillard21e7e2d2019-05-14 14:34:46 +0100777 static void setFilterBitmap(CRITICAL_JNI_PARAMS_COMMA jlong paintHandle, jboolean filterBitmap) {
Mike Reeda6cb58a2021-07-10 13:31:34 -0400778 reinterpret_cast<Paint*>(paintHandle)->setFilterBitmap(filterBitmap);
John Reckf2285972016-09-30 14:10:05 -0700779 }
780
Jerome Gaillard21e7e2d2019-05-14 14:34:46 +0100781 static void setDither(CRITICAL_JNI_PARAMS_COMMA jlong paintHandle, jboolean dither) {
John Reckf2285972016-09-30 14:10:05 -0700782 reinterpret_cast<Paint*>(paintHandle)->setDither(dither);
783 }
784
Jerome Gaillard21e7e2d2019-05-14 14:34:46 +0100785 static jint getStyle(CRITICAL_JNI_PARAMS_COMMA jlong objHandle) {
John Reckf2285972016-09-30 14:10:05 -0700786 Paint* obj = reinterpret_cast<Paint*>(objHandle);
787 return static_cast<jint>(obj->getStyle());
788 }
789
Jerome Gaillard21e7e2d2019-05-14 14:34:46 +0100790 static void setStyle(CRITICAL_JNI_PARAMS_COMMA jlong objHandle, jint styleHandle) {
John Reckf2285972016-09-30 14:10:05 -0700791 Paint* obj = reinterpret_cast<Paint*>(objHandle);
792 Paint::Style style = static_cast<Paint::Style>(styleHandle);
793 obj->setStyle(style);
794 }
795
Jerome Gaillard21e7e2d2019-05-14 14:34:46 +0100796 static void setColorLong(CRITICAL_JNI_PARAMS_COMMA jlong paintHandle, jlong colorSpaceHandle,
Leon Scroggins III10965f32019-03-12 11:13:27 -0400797 jlong colorLong) {
798 SkColor4f color = GraphicsJNI::convertColorLong(colorLong);
Leon Scroggins III0e443d12018-12-19 11:38:35 -0500799 sk_sp<SkColorSpace> cs = GraphicsJNI::getNativeColorSpace(colorSpaceHandle);
Leon Scroggins III0e443d12018-12-19 11:38:35 -0500800 reinterpret_cast<Paint*>(paintHandle)->setColor4f(color, cs.get());
801 }
802
Jerome Gaillard21e7e2d2019-05-14 14:34:46 +0100803 static void setColor(CRITICAL_JNI_PARAMS_COMMA jlong paintHandle, jint color) {
Leon Scroggins III03b3e2362019-03-12 10:15:46 -0400804 reinterpret_cast<Paint*>(paintHandle)->setColor(color);
805 }
806
Jerome Gaillard21e7e2d2019-05-14 14:34:46 +0100807 static void setAlpha(CRITICAL_JNI_PARAMS_COMMA jlong paintHandle, jint a) {
John Reckf2285972016-09-30 14:10:05 -0700808 reinterpret_cast<Paint*>(paintHandle)->setAlpha(a);
809 }
810
Jerome Gaillard21e7e2d2019-05-14 14:34:46 +0100811 static jfloat getStrokeWidth(CRITICAL_JNI_PARAMS_COMMA jlong paintHandle) {
John Reckf2285972016-09-30 14:10:05 -0700812 return SkScalarToFloat(reinterpret_cast<Paint*>(paintHandle)->getStrokeWidth());
813 }
814
Jerome Gaillard21e7e2d2019-05-14 14:34:46 +0100815 static void setStrokeWidth(CRITICAL_JNI_PARAMS_COMMA jlong paintHandle, jfloat width) {
John Reckf2285972016-09-30 14:10:05 -0700816 reinterpret_cast<Paint*>(paintHandle)->setStrokeWidth(width);
817 }
818
Jerome Gaillard21e7e2d2019-05-14 14:34:46 +0100819 static jfloat getStrokeMiter(CRITICAL_JNI_PARAMS_COMMA jlong paintHandle) {
John Reckf2285972016-09-30 14:10:05 -0700820 return SkScalarToFloat(reinterpret_cast<Paint*>(paintHandle)->getStrokeMiter());
821 }
822
Jerome Gaillard21e7e2d2019-05-14 14:34:46 +0100823 static void setStrokeMiter(CRITICAL_JNI_PARAMS_COMMA jlong paintHandle, jfloat miter) {
John Reckf2285972016-09-30 14:10:05 -0700824 reinterpret_cast<Paint*>(paintHandle)->setStrokeMiter(miter);
825 }
826
Jerome Gaillard21e7e2d2019-05-14 14:34:46 +0100827 static jint getStrokeCap(CRITICAL_JNI_PARAMS_COMMA jlong objHandle) {
John Reckf2285972016-09-30 14:10:05 -0700828 Paint* obj = reinterpret_cast<Paint*>(objHandle);
829 return static_cast<jint>(obj->getStrokeCap());
830 }
831
Jerome Gaillard21e7e2d2019-05-14 14:34:46 +0100832 static void setStrokeCap(CRITICAL_JNI_PARAMS_COMMA jlong objHandle, jint capHandle) {
John Reckf2285972016-09-30 14:10:05 -0700833 Paint* obj = reinterpret_cast<Paint*>(objHandle);
834 Paint::Cap cap = static_cast<Paint::Cap>(capHandle);
835 obj->setStrokeCap(cap);
836 }
837
Jerome Gaillard21e7e2d2019-05-14 14:34:46 +0100838 static jint getStrokeJoin(CRITICAL_JNI_PARAMS_COMMA jlong objHandle) {
John Reckf2285972016-09-30 14:10:05 -0700839 Paint* obj = reinterpret_cast<Paint*>(objHandle);
840 return static_cast<jint>(obj->getStrokeJoin());
841 }
842
Jerome Gaillard21e7e2d2019-05-14 14:34:46 +0100843 static void setStrokeJoin(CRITICAL_JNI_PARAMS_COMMA jlong objHandle, jint joinHandle) {
John Reckf2285972016-09-30 14:10:05 -0700844 Paint* obj = reinterpret_cast<Paint*>(objHandle);
845 Paint::Join join = (Paint::Join) joinHandle;
846 obj->setStrokeJoin(join);
847 }
848
Jerome Gaillard21e7e2d2019-05-14 14:34:46 +0100849 static jboolean getFillPath(CRITICAL_JNI_PARAMS_COMMA jlong objHandle, jlong srcHandle, jlong dstHandle) {
John Reckf2285972016-09-30 14:10:05 -0700850 Paint* obj = reinterpret_cast<Paint*>(objHandle);
851 SkPath* src = reinterpret_cast<SkPath*>(srcHandle);
852 SkPath* dst = reinterpret_cast<SkPath*>(dstHandle);
Kevin Lubick8df9a682022-12-14 18:52:56 +0000853 return skpathutils::FillPathWithPaint(*src, *obj, dst) ? JNI_TRUE : JNI_FALSE;
John Reckf2285972016-09-30 14:10:05 -0700854 }
855
Nader Jawad5bed1f52020-09-25 00:27:29 -0700856 static jlong setShader(CRITICAL_JNI_PARAMS_COMMA jlong objHandle, jlong shaderHandle) {
857 Paint* obj = reinterpret_cast<Paint*>(objHandle);
858 SkShader* shader = reinterpret_cast<SkShader*>(shaderHandle);
859 obj->setShader(sk_ref_sp(shader));
860 return reinterpret_cast<jlong>(obj->getShader());
John Reckf2285972016-09-30 14:10:05 -0700861 }
862
Jerome Gaillard21e7e2d2019-05-14 14:34:46 +0100863 static jlong setColorFilter(CRITICAL_JNI_PARAMS_COMMA jlong objHandle, jlong filterHandle) {
John Reckf2285972016-09-30 14:10:05 -0700864 Paint* obj = reinterpret_cast<Paint *>(objHandle);
Nader Jawadf0ea9e12023-05-02 15:18:00 -0700865 auto colorFilter = uirenderer::ColorFilter::fromJava(filterHandle);
866 auto skColorFilter =
867 colorFilter != nullptr ? colorFilter->getInstance() : sk_sp<SkColorFilter>();
868 obj->setColorFilter(skColorFilter);
869 return filterHandle;
John Reckf2285972016-09-30 14:10:05 -0700870 }
871
Jerome Gaillard21e7e2d2019-05-14 14:34:46 +0100872 static void setXfermode(CRITICAL_JNI_PARAMS_COMMA jlong paintHandle, jint xfermodeHandle) {
John Reckf2285972016-09-30 14:10:05 -0700873 // validate that the Java enum values match our expectations
Mike Reed260ab722016-10-07 15:59:20 -0400874 static_assert(0 == static_cast<int>(SkBlendMode::kClear), "xfermode_mismatch");
875 static_assert(1 == static_cast<int>(SkBlendMode::kSrc), "xfermode_mismatch");
876 static_assert(2 == static_cast<int>(SkBlendMode::kDst), "xfermode_mismatch");
877 static_assert(3 == static_cast<int>(SkBlendMode::kSrcOver), "xfermode_mismatch");
878 static_assert(4 == static_cast<int>(SkBlendMode::kDstOver), "xfermode_mismatch");
879 static_assert(5 == static_cast<int>(SkBlendMode::kSrcIn), "xfermode_mismatch");
880 static_assert(6 == static_cast<int>(SkBlendMode::kDstIn), "xfermode_mismatch");
881 static_assert(7 == static_cast<int>(SkBlendMode::kSrcOut), "xfermode_mismatch");
882 static_assert(8 == static_cast<int>(SkBlendMode::kDstOut), "xfermode_mismatch");
883 static_assert(9 == static_cast<int>(SkBlendMode::kSrcATop), "xfermode_mismatch");
884 static_assert(10 == static_cast<int>(SkBlendMode::kDstATop), "xfermode_mismatch");
885 static_assert(11 == static_cast<int>(SkBlendMode::kXor), "xfermode_mismatch");
Nader Jawad55e49d82018-11-16 11:22:32 -0800886 static_assert(12 == static_cast<int>(SkBlendMode::kPlus), "xfermode_mismatch");
Mike Reed260ab722016-10-07 15:59:20 -0400887 static_assert(13 == static_cast<int>(SkBlendMode::kModulate), "xfermode_mismatch");
888 static_assert(14 == static_cast<int>(SkBlendMode::kScreen), "xfermode_mismatch");
Mike Reed260ab722016-10-07 15:59:20 -0400889 static_assert(15 == static_cast<int>(SkBlendMode::kOverlay), "xfermode_mismatch");
Nader Jawad55e49d82018-11-16 11:22:32 -0800890 static_assert(16 == static_cast<int>(SkBlendMode::kDarken), "xfermode_mismatch");
891 static_assert(17 == static_cast<int>(SkBlendMode::kLighten), "xfermode_mismatch");
892 static_assert(18 == static_cast<int>(SkBlendMode::kColorDodge), "xfermode mismatch");
893 static_assert(19 == static_cast<int>(SkBlendMode::kColorBurn), "xfermode mismatch");
894 static_assert(20 == static_cast<int>(SkBlendMode::kHardLight), "xfermode mismatch");
895 static_assert(21 == static_cast<int>(SkBlendMode::kSoftLight), "xfermode mismatch");
896 static_assert(22 == static_cast<int>(SkBlendMode::kDifference), "xfermode mismatch");
897 static_assert(23 == static_cast<int>(SkBlendMode::kExclusion), "xfermode mismatch");
898 static_assert(24 == static_cast<int>(SkBlendMode::kMultiply), "xfermode mismatch");
899 static_assert(25 == static_cast<int>(SkBlendMode::kHue), "xfermode mismatch");
900 static_assert(26 == static_cast<int>(SkBlendMode::kSaturation), "xfermode mismatch");
901 static_assert(27 == static_cast<int>(SkBlendMode::kColor), "xfermode mismatch");
902 static_assert(28 == static_cast<int>(SkBlendMode::kLuminosity), "xfermode mismatch");
John Reckf2285972016-09-30 14:10:05 -0700903
Mike Reed260ab722016-10-07 15:59:20 -0400904 SkBlendMode mode = static_cast<SkBlendMode>(xfermodeHandle);
John Reckf2285972016-09-30 14:10:05 -0700905 Paint* paint = reinterpret_cast<Paint*>(paintHandle);
Mike Reed260ab722016-10-07 15:59:20 -0400906 paint->setBlendMode(mode);
John Reckf2285972016-09-30 14:10:05 -0700907 }
908
Jerome Gaillard21e7e2d2019-05-14 14:34:46 +0100909 static jlong setPathEffect(CRITICAL_JNI_PARAMS_COMMA jlong objHandle, jlong effectHandle) {
John Reckf2285972016-09-30 14:10:05 -0700910 Paint* obj = reinterpret_cast<Paint*>(objHandle);
911 SkPathEffect* effect = reinterpret_cast<SkPathEffect*>(effectHandle);
Mike Reed260ab722016-10-07 15:59:20 -0400912 obj->setPathEffect(sk_ref_sp(effect));
913 return reinterpret_cast<jlong>(obj->getPathEffect());
John Reckf2285972016-09-30 14:10:05 -0700914 }
915
Jerome Gaillard21e7e2d2019-05-14 14:34:46 +0100916 static jlong setMaskFilter(CRITICAL_JNI_PARAMS_COMMA jlong objHandle, jlong maskfilterHandle) {
John Reckf2285972016-09-30 14:10:05 -0700917 Paint* obj = reinterpret_cast<Paint*>(objHandle);
918 SkMaskFilter* maskfilter = reinterpret_cast<SkMaskFilter*>(maskfilterHandle);
Mike Reed260ab722016-10-07 15:59:20 -0400919 obj->setMaskFilter(sk_ref_sp(maskfilter));
920 return reinterpret_cast<jlong>(obj->getMaskFilter());
John Reckf2285972016-09-30 14:10:05 -0700921 }
922
Jerome Gaillard21e7e2d2019-05-14 14:34:46 +0100923 static void setTypeface(CRITICAL_JNI_PARAMS_COMMA jlong objHandle, jlong typefaceHandle) {
Seigo Nonaka318ca042017-08-01 16:36:18 -0700924 Paint* paint = reinterpret_cast<Paint*>(objHandle);
925 paint->setAndroidTypeface(reinterpret_cast<Typeface*>(typefaceHandle));
John Reckf2285972016-09-30 14:10:05 -0700926 }
927
Jerome Gaillard21e7e2d2019-05-14 14:34:46 +0100928 static jint getTextAlign(CRITICAL_JNI_PARAMS_COMMA jlong objHandle) {
John Reckf2285972016-09-30 14:10:05 -0700929 Paint* obj = reinterpret_cast<Paint*>(objHandle);
930 return static_cast<jint>(obj->getTextAlign());
931 }
932
Jerome Gaillard21e7e2d2019-05-14 14:34:46 +0100933 static void setTextAlign(CRITICAL_JNI_PARAMS_COMMA jlong objHandle, jint alignHandle) {
John Reckf2285972016-09-30 14:10:05 -0700934 Paint* obj = reinterpret_cast<Paint*>(objHandle);
935 Paint::Align align = static_cast<Paint::Align>(alignHandle);
936 obj->setTextAlign(align);
937 }
938
Jerome Gaillard21e7e2d2019-05-14 14:34:46 +0100939 static void setTextLocalesByMinikinLocaleListId(CRITICAL_JNI_PARAMS_COMMA jlong objHandle,
Seigo Nonaka20866c12017-10-26 16:02:01 -0700940 jint minikinLocaleListId) {
John Reckf2285972016-09-30 14:10:05 -0700941 Paint* obj = reinterpret_cast<Paint*>(objHandle);
Seigo Nonaka20866c12017-10-26 16:02:01 -0700942 obj->setMinikinLocaleListId(minikinLocaleListId);
John Reckf2285972016-09-30 14:10:05 -0700943 }
944
Seigo Nonakade05ca72023-10-23 10:48:42 +0900945 // Note: Following three values must be equal to the ones in Java file: Paint.java.
946 constexpr jint ELEGANT_TEXT_HEIGHT_UNSET = -1;
947 constexpr jint ELEGANT_TEXT_HEIGHT_ENABLED = 0;
948 constexpr jint ELEGANT_TEXT_HEIGHT_DISABLED = 1;
949
950 static jint getElegantTextHeight(CRITICAL_JNI_PARAMS_COMMA jlong paintHandle) {
John Reckf2285972016-09-30 14:10:05 -0700951 Paint* obj = reinterpret_cast<Paint*>(paintHandle);
Seigo Nonakade05ca72023-10-23 10:48:42 +0900952 const std::optional<minikin::FamilyVariant>& familyVariant = obj->getFamilyVariant();
953 if (familyVariant.has_value()) {
954 if (familyVariant.value() == minikin::FamilyVariant::ELEGANT) {
955 return ELEGANT_TEXT_HEIGHT_ENABLED;
956 } else {
957 return ELEGANT_TEXT_HEIGHT_DISABLED;
958 }
959 } else {
960 return ELEGANT_TEXT_HEIGHT_UNSET;
961 }
John Reckf2285972016-09-30 14:10:05 -0700962 }
963
Seigo Nonakade05ca72023-10-23 10:48:42 +0900964 static void setElegantTextHeight(CRITICAL_JNI_PARAMS_COMMA jlong paintHandle, jint value) {
John Reckf2285972016-09-30 14:10:05 -0700965 Paint* obj = reinterpret_cast<Paint*>(paintHandle);
Seigo Nonakade05ca72023-10-23 10:48:42 +0900966 switch (value) {
967 case ELEGANT_TEXT_HEIGHT_ENABLED:
968 obj->setFamilyVariant(minikin::FamilyVariant::ELEGANT);
969 return;
970 case ELEGANT_TEXT_HEIGHT_DISABLED:
971 obj->setFamilyVariant(minikin::FamilyVariant::DEFAULT);
972 return;
973 case ELEGANT_TEXT_HEIGHT_UNSET:
974 default:
975 obj->resetFamilyVariant();
976 return;
977 }
John Reckf2285972016-09-30 14:10:05 -0700978 }
979
Jerome Gaillard21e7e2d2019-05-14 14:34:46 +0100980 static jfloat getTextSize(CRITICAL_JNI_PARAMS_COMMA jlong paintHandle) {
Mike Reedf6d86ac2019-01-18 14:13:23 -0500981 return SkScalarToFloat(reinterpret_cast<Paint*>(paintHandle)->getSkFont().getSize());
John Reckf2285972016-09-30 14:10:05 -0700982 }
983
Jerome Gaillard21e7e2d2019-05-14 14:34:46 +0100984 static void setTextSize(CRITICAL_JNI_PARAMS_COMMA jlong paintHandle, jfloat textSize) {
Mike Reedf6d86ac2019-01-18 14:13:23 -0500985 if (textSize >= 0) {
986 reinterpret_cast<Paint*>(paintHandle)->getSkFont().setSize(textSize);
987 }
John Reckf2285972016-09-30 14:10:05 -0700988 }
989
Jerome Gaillard21e7e2d2019-05-14 14:34:46 +0100990 static jfloat getTextScaleX(CRITICAL_JNI_PARAMS_COMMA jlong paintHandle) {
Mike Reedf6d86ac2019-01-18 14:13:23 -0500991 return SkScalarToFloat(reinterpret_cast<Paint*>(paintHandle)->getSkFont().getScaleX());
John Reckf2285972016-09-30 14:10:05 -0700992 }
993
Jerome Gaillard21e7e2d2019-05-14 14:34:46 +0100994 static void setTextScaleX(CRITICAL_JNI_PARAMS_COMMA jlong paintHandle, jfloat scaleX) {
Mike Reedf6d86ac2019-01-18 14:13:23 -0500995 reinterpret_cast<Paint*>(paintHandle)->getSkFont().setScaleX(scaleX);
John Reckf2285972016-09-30 14:10:05 -0700996 }
997
Jerome Gaillard21e7e2d2019-05-14 14:34:46 +0100998 static jfloat getTextSkewX(CRITICAL_JNI_PARAMS_COMMA jlong paintHandle) {
Mike Reedf6d86ac2019-01-18 14:13:23 -0500999 return SkScalarToFloat(reinterpret_cast<Paint*>(paintHandle)->getSkFont().getSkewX());
John Reckf2285972016-09-30 14:10:05 -07001000 }
1001
Jerome Gaillard21e7e2d2019-05-14 14:34:46 +01001002 static void setTextSkewX(CRITICAL_JNI_PARAMS_COMMA jlong paintHandle, jfloat skewX) {
Mike Reedf6d86ac2019-01-18 14:13:23 -05001003 reinterpret_cast<Paint*>(paintHandle)->getSkFont().setSkewX(skewX);
John Reckf2285972016-09-30 14:10:05 -07001004 }
1005
Jerome Gaillard21e7e2d2019-05-14 14:34:46 +01001006 static jfloat getLetterSpacing(CRITICAL_JNI_PARAMS_COMMA jlong paintHandle) {
John Reckf2285972016-09-30 14:10:05 -07001007 Paint* paint = reinterpret_cast<Paint*>(paintHandle);
1008 return paint->getLetterSpacing();
1009 }
1010
Jerome Gaillard21e7e2d2019-05-14 14:34:46 +01001011 static void setLetterSpacing(CRITICAL_JNI_PARAMS_COMMA jlong paintHandle, jfloat letterSpacing) {
John Reckf2285972016-09-30 14:10:05 -07001012 Paint* paint = reinterpret_cast<Paint*>(paintHandle);
1013 paint->setLetterSpacing(letterSpacing);
1014 }
1015
Jerome Gaillard21e7e2d2019-05-14 14:34:46 +01001016 static jfloat getWordSpacing(CRITICAL_JNI_PARAMS_COMMA jlong paintHandle) {
Seigo Nonaka219e2c792016-11-15 19:01:45 +09001017 Paint* paint = reinterpret_cast<Paint*>(paintHandle);
1018 return paint->getWordSpacing();
1019 }
1020
Jerome Gaillard21e7e2d2019-05-14 14:34:46 +01001021 static void setWordSpacing(CRITICAL_JNI_PARAMS_COMMA jlong paintHandle, jfloat wordSpacing) {
Seigo Nonaka219e2c792016-11-15 19:01:45 +09001022 Paint* paint = reinterpret_cast<Paint*>(paintHandle);
1023 paint->setWordSpacing(wordSpacing);
1024 }
1025
Jerome Gaillard21e7e2d2019-05-14 14:34:46 +01001026 static jint getStartHyphenEdit(CRITICAL_JNI_PARAMS_COMMA jlong paintHandle, jint hyphen) {
John Reckf2285972016-09-30 14:10:05 -07001027 Paint* paint = reinterpret_cast<Paint*>(paintHandle);
Seigo Nonakafb1b4792019-03-08 14:05:08 -08001028 return static_cast<jint>(paint->getStartHyphenEdit());
John Reckf2285972016-09-30 14:10:05 -07001029 }
1030
Jerome Gaillard21e7e2d2019-05-14 14:34:46 +01001031 static jint getEndHyphenEdit(CRITICAL_JNI_PARAMS_COMMA jlong paintHandle, jint hyphen) {
John Reckf2285972016-09-30 14:10:05 -07001032 Paint* paint = reinterpret_cast<Paint*>(paintHandle);
Seigo Nonakafb1b4792019-03-08 14:05:08 -08001033 return static_cast<jint>(paint->getEndHyphenEdit());
1034 }
1035
Jerome Gaillard21e7e2d2019-05-14 14:34:46 +01001036 static void setStartHyphenEdit(CRITICAL_JNI_PARAMS_COMMA jlong paintHandle, jint hyphen) {
Seigo Nonakafb1b4792019-03-08 14:05:08 -08001037 Paint* paint = reinterpret_cast<Paint*>(paintHandle);
1038 paint->setStartHyphenEdit((uint32_t)hyphen);
1039 }
1040
Jerome Gaillard21e7e2d2019-05-14 14:34:46 +01001041 static void setEndHyphenEdit(CRITICAL_JNI_PARAMS_COMMA jlong paintHandle, jint hyphen) {
Seigo Nonakafb1b4792019-03-08 14:05:08 -08001042 Paint* paint = reinterpret_cast<Paint*>(paintHandle);
1043 paint->setEndHyphenEdit((uint32_t)hyphen);
John Reckf2285972016-09-30 14:10:05 -07001044 }
1045
Jerome Gaillard21e7e2d2019-05-14 14:34:46 +01001046 static jfloat ascent(CRITICAL_JNI_PARAMS_COMMA jlong paintHandle) {
Mike Reedda3488a2018-12-14 12:08:55 -05001047 SkFontMetrics metrics;
Seigo Nonaka59a0baf2023-10-06 15:59:28 +09001048 getMetricsInternal(paintHandle, &metrics, false /* useLocale */);
John Reckf2285972016-09-30 14:10:05 -07001049 return SkScalarToFloat(metrics.fAscent);
1050 }
1051
Jerome Gaillard21e7e2d2019-05-14 14:34:46 +01001052 static jfloat descent(CRITICAL_JNI_PARAMS_COMMA jlong paintHandle) {
Mike Reedda3488a2018-12-14 12:08:55 -05001053 SkFontMetrics metrics;
Seigo Nonaka59a0baf2023-10-06 15:59:28 +09001054 getMetricsInternal(paintHandle, &metrics, false /* useLocale */);
John Reckf2285972016-09-30 14:10:05 -07001055 return SkScalarToFloat(metrics.fDescent);
1056 }
1057
Jerome Gaillard21e7e2d2019-05-14 14:34:46 +01001058 static jfloat getUnderlinePosition(CRITICAL_JNI_PARAMS_COMMA jlong paintHandle) {
Mike Reedda3488a2018-12-14 12:08:55 -05001059 SkFontMetrics metrics;
Seigo Nonaka59a0baf2023-10-06 15:59:28 +09001060 getMetricsInternal(paintHandle, &metrics, false /* useLocale */);
Roozbeh Pournaderca8a04a2017-06-06 18:30:29 -07001061 SkScalar position;
1062 if (metrics.hasUnderlinePosition(&position)) {
1063 return SkScalarToFloat(position);
1064 } else {
Mike Reedf6d86ac2019-01-18 14:13:23 -05001065 const SkScalar textSize = reinterpret_cast<Paint*>(paintHandle)->getSkFont().getSize();
Roozbeh Pournaderca8a04a2017-06-06 18:30:29 -07001066 return SkScalarToFloat(Paint::kStdUnderline_Top * textSize);
1067 }
1068 }
1069
Jerome Gaillard21e7e2d2019-05-14 14:34:46 +01001070 static jfloat getUnderlineThickness(CRITICAL_JNI_PARAMS_COMMA jlong paintHandle) {
Mike Reedda3488a2018-12-14 12:08:55 -05001071 SkFontMetrics metrics;
Seigo Nonaka59a0baf2023-10-06 15:59:28 +09001072 getMetricsInternal(paintHandle, &metrics, false /* useLocale */);
Roozbeh Pournaderca8a04a2017-06-06 18:30:29 -07001073 SkScalar thickness;
1074 if (metrics.hasUnderlineThickness(&thickness)) {
1075 return SkScalarToFloat(thickness);
1076 } else {
Mike Reedf6d86ac2019-01-18 14:13:23 -05001077 const SkScalar textSize = reinterpret_cast<Paint*>(paintHandle)->getSkFont().getSize();
Roozbeh Pournaderca8a04a2017-06-06 18:30:29 -07001078 return SkScalarToFloat(Paint::kStdUnderline_Thickness * textSize);
1079 }
1080 }
1081
Jerome Gaillard21e7e2d2019-05-14 14:34:46 +01001082 static jfloat getStrikeThruPosition(CRITICAL_JNI_PARAMS_COMMA jlong paintHandle) {
Mike Reedf6d86ac2019-01-18 14:13:23 -05001083 const SkScalar textSize = reinterpret_cast<Paint*>(paintHandle)->getSkFont().getSize();
Roozbeh Pournader1378a9d2017-07-13 12:45:20 -07001084 return SkScalarToFloat(Paint::kStdStrikeThru_Top * textSize);
1085 }
1086
Jerome Gaillard21e7e2d2019-05-14 14:34:46 +01001087 static jfloat getStrikeThruThickness(CRITICAL_JNI_PARAMS_COMMA jlong paintHandle) {
Mike Reedf6d86ac2019-01-18 14:13:23 -05001088 const SkScalar textSize = reinterpret_cast<Paint*>(paintHandle)->getSkFont().getSize();
Roozbeh Pournader1378a9d2017-07-13 12:45:20 -07001089 return SkScalarToFloat(Paint::kStdStrikeThru_Thickness * textSize);
1090 }
1091
Jerome Gaillard21e7e2d2019-05-14 14:34:46 +01001092 static void setShadowLayer(CRITICAL_JNI_PARAMS_COMMA jlong paintHandle, jfloat radius,
Leon Scroggins III0e443d12018-12-19 11:38:35 -05001093 jfloat dx, jfloat dy, jlong colorSpaceHandle,
Leon Scroggins III10965f32019-03-12 11:13:27 -04001094 jlong colorLong) {
1095 SkColor4f color = GraphicsJNI::convertColorLong(colorLong);
Leon Scroggins III0e443d12018-12-19 11:38:35 -05001096 sk_sp<SkColorSpace> cs = GraphicsJNI::getNativeColorSpace(colorSpaceHandle);
Leon Scroggins III0e443d12018-12-19 11:38:35 -05001097
1098 Paint* paint = reinterpret_cast<Paint*>(paintHandle);
1099 if (radius <= 0) {
1100 paint->setLooper(nullptr);
1101 }
1102 else {
1103 SkScalar sigma = android::uirenderer::Blur::convertRadiusToSigma(radius);
Mike Reed0f9dce72021-02-12 21:20:33 -05001104 paint->setLooper(BlurDrawLooper::Make(color, cs.get(), sigma, {dx, dy}));
Leon Scroggins III0e443d12018-12-19 11:38:35 -05001105 }
1106 }
1107
Jerome Gaillard21e7e2d2019-05-14 14:34:46 +01001108 static jboolean hasShadowLayer(CRITICAL_JNI_PARAMS_COMMA jlong paintHandle) {
John Reckf2285972016-09-30 14:10:05 -07001109 Paint* paint = reinterpret_cast<Paint*>(paintHandle);
Mike Reed0f9dce72021-02-12 21:20:33 -05001110 return paint->getLooper() != nullptr;
John Reckf2285972016-09-30 14:10:05 -07001111 }
1112
Jerome Gaillard21e7e2d2019-05-14 14:34:46 +01001113 static jboolean equalsForTextMeasurement(CRITICAL_JNI_PARAMS_COMMA jlong lPaint, jlong rPaint) {
Seigo Nonakabeafa1f2018-02-01 21:39:24 -08001114 if (lPaint == rPaint) {
1115 return true;
1116 }
1117 Paint* leftPaint = reinterpret_cast<Paint*>(lPaint);
1118 Paint* rightPaint = reinterpret_cast<Paint*>(rPaint);
1119
1120 const Typeface* leftTypeface = Typeface::resolveDefault(leftPaint->getAndroidTypeface());
1121 const Typeface* rightTypeface = Typeface::resolveDefault(rightPaint->getAndroidTypeface());
1122 minikin::MinikinPaint leftMinikinPaint
1123 = MinikinUtils::prepareMinikinPaint(leftPaint, leftTypeface);
1124 minikin::MinikinPaint rightMinikinPaint
1125 = MinikinUtils::prepareMinikinPaint(rightPaint, rightTypeface);
1126
1127 return leftMinikinPaint == rightMinikinPaint;
1128 }
1129
John Reckdbffd252015-10-01 14:46:12 -07001130}; // namespace PaintGlue
The Android Open Source Project9066cfe2009-03-03 19:31:44 -08001131
Daniel Micay76f6a862015-09-19 17:31:01 -04001132static const JNINativeMethod methods[] = {
Haoyu Zhangc8abba42022-06-23 10:29:24 -07001133 {"nGetNativeFinalizer", "()J", (void*)PaintGlue::getNativeFinalizer},
1134 {"nInit", "()J", (void*)PaintGlue::init},
1135 {"nInitWithPaint", "(J)J", (void*)PaintGlue::initWithPaint},
1136 {"nBreakText", "(J[CIIFI[F)I", (void*)PaintGlue::breakTextC},
1137 {"nBreakText", "(JLjava/lang/String;ZFI[F)I", (void*)PaintGlue::breakTextS},
1138 {"nGetTextAdvances", "(J[CIIIII[FI)F", (void*)PaintGlue::getTextAdvances___CIIIII_FI},
1139 {"nGetTextAdvances", "(JLjava/lang/String;IIIII[FI)F",
1140 (void*)PaintGlue::getTextAdvances__StringIIIII_FI},
Fabrice Di Meglioda12f382013-03-15 11:26:56 -07001141
Haoyu Zhangc8abba42022-06-23 10:29:24 -07001142 {"nGetTextRunCursor", "(J[CIIIII)I", (void*)PaintGlue::getTextRunCursor___C},
1143 {"nGetTextRunCursor", "(JLjava/lang/String;IIIII)I",
1144 (void*)PaintGlue::getTextRunCursor__String},
1145 {"nGetTextPath", "(JI[CIIFFJ)V", (void*)PaintGlue::getTextPath___C},
1146 {"nGetTextPath", "(JILjava/lang/String;IIFFJ)V", (void*)PaintGlue::getTextPath__String},
1147 {"nGetStringBounds", "(JLjava/lang/String;IIILandroid/graphics/Rect;)V",
1148 (void*)PaintGlue::getStringBounds},
1149 {"nGetCharArrayBounds", "(J[CIIILandroid/graphics/Rect;)V",
1150 (void*)PaintGlue::getCharArrayBounds},
1151 {"nHasGlyph", "(JILjava/lang/String;)Z", (void*)PaintGlue::hasGlyph},
1152 {"nGetRunAdvance", "(J[CIIIIZI)F", (void*)PaintGlue::getRunAdvance___CIIIIZI_F},
Seigo Nonakadd617182023-12-07 08:56:31 +09001153 {"nGetRunCharacterAdvance",
1154 "(J[CIIIIZI[FILandroid/graphics/RectF;Landroid/graphics/Paint$RunInfo;)F",
Haoyu Zhangc8abba42022-06-23 10:29:24 -07001155 (void*)PaintGlue::getRunCharacterAdvance___CIIIIZI_FI_F},
1156 {"nGetOffsetForAdvance", "(J[CIIIIZF)I", (void*)PaintGlue::getOffsetForAdvance___CIIIIZF_I},
1157 {"nGetFontMetricsIntForText", "(J[CIIIIZLandroid/graphics/Paint$FontMetricsInt;)V",
1158 (void*)PaintGlue::getFontMetricsIntForText___C},
1159 {"nGetFontMetricsIntForText",
1160 "(JLjava/lang/String;IIIIZLandroid/graphics/Paint$FontMetricsInt;)V",
1161 (void*)PaintGlue::getFontMetricsIntForText___String},
Chris Craik4136a0a2014-10-07 15:09:46 -07001162
Haoyu Zhangc8abba42022-06-23 10:29:24 -07001163 // --------------- @FastNative ----------------------
John Reckf2285972016-09-30 14:10:05 -07001164
Haoyu Zhangc8abba42022-06-23 10:29:24 -07001165 {"nSetTextLocales", "(JLjava/lang/String;)I", (void*)PaintGlue::setTextLocales},
1166 {"nSetFontFeatureSettings", "(JLjava/lang/String;)V",
1167 (void*)PaintGlue::setFontFeatureSettings},
Seigo Nonaka59a0baf2023-10-06 15:59:28 +09001168 {"nGetFontMetrics", "(JLandroid/graphics/Paint$FontMetrics;Z)F",
Haoyu Zhangc8abba42022-06-23 10:29:24 -07001169 (void*)PaintGlue::getFontMetrics},
Seigo Nonaka59a0baf2023-10-06 15:59:28 +09001170 {"nGetFontMetricsInt", "(JLandroid/graphics/Paint$FontMetricsInt;Z)I",
Haoyu Zhangc8abba42022-06-23 10:29:24 -07001171 (void*)PaintGlue::getFontMetricsInt},
John Reckf2285972016-09-30 14:10:05 -07001172
Haoyu Zhangc8abba42022-06-23 10:29:24 -07001173 // --------------- @CriticalNative ------------------
John Reckf2285972016-09-30 14:10:05 -07001174
Haoyu Zhangc8abba42022-06-23 10:29:24 -07001175 {"nReset", "(J)V", (void*)PaintGlue::reset},
1176 {"nSet", "(JJ)V", (void*)PaintGlue::assign},
1177 {"nGetFlags", "(J)I", (void*)PaintGlue::getFlags},
1178 {"nSetFlags", "(JI)V", (void*)PaintGlue::setFlags},
1179 {"nGetHinting", "(J)I", (void*)PaintGlue::getHinting},
1180 {"nSetHinting", "(JI)V", (void*)PaintGlue::setHinting},
1181 {"nSetAntiAlias", "(JZ)V", (void*)PaintGlue::setAntiAlias},
1182 {"nSetSubpixelText", "(JZ)V", (void*)PaintGlue::setSubpixelText},
1183 {"nSetLinearText", "(JZ)V", (void*)PaintGlue::setLinearText},
1184 {"nSetUnderlineText", "(JZ)V", (void*)PaintGlue::setUnderlineText},
1185 {"nSetStrikeThruText", "(JZ)V", (void*)PaintGlue::setStrikeThruText},
1186 {"nSetFakeBoldText", "(JZ)V", (void*)PaintGlue::setFakeBoldText},
1187 {"nSetFilterBitmap", "(JZ)V", (void*)PaintGlue::setFilterBitmap},
1188 {"nSetDither", "(JZ)V", (void*)PaintGlue::setDither},
1189 {"nGetStyle", "(J)I", (void*)PaintGlue::getStyle},
1190 {"nSetStyle", "(JI)V", (void*)PaintGlue::setStyle},
1191 {"nSetColor", "(JI)V", (void*)PaintGlue::setColor},
1192 {"nSetColor", "(JJJ)V", (void*)PaintGlue::setColorLong},
1193 {"nSetAlpha", "(JI)V", (void*)PaintGlue::setAlpha},
1194 {"nGetStrokeWidth", "(J)F", (void*)PaintGlue::getStrokeWidth},
1195 {"nSetStrokeWidth", "(JF)V", (void*)PaintGlue::setStrokeWidth},
1196 {"nGetStrokeMiter", "(J)F", (void*)PaintGlue::getStrokeMiter},
1197 {"nSetStrokeMiter", "(JF)V", (void*)PaintGlue::setStrokeMiter},
1198 {"nGetStrokeCap", "(J)I", (void*)PaintGlue::getStrokeCap},
1199 {"nSetStrokeCap", "(JI)V", (void*)PaintGlue::setStrokeCap},
1200 {"nGetStrokeJoin", "(J)I", (void*)PaintGlue::getStrokeJoin},
1201 {"nSetStrokeJoin", "(JI)V", (void*)PaintGlue::setStrokeJoin},
1202 {"nGetFillPath", "(JJJ)Z", (void*)PaintGlue::getFillPath},
1203 {"nSetShader", "(JJ)J", (void*)PaintGlue::setShader},
1204 {"nSetColorFilter", "(JJ)J", (void*)PaintGlue::setColorFilter},
1205 {"nSetXfermode", "(JI)V", (void*)PaintGlue::setXfermode},
1206 {"nSetPathEffect", "(JJ)J", (void*)PaintGlue::setPathEffect},
1207 {"nSetMaskFilter", "(JJ)J", (void*)PaintGlue::setMaskFilter},
1208 {"nSetTypeface", "(JJ)V", (void*)PaintGlue::setTypeface},
1209 {"nGetTextAlign", "(J)I", (void*)PaintGlue::getTextAlign},
1210 {"nSetTextAlign", "(JI)V", (void*)PaintGlue::setTextAlign},
1211 {"nSetTextLocalesByMinikinLocaleListId", "(JI)V",
1212 (void*)PaintGlue::setTextLocalesByMinikinLocaleListId},
Seigo Nonakade05ca72023-10-23 10:48:42 +09001213 {"nGetElegantTextHeight", "(J)I", (void*)PaintGlue::getElegantTextHeight},
1214 {"nSetElegantTextHeight", "(JI)V", (void*)PaintGlue::setElegantTextHeight},
Haoyu Zhangc8abba42022-06-23 10:29:24 -07001215 {"nGetTextSize", "(J)F", (void*)PaintGlue::getTextSize},
1216 {"nSetTextSize", "(JF)V", (void*)PaintGlue::setTextSize},
1217 {"nGetTextScaleX", "(J)F", (void*)PaintGlue::getTextScaleX},
1218 {"nSetTextScaleX", "(JF)V", (void*)PaintGlue::setTextScaleX},
1219 {"nGetTextSkewX", "(J)F", (void*)PaintGlue::getTextSkewX},
1220 {"nSetTextSkewX", "(JF)V", (void*)PaintGlue::setTextSkewX},
1221 {"nGetLetterSpacing", "(J)F", (void*)PaintGlue::getLetterSpacing},
1222 {"nSetLetterSpacing", "(JF)V", (void*)PaintGlue::setLetterSpacing},
1223 {"nGetWordSpacing", "(J)F", (void*)PaintGlue::getWordSpacing},
1224 {"nSetWordSpacing", "(JF)V", (void*)PaintGlue::setWordSpacing},
1225 {"nGetStartHyphenEdit", "(J)I", (void*)PaintGlue::getStartHyphenEdit},
1226 {"nGetEndHyphenEdit", "(J)I", (void*)PaintGlue::getEndHyphenEdit},
1227 {"nSetStartHyphenEdit", "(JI)V", (void*)PaintGlue::setStartHyphenEdit},
1228 {"nSetEndHyphenEdit", "(JI)V", (void*)PaintGlue::setEndHyphenEdit},
1229 {"nAscent", "(J)F", (void*)PaintGlue::ascent},
1230 {"nDescent", "(J)F", (void*)PaintGlue::descent},
1231 {"nGetUnderlinePosition", "(J)F", (void*)PaintGlue::getUnderlinePosition},
1232 {"nGetUnderlineThickness", "(J)F", (void*)PaintGlue::getUnderlineThickness},
1233 {"nGetStrikeThruPosition", "(J)F", (void*)PaintGlue::getStrikeThruPosition},
1234 {"nGetStrikeThruThickness", "(J)F", (void*)PaintGlue::getStrikeThruThickness},
1235 {"nSetShadowLayer", "(JFFFJJ)V", (void*)PaintGlue::setShadowLayer},
1236 {"nHasShadowLayer", "(J)Z", (void*)PaintGlue::hasShadowLayer},
1237 {"nEqualsForTextMeasurement", "(JJ)Z", (void*)PaintGlue::equalsForTextMeasurement},
The Android Open Source Project9066cfe2009-03-03 19:31:44 -08001238};
1239
The Android Open Source Project9066cfe2009-03-03 19:31:44 -08001240int register_android_graphics_Paint(JNIEnv* env) {
Andreas Gampeed6b9df2014-11-20 22:02:20 -08001241 return RegisterMethodsOrDie(env, "android/graphics/Paint", methods, NELEM(methods));
The Android Open Source Project9066cfe2009-03-03 19:31:44 -08001242}
1243
1244}