giteadmin/script-astra
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
master
script-astra/Android/Sdk/sources/android-35/android/graphics/Paint.java

3849 lines
147 KiB
Java
Raw Permalink Normal View History

init
2025-01-20 15:15:20 +00:00
/*
* Copyright (C) 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.
*/
package android.graphics;
import static com.android.text.flags.Flags.FLAG_FIX_LINE_HEIGHT_FOR_LOCALE;
import static com.android.text.flags.Flags.FLAG_LETTER_SPACING_JUSTIFICATION;
import android.annotation.ColorInt;
import android.annotation.ColorLong;
import android.annotation.FlaggedApi;
import android.annotation.IntDef;
import android.annotation.IntRange;
import android.annotation.NonNull;
import android.annotation.Nullable;
import android.annotation.Px;
import android.annotation.Size;
import android.app.compat.CompatChanges;
import android.compat.annotation.ChangeId;
import android.compat.annotation.EnabledSince;
import android.compat.annotation.UnsupportedAppUsage;
import android.graphics.fonts.FontVariationAxis;
import android.os.Build;
import android.os.LocaleList;
import android.text.GraphicsOperations;
import android.text.SpannableString;
import android.text.SpannedString;
import android.text.TextUtils;
import com.android.internal.annotations.GuardedBy;
import dalvik.annotation.optimization.CriticalNative;
import dalvik.annotation.optimization.FastNative;
import libcore.util.NativeAllocationRegistry;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.Locale;
import java.util.Objects;
/**
* The Paint class holds the style and color information about how to draw
* geometries, text and bitmaps.
*/
public class Paint {
@UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.R, trackingBug = 170729553)
private long mNativePaint;
private long mNativeShader;
private long mNativeColorFilter;
// Use a Holder to allow static initialization of Paint in the boot image.
private static class NoImagePreloadHolder {
public static final NativeAllocationRegistry sRegistry =
NativeAllocationRegistry.createMalloced(
Paint.class.getClassLoader(), nGetNativeFinalizer());
}
@ColorLong private long mColor;
private ColorFilter mColorFilter;
private MaskFilter mMaskFilter;
private PathEffect mPathEffect;
private Shader mShader;
@UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.P, trackingBug = 115609023)
private Typeface mTypeface;
private Xfermode mXfermode;
private boolean mHasCompatScaling;
private float mCompatScaling;
private float mInvCompatScaling;
private LocaleList mLocales;
private String mFontFeatureSettings;
private String mFontVariationSettings;
private float mShadowLayerRadius;
private float mShadowLayerDx;
private float mShadowLayerDy;
@ColorLong private long mShadowLayerColor;
private static final Object sCacheLock = new Object();
/**
* Cache for the Minikin language list ID.
*
* A map from a string representation of the LocaleList to Minikin's language list ID.
*/
@GuardedBy("sCacheLock")
private static final HashMap<String, Integer> sMinikinLocaleListIdCache = new HashMap<>();
/**
* @hide
*/
public int mBidiFlags = BIDI_DEFAULT_LTR;
static final Style[] sStyleArray = {
Style.FILL, Style.STROKE, Style.FILL_AND_STROKE
};
static final Cap[] sCapArray = {
Cap.BUTT, Cap.ROUND, Cap.SQUARE
};
static final Join[] sJoinArray = {
Join.MITER, Join.ROUND, Join.BEVEL
};
static final Align[] sAlignArray = {
Align.LEFT, Align.CENTER, Align.RIGHT
};
/** @hide */
@Retention(RetentionPolicy.SOURCE)
@IntDef(flag = true, value = {
ANTI_ALIAS_FLAG,
FILTER_BITMAP_FLAG,
DITHER_FLAG,
UNDERLINE_TEXT_FLAG,
STRIKE_THRU_TEXT_FLAG,
FAKE_BOLD_TEXT_FLAG,
LINEAR_TEXT_FLAG,
SUBPIXEL_TEXT_FLAG,
EMBEDDED_BITMAP_TEXT_FLAG,
TEXT_RUN_FLAG_LEFT_EDGE,
TEXT_RUN_FLAG_RIGHT_EDGE
})
public @interface PaintFlag{}
/**
* Paint flag that enables antialiasing when drawing.
*
* <p>Enabling this flag will cause all draw operations that support
* antialiasing to use it.</p>
*
* <p>Notable draw operations that do <b>not</b> support antialiasing include:</p>
* <ul>
* <li>{@link android.graphics.Canvas#drawBitmapMesh}</li>
* <li>{@link android.graphics.Canvas#drawPatch}</li>
* <li>{@link android.graphics.Canvas#drawVertices}</li>
* </ul>
*
* @see #Paint(int)
* @see #setFlags(int)
*/
public static final int ANTI_ALIAS_FLAG = 0x01;
/**
* Paint flag that enables bilinear sampling on scaled bitmaps.
*
* <p>If cleared, scaled bitmaps will be drawn with nearest neighbor
* sampling, likely resulting in artifacts. This should generally be on
* when drawing bitmaps, unless performance-bound (rendering to software
* canvas) or preferring pixelation artifacts to blurriness when scaling
* significantly.</p>
*
* <p>If bitmaps are scaled for device density at creation time (as
* resource bitmaps often are) the filtering will already have been
* done.</p>
*
* <p>On devices running {@link Build.VERSION_CODES#O} and below, hardware
* accelerated drawing always uses bilinear sampling on scaled bitmaps,
* regardless of this flag. On devices running {@link Build.VERSION_CODES#Q}
* and above, this flag defaults to being set on a new {@code Paint}. It can
* be cleared with {@link #setFlags} or {@link #setFilterBitmap}.</p>
*
* @see #Paint()
* @see #Paint(int)
* @see #setFlags(int)
*/
public static final int FILTER_BITMAP_FLAG = 0x02;
/**
* Paint flag that enables dithering when blitting.
*
* <p>Enabling this flag applies a dither to any blit operation where the
* target's colour space is more constrained than the source.
*
* @see #Paint(int)
* @see #setFlags(int)
*/
public static final int DITHER_FLAG = 0x04;
/**
* Paint flag that applies an underline decoration to drawn text.
*
* @see #Paint(int)
* @see #setFlags(int)
*/
public static final int UNDERLINE_TEXT_FLAG = 0x08;
/**
* Paint flag that applies a strike-through decoration to drawn text.
*
* @see #Paint(int)
* @see #setFlags(int)
*/
public static final int STRIKE_THRU_TEXT_FLAG = 0x10;
/**
* Paint flag that applies a synthetic bolding effect to drawn text.
*
* <p>Enabling this flag will cause text draw operations to apply a
* simulated bold effect when drawing a {@link Typeface} that is not
* already bold.</p>
*
* @see #Paint(int)
* @see #setFlags(int)
*/
public static final int FAKE_BOLD_TEXT_FLAG = 0x20;
/**
* Paint flag that enables smooth linear scaling of text.
*
* <p>Enabling this flag does not actually scale text, but rather adjusts
* text draw operations to deal gracefully with smooth adjustment of scale.
* When this flag is enabled, font hinting is disabled to prevent shape
* deformation between scale factors, and glyph caching is disabled due to
* the large number of glyph images that will be generated.</p>
*
* <p>{@link #SUBPIXEL_TEXT_FLAG} should be used in conjunction with this
* flag to prevent glyph positions from snapping to whole pixel values as
* scale factor is adjusted.</p>
*
* @see #Paint(int)
* @see #setFlags(int)
*/
public static final int LINEAR_TEXT_FLAG = 0x40;
/**
* Paint flag that enables subpixel positioning of text.
*
* <p>Enabling this flag causes glyph advances to be computed with subpixel
* accuracy.</p>
*
* <p>This can be used with {@link #LINEAR_TEXT_FLAG} to prevent text from
* jittering during smooth scale transitions.</p>
*
* @see #Paint(int)
* @see #setFlags(int)
*/
public static final int SUBPIXEL_TEXT_FLAG = 0x80;
/** Legacy Paint flag, no longer used. */
public static final int DEV_KERN_TEXT_FLAG = 0x100;
/** @hide bit mask for the flag enabling subpixel glyph rendering for text */
public static final int LCD_RENDER_TEXT_FLAG = 0x200;
/**
* Paint flag that enables the use of bitmap fonts when drawing text.
*
* <p>Disabling this flag will prevent text draw operations from using
* embedded bitmap strikes in fonts, causing fonts with both scalable
* outlines and bitmap strikes to draw only the scalable outlines, and
* fonts with only bitmap strikes to not draw at all.</p>
*
* @see #Paint(int)
* @see #setFlags(int)
*/
public static final int EMBEDDED_BITMAP_TEXT_FLAG = 0x400;
/** @hide bit mask for the flag forcing freetype's autohinter on for text */
public static final int AUTO_HINTING_TEXT_FLAG = 0x800;
/** @hide bit mask for the flag enabling vertical rendering for text */
public static final int VERTICAL_TEXT_FLAG = 0x1000;
/**
* A text run flag that indicates the run is located the visually most left segment of the line.
* <p>
* This flag is used for telling the underlying text layout engine that the text is located at
* the most left of the line. This flag is used for controlling the amount letter spacing
* added. If the text is in the middle of the line, the text layout engine assigns additional
* letter spacing to the both side of each letter. On the other hand, the letter spacing should
* not be added to the visually most left and right of the line. By setting this flag, text
* layout engine calculates the layout as it is located at the most visually left of the line
* and doesn't add letter spacing to the left of this run.
* <p>
* Note that the caller must resolve BiDi runs and reorder them visually and set this flag only
* if the target run is located visually most left position. This left does not always mean the
* beginning of the text.
* <p>
* If the run covers entire line, caller should set {@link #TEXT_RUN_FLAG_RIGHT_EDGE} as well.
* <p>
* Note that this flag is only effective for run based APIs. For example, this flag works for
* {@link Canvas#drawTextRun(CharSequence, int, int, int, int, float, float, boolean, Paint)}
* and
* {@link Paint#getRunCharacterAdvance(char[], int, int, int, int, boolean, int, float[], int)}.
* However, this doesn't work for
* {@link Canvas#drawText(CharSequence, int, int, float, float, Paint)} or
* {@link Paint#measureText(CharSequence, int, int)}. The non-run based APIs works as both
* {@link #TEXT_RUN_FLAG_LEFT_EDGE} and {@link #TEXT_RUN_FLAG_RIGHT_EDGE} are specified.
*/
@FlaggedApi(FLAG_LETTER_SPACING_JUSTIFICATION)
public static final int TEXT_RUN_FLAG_LEFT_EDGE = 0x2000;
/**
* A text run flag that indicates the run is located the visually most right segment of the
* line.
* <p>
* This flag is used for telling the underlying text layout engine that the text is located at
* the most right of the line. This flag is used for controlling the amount letter spacing
* added. If the text is in the middle of the line, the text layout engine assigns additional
* letter spacing to the both side of each letter. On the other hand, the letter spacing should
* not be added to the visually most left and right of the line. By setting this flag, text
* layout engine calculates the layout as it is located at the most visually left of the line
* and doesn't add letter spacing to the left of this run.
* <p>
* Note that the caller must resolve BiDi runs and reorder them visually and set this flag only
* if the target run is located visually most right position. This right does not always mean
* the end of the text.
* <p>
* If the run covers entire line, caller should set {@link #TEXT_RUN_FLAG_LEFT_EDGE} as well.
* <p>
* Note that this flag is only effective for run based APIs. For example, this flag works for
* {@link Canvas#drawTextRun(CharSequence, int, int, int, int, float, float, boolean, Paint)}
* and
* {@link Paint#getRunCharacterAdvance(char[], int, int, int, int, boolean, int, float[], int)}.
* However, this doesn't work for
* {@link Canvas#drawText(CharSequence, int, int, float, float, Paint)} or
* {@link Paint#measureText(CharSequence, int, int)}. The non-run based APIs works as both
* {@link #TEXT_RUN_FLAG_LEFT_EDGE} and {@link #TEXT_RUN_FLAG_RIGHT_EDGE} are specified.
*/
@FlaggedApi(FLAG_LETTER_SPACING_JUSTIFICATION)
public static final int TEXT_RUN_FLAG_RIGHT_EDGE = 0x4000;
// These flags are always set on a new/reset paint, even if flags 0 is passed.
static final int HIDDEN_DEFAULT_PAINT_FLAGS = DEV_KERN_TEXT_FLAG | EMBEDDED_BITMAP_TEXT_FLAG
| FILTER_BITMAP_FLAG;
/**
* Font hinter option that disables font hinting.
*
* @see #setHinting(int)
*/
public static final int HINTING_OFF = 0x0;
/**
* Font hinter option that enables font hinting.
*
* @see #setHinting(int)
*/
public static final int HINTING_ON = 0x1;
/**
* Bidi flag to set LTR paragraph direction.
*
* @hide
*/
public static final int BIDI_LTR = 0x0;
/**
* Bidi flag to set RTL paragraph direction.
*
* @hide
*/
public static final int BIDI_RTL = 0x1;
/**
* Bidi flag to detect paragraph direction via heuristics, defaulting to
* LTR.
*
* @hide
*/
public static final int BIDI_DEFAULT_LTR = 0x2;
/**
* Bidi flag to detect paragraph direction via heuristics, defaulting to
* RTL.
*
* @hide
*/
public static final int BIDI_DEFAULT_RTL = 0x3;
/**
* Bidi flag to override direction to all LTR (ignore bidi).
*
* @hide
*/
public static final int BIDI_FORCE_LTR = 0x4;
/**
* Bidi flag to override direction to all RTL (ignore bidi).
*
* @hide
*/
public static final int BIDI_FORCE_RTL = 0x5;
/**
* Maximum Bidi flag value.
* @hide
*/
private static final int BIDI_MAX_FLAG_VALUE = BIDI_FORCE_RTL;
/**
* Mask for bidi flags.
* @hide
*/
private static final int BIDI_FLAG_MASK = 0x7;
/**
* Flag for getTextRunAdvances indicating left-to-right run direction.
* @hide
*/
public static final int DIRECTION_LTR = 0;
/**
* Flag for getTextRunAdvances indicating right-to-left run direction.
* @hide
*/
public static final int DIRECTION_RTL = 1;
/** @hide */
@IntDef(prefix = { "CURSOR_" }, value = {
CURSOR_AFTER, CURSOR_AT_OR_AFTER, CURSOR_BEFORE, CURSOR_AT_OR_BEFORE
})
@Retention(RetentionPolicy.SOURCE)
public @interface CursorOption {}
/**
* Option for getTextRunCursor.
*
* Compute the valid cursor after offset or the limit of the context, whichever is less.
*/
public static final int CURSOR_AFTER = 0;
/**
* Option for getTextRunCursor.
*
* Compute the valid cursor at or after the offset or the limit of the context, whichever is
* less.
*/
public static final int CURSOR_AT_OR_AFTER = 1;
/**
* Option for getTextRunCursor.
*
* Compute the valid cursor before offset or the start of the context, whichever is greater.
*/
public static final int CURSOR_BEFORE = 2;
/**
* Option for getTextRunCursor.
*
* Compute the valid cursor at or before offset or the start of the context, whichever is
* greater.
*/
public static final int CURSOR_AT_OR_BEFORE = 3;
/**
* Option for getTextRunCursor.
*
* Return offset if the cursor at offset is valid, or -1 if it isn't.
*/
public static final int CURSOR_AT = 4;
/**
* Maximum cursor option value.
*/
private static final int CURSOR_OPT_MAX_VALUE = CURSOR_AT;
/** @hide */
@IntDef(prefix = { "START_HYPHEN_EDIT_" }, value = {
START_HYPHEN_EDIT_NO_EDIT,
START_HYPHEN_EDIT_INSERT_HYPHEN,
START_HYPHEN_EDIT_INSERT_ZWJ
})
@Retention(RetentionPolicy.SOURCE)
public @interface StartHyphenEdit {}
/**
* An integer representing the starting of the line has no modification for hyphenation.
*/
public static final int START_HYPHEN_EDIT_NO_EDIT = 0x00;
/**
* An integer representing the starting of the line has normal hyphen character (U+002D).
*/
public static final int START_HYPHEN_EDIT_INSERT_HYPHEN = 0x01;
/**
* An integer representing the starting of the line has Zero-Width-Joiner (U+200D).
*/
public static final int START_HYPHEN_EDIT_INSERT_ZWJ = 0x02;
/** @hide */
@IntDef(prefix = { "END_HYPHEN_EDIT_" }, value = {
END_HYPHEN_EDIT_NO_EDIT,
END_HYPHEN_EDIT_REPLACE_WITH_HYPHEN,
END_HYPHEN_EDIT_INSERT_HYPHEN,
END_HYPHEN_EDIT_INSERT_ARMENIAN_HYPHEN,
END_HYPHEN_EDIT_INSERT_MAQAF,
END_HYPHEN_EDIT_INSERT_UCAS_HYPHEN,
END_HYPHEN_EDIT_INSERT_ZWJ_AND_HYPHEN
})
@Retention(RetentionPolicy.SOURCE)
public @interface EndHyphenEdit {}
/**
* An integer representing the end of the line has no modification for hyphenation.
*/
public static final int END_HYPHEN_EDIT_NO_EDIT = 0x00;
/**
* An integer representing the character at the end of the line is replaced with hyphen
* character (U+002D).
*/
public static final int END_HYPHEN_EDIT_REPLACE_WITH_HYPHEN = 0x01;
/**
* An integer representing the end of the line has normal hyphen character (U+002D).
*/
public static final int END_HYPHEN_EDIT_INSERT_HYPHEN = 0x02;
/**
* An integer representing the end of the line has Armentian hyphen (U+058A).
*/
public static final int END_HYPHEN_EDIT_INSERT_ARMENIAN_HYPHEN = 0x03;
/**
* An integer representing the end of the line has maqaf (Hebrew hyphen, U+05BE).
*/
public static final int END_HYPHEN_EDIT_INSERT_MAQAF = 0x04;
/**
* An integer representing the end of the line has Canadian Syllabics hyphen (U+1400).
*/
public static final int END_HYPHEN_EDIT_INSERT_UCAS_HYPHEN = 0x05;
/**
* An integer representing the end of the line has Zero-Width-Joiner (U+200D) followed by normal
* hyphen character (U+002D).
*/
public static final int END_HYPHEN_EDIT_INSERT_ZWJ_AND_HYPHEN = 0x06;
/**
* The Style specifies if the primitive being drawn is filled, stroked, or
* both (in the same color). The default is FILL.
*/
public enum Style {
/**
* Geometry and text drawn with this style will be filled, ignoring all
* stroke-related settings in the paint.
*/
FILL (0),
/**
* Geometry and text drawn with this style will be stroked, respecting
* the stroke-related fields on the paint.
*/
STROKE (1),
/**
* Geometry and text drawn with this style will be both filled and
* stroked at the same time, respecting the stroke-related fields on
* the paint. This mode can give unexpected results if the geometry
* is oriented counter-clockwise. This restriction does not apply to
* either FILL or STROKE.
*/
FILL_AND_STROKE (2);
Style(int nativeInt) {
this.nativeInt = nativeInt;
}
final int nativeInt;
}
/**
* The Cap specifies the treatment for the beginning and ending of
* stroked lines and paths. The default is BUTT.
*/
public enum Cap {
/**
* The stroke ends with the path, and does not project beyond it.
*/
BUTT (0),
/**
* The stroke projects out as a semicircle, with the center at the
* end of the path.
*/
ROUND (1),
/**
* The stroke projects out as a square, with the center at the end
* of the path.
*/
SQUARE (2);
private Cap(int nativeInt) {
this.nativeInt = nativeInt;
}
final int nativeInt;
}
/**
* The Join specifies the treatment where lines and curve segments
* join on a stroked path. The default is MITER.
*/
public enum Join {
/**
* The outer edges of a join meet at a sharp angle
*/
MITER (0),
/**
* The outer edges of a join meet in a circular arc.
*/
ROUND (1),
/**
* The outer edges of a join meet with a straight line
*/
BEVEL (2);
private Join(int nativeInt) {
this.nativeInt = nativeInt;
}
final int nativeInt;
}
/**
* Align specifies how drawText aligns its text relative to the
* [x,y] coordinates. The default is LEFT.
*/
public enum Align {
/**
* The text is drawn to the right of the x,y origin
*/
LEFT (0),
/**
* The text is drawn centered horizontally on the x,y origin
*/
CENTER (1),
/**
* The text is drawn to the left of the x,y origin
*/
RIGHT (2);
private Align(int nativeInt) {
this.nativeInt = nativeInt;
}
final int nativeInt;
}
/**
* Create a new paint with default settings.
*
* <p>On devices running {@link Build.VERSION_CODES#O} and below, hardware
* accelerated drawing always acts as if {@link #FILTER_BITMAP_FLAG} is set.
* On devices running {@link Build.VERSION_CODES#Q} and above,
* {@code FILTER_BITMAP_FLAG} is set by this constructor, and it can be
* cleared with {@link #setFlags} or {@link #setFilterBitmap}.
* On devices running {@link Build.VERSION_CODES#S} and above, {@code ANTI_ALIAS_FLAG}
* is set by this constructor, and it can be cleared with {@link #setFlags} or
* {@link #setAntiAlias}.</p>
*/
public Paint() {
this(ANTI_ALIAS_FLAG);
}
/**
* Create a new paint with the specified flags. Use setFlags() to change
* these after the paint is created.
*
* <p>On devices running {@link Build.VERSION_CODES#O} and below, hardware
* accelerated drawing always acts as if {@link #FILTER_BITMAP_FLAG} is set.
* On devices running {@link Build.VERSION_CODES#Q} and above,
* {@code FILTER_BITMAP_FLAG} is always set by this constructor, regardless
* of the value of {@code flags}. It can be cleared with {@link #setFlags} or
* {@link #setFilterBitmap}.</p>
*
* @param flags initial flag bits, as if they were passed via setFlags().
*/
public Paint(int flags) {
mNativePaint = nInit();
NoImagePreloadHolder.sRegistry.registerNativeAllocation(this, mNativePaint);
setFlags(flags | HIDDEN_DEFAULT_PAINT_FLAGS);
// TODO: Turning off hinting has undesirable side effects, we need to
// revisit hinting once we add support for subpixel positioning
// setHinting(DisplayMetrics.DENSITY_DEVICE >= DisplayMetrics.DENSITY_TV
// ? HINTING_OFF : HINTING_ON);
mCompatScaling = mInvCompatScaling = 1;
setTextLocales(LocaleList.getAdjustedDefault());
mColor = Color.pack(Color.BLACK);
resetElegantTextHeight();
}
/**
* Create a new paint, initialized with the attributes in the specified
* paint parameter.
*
* @param paint Existing paint used to initialized the attributes of the
* new paint.
*/
public Paint(Paint paint) {
mNativePaint = nInitWithPaint(paint.getNativeInstance());
NoImagePreloadHolder.sRegistry.registerNativeAllocation(this, mNativePaint);
setClassVariablesFrom(paint);
}
/** Restores the paint to its default settings. */
public void reset() {
nReset(mNativePaint);
setFlags(HIDDEN_DEFAULT_PAINT_FLAGS | ANTI_ALIAS_FLAG);
// TODO: Turning off hinting has undesirable side effects, we need to
// revisit hinting once we add support for subpixel positioning
// setHinting(DisplayMetrics.DENSITY_DEVICE >= DisplayMetrics.DENSITY_TV
// ? HINTING_OFF : HINTING_ON);
mColor = Color.pack(Color.BLACK);
mColorFilter = null;
mMaskFilter = null;
mPathEffect = null;
mShader = null;
mNativeShader = 0;
mTypeface = null;
mXfermode = null;
mHasCompatScaling = false;
mCompatScaling = 1;
mInvCompatScaling = 1;
mBidiFlags = BIDI_DEFAULT_LTR;
setTextLocales(LocaleList.getAdjustedDefault());
resetElegantTextHeight();
mFontFeatureSettings = null;
mFontVariationSettings = null;
mShadowLayerRadius = 0.0f;
mShadowLayerDx = 0.0f;
mShadowLayerDy = 0.0f;
mShadowLayerColor = Color.pack(0);
}
/**
* Copy the fields from src into this paint. This is equivalent to calling
* get() on all of the src fields, and calling the corresponding set()
* methods on this.
*/
public void set(Paint src) {
if (this != src) {
// copy over the native settings
nSet(mNativePaint, src.mNativePaint);
setClassVariablesFrom(src);
}
}
/**
* Set all class variables using current values from the given
* {@link Paint}.
*/
private void setClassVariablesFrom(Paint paint) {
mColor = paint.mColor;
mColorFilter = paint.mColorFilter;
mMaskFilter = paint.mMaskFilter;
mPathEffect = paint.mPathEffect;
mShader = paint.mShader;
mNativeShader = paint.mNativeShader;
mTypeface = paint.mTypeface;
mXfermode = paint.mXfermode;
mHasCompatScaling = paint.mHasCompatScaling;
mCompatScaling = paint.mCompatScaling;
mInvCompatScaling = paint.mInvCompatScaling;
mBidiFlags = paint.mBidiFlags;
mLocales = paint.mLocales;
mFontFeatureSettings = paint.mFontFeatureSettings;
mFontVariationSettings = paint.mFontVariationSettings;
mShadowLayerRadius = paint.mShadowLayerRadius;
mShadowLayerDx = paint.mShadowLayerDx;
mShadowLayerDy = paint.mShadowLayerDy;
mShadowLayerColor = paint.mShadowLayerColor;
}
/** @hide */
@UnsupportedAppUsage
public void setCompatibilityScaling(float factor) {
if (factor == 1.0) {
mHasCompatScaling = false;
mCompatScaling = mInvCompatScaling = 1.0f;
} else {
mHasCompatScaling = true;
mCompatScaling = factor;
mInvCompatScaling = 1.0f/factor;
}
}
/**
* Return the pointer to the native object while ensuring that any
* mutable objects that are attached to the paint are also up-to-date.
*
* Note: Although this method is |synchronized|, this is simply so it
* is not thread-hostile to multiple threads calling this method. It
* is still unsafe to attempt to change the Shader/ColorFilter while
* another thread attempts to access the native object.
*
* @hide
*/
@UnsupportedAppUsage
public synchronized long getNativeInstance() {
boolean filter = isFilterBitmap();
long newNativeShader = mShader == null ? 0 : mShader.getNativeInstance(filter);
if (newNativeShader != mNativeShader) {
mNativeShader = newNativeShader;
nSetShader(mNativePaint, mNativeShader);
}
long newNativeColorFilter = mColorFilter == null ? 0 : mColorFilter.getNativeInstance();
if (newNativeColorFilter != mNativeColorFilter) {
mNativeColorFilter = newNativeColorFilter;
nSetColorFilter(mNativePaint, mNativeColorFilter);
}
return mNativePaint;
}
/**
* Return the bidi flags on the paint.
*
* @return the bidi flags on the paint
* @hide
*/
public int getBidiFlags() {
return mBidiFlags;
}
/**
* Set the bidi flags on the paint.
* @hide
*/
public void setBidiFlags(int flags) {
// only flag value is the 3-bit BIDI control setting
flags &= BIDI_FLAG_MASK;
if (flags > BIDI_MAX_FLAG_VALUE) {
throw new IllegalArgumentException("unknown bidi flag: " + flags);
}
mBidiFlags = flags;
}
/**
* Return the paint's flags. Use the Flag enum to test flag values.
*
* @return the paint's flags (see enums ending in _Flag for bit masks)
*/
public @PaintFlag int getFlags() {
return nGetFlags(mNativePaint);
}
/**
* Set the paint's flags. Use the Flag enum to specific flag values.
*
* @param flags The new flag bits for the paint
*/
public void setFlags(@PaintFlag int flags) {
nSetFlags(mNativePaint, flags);
}
/**
* Return the paint's hinting mode. Returns either
* {@link #HINTING_OFF} or {@link #HINTING_ON}.
*/
public int getHinting() {
return nGetHinting(mNativePaint);
}
/**
* Set the paint's hinting mode. May be either
* {@link #HINTING_OFF} or {@link #HINTING_ON}.
*/
public void setHinting(int mode) {
nSetHinting(mNativePaint, mode);
}
/**
* Helper for getFlags(), returning true if ANTI_ALIAS_FLAG bit is set
* AntiAliasing smooths out the edges of what is being drawn, but is has
* no impact on the interior of the shape. See setDither() and
* setFilterBitmap() to affect how colors are treated.
*
* @return true if the antialias bit is set in the paint's flags.
*/
public final boolean isAntiAlias() {
return (getFlags() & ANTI_ALIAS_FLAG) != 0;
}
/**
* Helper for setFlags(), setting or clearing the ANTI_ALIAS_FLAG bit
* AntiAliasing smooths out the edges of what is being drawn, but is has
* no impact on the interior of the shape. See setDither() and
* setFilterBitmap() to affect how colors are treated.
*
* @param aa true to set the antialias bit in the flags, false to clear it
*/
public void setAntiAlias(boolean aa) {
nSetAntiAlias(mNativePaint, aa);
}
/**
* Helper for getFlags(), returning true if DITHER_FLAG bit is set
* Dithering affects how colors that are higher precision than the device
* are down-sampled. No dithering is generally faster, but higher precision
* colors are just truncated down (e.g. 8888 -> 565). Dithering tries to
* distribute the error inherent in this process, to reduce the visual
* artifacts.
*
* @return true if the dithering bit is set in the paint's flags.
*/
public final boolean isDither() {
return (getFlags() & DITHER_FLAG) != 0;
}
/**
* Helper for setFlags(), setting or clearing the DITHER_FLAG bit
* Dithering affects how colors that are higher precision than the device
* are down-sampled. No dithering is generally faster, but higher precision
* colors are just truncated down (e.g. 8888 -> 565). Dithering tries to
* distribute the error inherent in this process, to reduce the visual
* artifacts.
*
* @param dither true to set the dithering bit in flags, false to clear it
*/
public void setDither(boolean dither) {
nSetDither(mNativePaint, dither);
}
/**
* Helper for getFlags(), returning true if LINEAR_TEXT_FLAG bit is set
*
* @return true if the lineartext bit is set in the paint's flags
*/
public final boolean isLinearText() {
return (getFlags() & LINEAR_TEXT_FLAG) != 0;
}
/**
* Helper for setFlags(), setting or clearing the LINEAR_TEXT_FLAG bit
*
* @param linearText true to set the linearText bit in the paint's flags,
* false to clear it.
*/
public void setLinearText(boolean linearText) {
nSetLinearText(mNativePaint, linearText);
}
/**
* Helper for getFlags(), returning true if SUBPIXEL_TEXT_FLAG bit is set
*
* @return true if the subpixel bit is set in the paint's flags
*/
public final boolean isSubpixelText() {
return (getFlags() & SUBPIXEL_TEXT_FLAG) != 0;
}
/**
* Helper for setFlags(), setting or clearing the SUBPIXEL_TEXT_FLAG bit
*
* @param subpixelText true to set the subpixelText bit in the paint's
* flags, false to clear it.
*/
public void setSubpixelText(boolean subpixelText) {
nSetSubpixelText(mNativePaint, subpixelText);
}
/**
* Helper for getFlags(), returning true if UNDERLINE_TEXT_FLAG bit is set
*
* @return true if the underlineText bit is set in the paint's flags.
* @see #getUnderlinePosition()
* @see #getUnderlineThickness()
* @see #setUnderlineText(boolean)
*/
public final boolean isUnderlineText() {
return (getFlags() & UNDERLINE_TEXT_FLAG) != 0;
}
/**
* Returns the distance from top of the underline to the baseline in pixels.
*
* The result is positive for positions that are below the baseline.
* This method returns where the underline should be drawn independent of if the {@link
* #UNDERLINE_TEXT_FLAG} bit is set.
*
* @return the position of the underline in pixels
* @see #isUnderlineText()
* @see #getUnderlineThickness()
* @see #setUnderlineText(boolean)
*/
public @Px float getUnderlinePosition() {
return nGetUnderlinePosition(mNativePaint);
}
/**
* Returns the thickness of the underline in pixels.
*
* @return the thickness of the underline in pixels
* @see #isUnderlineText()
* @see #getUnderlinePosition()
* @see #setUnderlineText(boolean)
*/
public @Px float getUnderlineThickness() {
return nGetUnderlineThickness(mNativePaint);
}
/**
* Helper for setFlags(), setting or clearing the UNDERLINE_TEXT_FLAG bit
*
* @param underlineText true to set the underlineText bit in the paint's
* flags, false to clear it.
* @see #isUnderlineText()
* @see #getUnderlinePosition()
* @see #getUnderlineThickness()
*/
public void setUnderlineText(boolean underlineText) {
nSetUnderlineText(mNativePaint, underlineText);
}
/**
* Helper for getFlags(), returning true if STRIKE_THRU_TEXT_FLAG bit is set
*
* @return true if the {@link #STRIKE_THRU_TEXT_FLAG} bit is set in the paint's flags.
* @see #getStrikeThruPosition()
* @see #getStrikeThruThickness()
* @see #setStrikeThruText(boolean)
*/
public final boolean isStrikeThruText() {
return (getFlags() & STRIKE_THRU_TEXT_FLAG) != 0;
}
/**
* Distance from top of the strike-through line to the baseline in pixels.
*
* The result is negative for positions that are above the baseline.
* This method returns where the strike-through line should be drawn independent of if the
* {@link #STRIKE_THRU_TEXT_FLAG} bit is set.
*
* @return the position of the strike-through line in pixels
* @see #getStrikeThruThickness()
* @see #setStrikeThruText(boolean)
* @see #isStrikeThruText()
*/
public @Px float getStrikeThruPosition() {
return nGetStrikeThruPosition(mNativePaint);
}
/**
* Returns the thickness of the strike-through line in pixels.
*
* @return the position of the strike-through line in pixels
* @see #getStrikeThruPosition()
* @see #setStrikeThruText(boolean)
* @see #isStrikeThruText()
*/
public @Px float getStrikeThruThickness() {
return nGetStrikeThruThickness(mNativePaint);
}
/**
* Helper for setFlags(), setting or clearing the STRIKE_THRU_TEXT_FLAG bit
*
* @param strikeThruText true to set the strikeThruText bit in the paint's
* flags, false to clear it.
* @see #getStrikeThruPosition()
* @see #getStrikeThruThickness()
* @see #isStrikeThruText()
*/
public void setStrikeThruText(boolean strikeThruText) {
nSetStrikeThruText(mNativePaint, strikeThruText);
}
/**
* Helper for getFlags(), returning true if FAKE_BOLD_TEXT_FLAG bit is set
*
* @return true if the fakeBoldText bit is set in the paint's flags.
*/
public final boolean isFakeBoldText() {
return (getFlags() & FAKE_BOLD_TEXT_FLAG) != 0;
}
/**
* Helper for setFlags(), setting or clearing the FAKE_BOLD_TEXT_FLAG bit
*
* @param fakeBoldText true to set the fakeBoldText bit in the paint's
* flags, false to clear it.
*/
public void setFakeBoldText(boolean fakeBoldText) {
nSetFakeBoldText(mNativePaint, fakeBoldText);
}
/**
* Whether or not the bitmap filter is activated.
* Filtering affects the sampling of bitmaps when they are transformed.
* Filtering does not affect how the colors in the bitmap are converted into
* device pixels. That is dependent on dithering and xfermodes.
*
* @see #setFilterBitmap(boolean) setFilterBitmap()
* @see #FILTER_BITMAP_FLAG
*/
public final boolean isFilterBitmap() {
return (getFlags() & FILTER_BITMAP_FLAG) != 0;
}
/**
* Helper for setFlags(), setting or clearing the FILTER_BITMAP_FLAG bit.
* Filtering affects the sampling of bitmaps when they are transformed.
* Filtering does not affect how the colors in the bitmap are converted into
* device pixels. That is dependent on dithering and xfermodes.
*
* @param filter true to set the FILTER_BITMAP_FLAG bit in the paint's
* flags, false to clear it.
* @see #FILTER_BITMAP_FLAG
*/
public void setFilterBitmap(boolean filter) {
nSetFilterBitmap(mNativePaint, filter);
}
/**
* Return the paint's style, used for controlling how primitives'
* geometries are interpreted (except for drawBitmap, which always assumes
* FILL_STYLE).
*
* @return the paint's style setting (Fill, Stroke, StrokeAndFill)
*/
public Style getStyle() {
return sStyleArray[nGetStyle(mNativePaint)];
}
/**
* Set the paint's style, used for controlling how primitives'
* geometries are interpreted (except for drawBitmap, which always assumes
* Fill).
*
* @param style The new style to set in the paint
*/
public void setStyle(Style style) {
nSetStyle(mNativePaint, style.nativeInt);
}
/**
* Return the paint's color in sRGB. Note that the color is a 32bit value
* containing alpha as well as r,g,b. This 32bit value is not premultiplied,
* meaning that its alpha can be any value, regardless of the values of
* r,g,b. See the Color class for more details.
*
* @return the paint's color (and alpha).
*/
@ColorInt
public int getColor() {
return Color.toArgb(mColor);
}
/**
* Return the paint's color. Note that the color is a long with an encoded
* {@link ColorSpace} as well as alpha and r,g,b. These values are not
* premultiplied, meaning that alpha can be any value, regardless of the
* values of r,g,b. See the {@link Color} class for more details.
*
* @return the paint's color, alpha, and {@code ColorSpace} encoded as a
* {@code ColorLong}
*/
@ColorLong
public long getColorLong() {
return mColor;
}
/**
* Set the paint's color. Note that the color is an int containing alpha
* as well as r,g,b. This 32bit value is not premultiplied, meaning that
* its alpha can be any value, regardless of the values of r,g,b.
* See the Color class for more details.
*
* @param color The new color (including alpha) to set in the paint.
*/
public void setColor(@ColorInt int color) {
nSetColor(mNativePaint, color);
mColor = Color.pack(color);
}
/**
* Set the paint's color with a {@code ColorLong}. Note that the color is
* a long with an encoded {@link ColorSpace} as well as alpha and r,g,b.
* These values are not premultiplied, meaning that alpha can be any value,
* regardless of the values of r,g,b. See the {@link Color} class for more
* details.
*
* @param color The new color (including alpha and {@link ColorSpace})
* to set in the paint.
* @throws IllegalArgumentException if the color space encoded in the
* {@code ColorLong} is invalid or unknown.
*/
public void setColor(@ColorLong long color) {
ColorSpace cs = Color.colorSpace(color);
nSetColor(mNativePaint, cs.getNativeInstance(), color);
mColor = color;
}
/**
* Helper to getColor() that just returns the color's alpha value. This is
* the same as calling getColor() >>> 24. It always returns a value between
* 0 (completely transparent) and 255 (completely opaque).
*
* @return the alpha component of the paint's color.
*/
public int getAlpha() {
return Math.round(Color.alpha(mColor) * 255.0f);
}
/**
* Helper to setColor(), that only assigns the color's alpha value,
* leaving its r,g,b values unchanged. Results are undefined if the alpha
* value is outside of the range [0..255]
*
* @param a set the alpha component [0..255] of the paint's color.
*/
public void setAlpha(int a) {
// FIXME: No need to unpack this. Instead, just update the alpha bits.
// b/122959599
ColorSpace cs = Color.colorSpace(mColor);
float r = Color.red(mColor);
float g = Color.green(mColor);
float b = Color.blue(mColor);
mColor = Color.pack(r, g, b, a * (1.0f / 255), cs);
nSetAlpha(mNativePaint, a);
}
/**
* Helper to setColor(), that takes a,r,g,b and constructs the color int
*
* @param a The new alpha component (0..255) of the paint's color.
* @param r The new red component (0..255) of the paint's color.
* @param g The new green component (0..255) of the paint's color.
* @param b The new blue component (0..255) of the paint's color.
*/
public void setARGB(int a, int r, int g, int b) {
setColor((a << 24) | (r << 16) | (g << 8) | b);
}
/**
* Return the width for stroking.
* <p />
* A value of 0 strokes in hairline mode.
* Hairlines always draws a single pixel independent of the canvas's matrix.
*
* @return the paint's stroke width, used whenever the paint's style is
* Stroke or StrokeAndFill.
*/
public float getStrokeWidth() {
return nGetStrokeWidth(mNativePaint);
}
/**
* Set the width for stroking.
* Pass 0 to stroke in hairline mode.
* Hairlines always draws a single pixel independent of the canvas's matrix.
*
* @param width set the paint's stroke width, used whenever the paint's
* style is Stroke or StrokeAndFill.
*/
public void setStrokeWidth(float width) {
nSetStrokeWidth(mNativePaint, width);
}
/**
* Return the paint's stroke miter value. Used to control the behavior
* of miter joins when the joins angle is sharp.
*
* @return the paint's miter limit, used whenever the paint's style is
* Stroke or StrokeAndFill.
*/
public float getStrokeMiter() {
return nGetStrokeMiter(mNativePaint);
}
/**
* Set the paint's stroke miter value. This is used to control the behavior
* of miter joins when the joins angle is sharp. This value must be >= 0.
*
* @param miter set the miter limit on the paint, used whenever the paint's
* style is Stroke or StrokeAndFill.
*/
public void setStrokeMiter(float miter) {
nSetStrokeMiter(mNativePaint, miter);
}
/**
* Return the paint's Cap, controlling how the start and end of stroked
* lines and paths are treated.
*
* @return the line cap style for the paint, used whenever the paint's
* style is Stroke or StrokeAndFill.
*/
public Cap getStrokeCap() {
return sCapArray[nGetStrokeCap(mNativePaint)];
}
/**
* Set the paint's Cap.
*
* @param cap set the paint's line cap style, used whenever the paint's
* style is Stroke or StrokeAndFill.
*/
public void setStrokeCap(Cap cap) {
nSetStrokeCap(mNativePaint, cap.nativeInt);
}
/**
* Return the paint's stroke join type.
*
* @return the paint's Join.
*/
public Join getStrokeJoin() {
return sJoinArray[nGetStrokeJoin(mNativePaint)];
}
/**
* Set the paint's Join.
*
* @param join set the paint's Join, used whenever the paint's style is
* Stroke or StrokeAndFill.
*/
public void setStrokeJoin(Join join) {
nSetStrokeJoin(mNativePaint, join.nativeInt);
}
/**
* Applies any/all effects (patheffect, stroking) to src, returning the
* result in dst. The result is that drawing src with this paint will be
* the same as drawing dst with a default paint (at least from the
* geometric perspective).
*
* @param src input path
* @param dst output path (may be the same as src)
* @return true if the path should be filled, or false if it should be
* drawn with a hairline (width == 0)
*/
public boolean getFillPath(Path src, Path dst) {
return nGetFillPath(mNativePaint, src.readOnlyNI(), dst.mutateNI());
}
/**
* Get the paint's shader object.
*
* @return the paint's shader (or null)
*/
public Shader getShader() {
return mShader;
}
/**
* Set or clear the shader object.
* <p />
* Pass null to clear any previous shader.
* As a convenience, the parameter passed is also returned.
*
* @param shader May be null. the new shader to be installed in the paint
* @return shader
*/
public Shader setShader(Shader shader) {
// If mShader changes, cached value of native shader aren't valid, since
// old shader's pointer may be reused by another shader allocation later
if (mShader != shader) {
mNativeShader = -1;
// Release any native references to the old shader content
nSetShader(mNativePaint, 0);
}
// Defer setting the shader natively until getNativeInstance() is called
mShader = shader;
return shader;
}
/**
* Get the paint's colorfilter (maybe be null).
*
* @return the paint's colorfilter (maybe be null)
*/
public ColorFilter getColorFilter() {
return mColorFilter;
}
/**
* Set or clear the paint's colorfilter, returning the parameter.
*
* @param filter May be null. The new filter to be installed in the paint
* @return filter
*/
public ColorFilter setColorFilter(ColorFilter filter) {
// If mColorFilter changes, cached value of native shader aren't valid, since
// old shader's pointer may be reused by another shader allocation later
if (mColorFilter != filter) {
mNativeColorFilter = -1;
}
// Defer setting the filter natively until getNativeInstance() is called
mColorFilter = filter;
return filter;
}
/**
* Get the paint's transfer mode object.
*
* @return the paint's transfer mode (or null)
*/
public Xfermode getXfermode() {
return mXfermode;
}
/**
* Get the paint's blend mode object.
*
* @return the paint's blend mode (or null)
*/
@Nullable
public BlendMode getBlendMode() {
if (mXfermode == null) {
return null;
} else {
return BlendMode.fromValue(mXfermode.porterDuffMode);
}
}
/**
* Set or clear the transfer mode object. A transfer mode defines how
* source pixels (generate by a drawing command) are composited with
* the destination pixels (content of the render target).
* <p />
* Pass null to clear any previous transfer mode.
* As a convenience, the parameter passed is also returned.
* <p />
* {@link PorterDuffXfermode} is the most common transfer mode.
*
* @param xfermode May be null. The xfermode to be installed in the paint
* @return xfermode
*/
public Xfermode setXfermode(Xfermode xfermode) {
return installXfermode(xfermode);
}
@Nullable
private Xfermode installXfermode(Xfermode xfermode) {
int newMode = xfermode != null ? xfermode.porterDuffMode : Xfermode.DEFAULT;
int curMode = mXfermode != null ? mXfermode.porterDuffMode : Xfermode.DEFAULT;
if (newMode != curMode) {
nSetXfermode(mNativePaint, newMode);
}
mXfermode = xfermode;
return xfermode;
}
/**
* Set or clear the blend mode. A blend mode defines how source pixels
* (generated by a drawing command) are composited with the destination pixels
* (content of the render target).
* <p />
* Pass null to clear any previous blend mode.
* <p />
*
* @see BlendMode
*
* @param blendmode May be null. The blend mode to be installed in the paint
*/
public void setBlendMode(@Nullable BlendMode blendmode) {
installXfermode(blendmode != null ? blendmode.getXfermode() : null);
}
/**
* Get the paint's patheffect object.
*
* @return the paint's patheffect (or null)
*/
public PathEffect getPathEffect() {
return mPathEffect;
}
/**
* Set or clear the patheffect object.
* <p />
* Pass null to clear any previous patheffect.
* As a convenience, the parameter passed is also returned.
*
* @param effect May be null. The patheffect to be installed in the paint
* @return effect
*/
public PathEffect setPathEffect(PathEffect effect) {
long effectNative = 0;
if (effect != null) {
effectNative = effect.native_instance;
}
nSetPathEffect(mNativePaint, effectNative);
mPathEffect = effect;
return effect;
}
/**
* Get the paint's maskfilter object.
*
* @return the paint's maskfilter (or null)
*/
public MaskFilter getMaskFilter() {
return mMaskFilter;
}
/**
* Set or clear the maskfilter object.
* <p />
* Pass null to clear any previous maskfilter.
* As a convenience, the parameter passed is also returned.
*
* @param maskfilter May be null. The maskfilter to be installed in the
* paint
* @return maskfilter
*/
public MaskFilter setMaskFilter(MaskFilter maskfilter) {
long maskfilterNative = 0;
if (maskfilter != null) {
maskfilterNative = maskfilter.native_instance;
}
nSetMaskFilter(mNativePaint, maskfilterNative);
mMaskFilter = maskfilter;
return maskfilter;
}
/**
* Get the paint's typeface object.
* <p />
* The typeface object identifies which font to use when drawing or
* measuring text.
*
* @return the paint's typeface (or null)
*/
public Typeface getTypeface() {
return mTypeface;
}
/**
* Set or clear the typeface object.
* <p />
* Pass null to clear any previous typeface.
* As a convenience, the parameter passed is also returned.
*
* @param typeface May be null. The typeface to be installed in the paint
* @return typeface
*/
public Typeface setTypeface(Typeface typeface) {
final long typefaceNative = typeface == null ? 0 : typeface.native_instance;
nSetTypeface(mNativePaint, typefaceNative);
mTypeface = typeface;
return typeface;
}
/**
* Get the paint's rasterizer (or null).
* <p />
* The raster controls/modifies how paths/text are turned into alpha masks.
*
* @return the paint's rasterizer (or null)
*
* @deprecated Rasterizer is not supported by either the HW or PDF backends.
* @removed
*/
@Deprecated
public Rasterizer getRasterizer() {
return null;
}
/**
* Set or clear the rasterizer object.
* <p />
* Pass null to clear any previous rasterizer.
* As a convenience, the parameter passed is also returned.
*
* @param rasterizer May be null. The new rasterizer to be installed in
* the paint.
* @return rasterizer
*
* @deprecated Rasterizer is not supported by either the HW or PDF backends.
* @removed
*/
@Deprecated
public Rasterizer setRasterizer(Rasterizer rasterizer) {
return rasterizer;
}
/**
* This draws a shadow layer below the main layer, with the specified
* offset and color, and blur radius. If radius is 0, then the shadow
* layer is removed.
* <p>
* Can be used to create a blurred shadow underneath text. Support for use
* with other drawing operations is constrained to the software rendering
* pipeline.
* <p>
* The alpha of the shadow will be the paint's alpha if the shadow color is
* opaque, or the alpha from the shadow color if not.
*/
public void setShadowLayer(float radius, float dx, float dy, @ColorInt int shadowColor) {
setShadowLayer(radius, dx, dy, Color.pack(shadowColor));
}
/**
* This draws a shadow layer below the main layer, with the specified
* offset and color, and blur radius. If radius is 0, then the shadow
* layer is removed.
* <p>
* Can be used to create a blurred shadow underneath text. Support for use
* with other drawing operations is constrained to the software rendering
* pipeline.
* <p>
* The alpha of the shadow will be the paint's alpha if the shadow color is
* opaque, or the alpha from the shadow color if not.
*
* @throws IllegalArgumentException if the color space encoded in the
* {@code ColorLong} is invalid or unknown.
*/
public void setShadowLayer(float radius, float dx, float dy, @ColorLong long shadowColor) {
ColorSpace cs = Color.colorSpace(shadowColor);
nSetShadowLayer(mNativePaint, radius, dx, dy, cs.getNativeInstance(), shadowColor);
mShadowLayerRadius = radius;
mShadowLayerDx = dx;
mShadowLayerDy = dy;
mShadowLayerColor = shadowColor;
}
/**
* Clear the shadow layer.
*/
public void clearShadowLayer() {
setShadowLayer(0, 0, 0, 0);
}
/**
* Checks if the paint has a shadow layer attached
*
* @return true if the paint has a shadow layer attached and false otherwise
* @hide
*/
public boolean hasShadowLayer() {
return nHasShadowLayer(mNativePaint);
}
/**
* Returns the blur radius of the shadow layer.
* @see #setShadowLayer(float,float,float,int)
* @see #setShadowLayer(float,float,float,long)
*/
public float getShadowLayerRadius() {
return mShadowLayerRadius;
}
/**
* Returns the x offset of the shadow layer.
* @see #setShadowLayer(float,float,float,int)
* @see #setShadowLayer(float,float,float,long)
*/
public float getShadowLayerDx() {
return mShadowLayerDx;
}
/**
* Returns the y offset of the shadow layer.
* @see #setShadowLayer(float,float,float,int)
* @see #setShadowLayer(float,float,float,long)
*/
public float getShadowLayerDy() {
return mShadowLayerDy;
}
/**
* Returns the color of the shadow layer.
* @see #setShadowLayer(float,float,float,int)
* @see #setShadowLayer(float,float,float,long)
*/
public @ColorInt int getShadowLayerColor() {
return Color.toArgb(mShadowLayerColor);
}
/**
* Returns the color of the shadow layer.
*
* @return the shadow layer's color encoded as a {@code ColorLong}.
* @see #setShadowLayer(float,float,float,int)
* @see #setShadowLayer(float,float,float,long)
* @see Color
*/
public @ColorLong long getShadowLayerColorLong() {
return mShadowLayerColor;
}
/**
* Return the paint's Align value for drawing text. This controls how the
* text is positioned relative to its origin. LEFT align means that all of
* the text will be drawn to the right of its origin (i.e. the origin
* specifies the LEFT edge of the text) and so on.
*
* @return the paint's Align value for drawing text.
*/
public Align getTextAlign() {
return sAlignArray[nGetTextAlign(mNativePaint)];
}
/**
* Set the paint's text alignment. This controls how the
* text is positioned relative to its origin. LEFT align means that all of
* the text will be drawn to the right of its origin (i.e. the origin
* specifies the LEFT edge of the text) and so on.
*
* @param align set the paint's Align value for drawing text.
*/
public void setTextAlign(Align align) {
nSetTextAlign(mNativePaint, align.nativeInt);
}
/**
* Get the text's primary Locale. Note that this is not all of the locale-related information
* Paint has. Use {@link #getTextLocales()} to get the complete list.
*
* @return the paint's primary Locale used for drawing text, never null.
*/
@NonNull
public Locale getTextLocale() {
return mLocales.get(0);
}
/**
* Get the text locale list.
*
* @return the paint's LocaleList used for drawing text, never null or empty.
*/
@NonNull @Size(min=1)
public LocaleList getTextLocales() {
return mLocales;
}
/**
* Set the text locale list to a one-member list consisting of just the locale.
*
* See {@link #setTextLocales(LocaleList)} for how the locale list affects
* the way the text is drawn for some languages.
*
* @param locale the paint's locale value for drawing text, must not be null.
*/
public void setTextLocale(@NonNull Locale locale) {
if (locale == null) {
throw new IllegalArgumentException("locale cannot be null");
}
if (mLocales != null && mLocales.size() == 1 && locale.equals(mLocales.get(0))) {
return;
}
mLocales = new LocaleList(locale);
syncTextLocalesWithMinikin();
}
/**
* Set the text locale list.
*
* The text locale list affects how the text is drawn for some languages.
*
* For example, if the locale list contains {@link Locale#CHINESE} or {@link Locale#CHINA},
* then the text renderer will prefer to draw text using a Chinese font. Likewise,
* if the locale list contains {@link Locale#JAPANESE} or {@link Locale#JAPAN}, then the text
* renderer will prefer to draw text using a Japanese font. If the locale list contains both,
* the order those locales appear in the list is considered for deciding the font.
*
* This distinction is important because Chinese and Japanese text both use many
* of the same Unicode code points but their appearance is subtly different for
* each language.
*
* By default, the text locale list is initialized to a one-member list just containing the
* system locales. This assumes that the text to be rendered will most likely be in the user's
* preferred language.
*
* If the actual language or languages of the text is/are known, then they can be provided to
* the text renderer using this method. The text renderer may attempt to guess the
* language script based on the contents of the text to be drawn independent of
* the text locale here. Specifying the text locales just helps it do a better
* job in certain ambiguous cases.
*
* @param locales the paint's locale list for drawing text, must not be null or empty.
*/
public void setTextLocales(@NonNull @Size(min=1) LocaleList locales) {
if (locales == null || locales.isEmpty()) {
throw new IllegalArgumentException("locales cannot be null or empty");
}
if (locales.equals(mLocales)) return;
mLocales = locales;
syncTextLocalesWithMinikin();
}
private void syncTextLocalesWithMinikin() {
final String languageTags = mLocales.toLanguageTags();
final Integer minikinLocaleListId;
synchronized (sCacheLock) {
minikinLocaleListId = sMinikinLocaleListIdCache.get(languageTags);
if (minikinLocaleListId == null) {
final int newID = nSetTextLocales(mNativePaint, languageTags);
sMinikinLocaleListIdCache.put(languageTags, newID);
return;
}
}
nSetTextLocalesByMinikinLocaleListId(mNativePaint, minikinLocaleListId.intValue());
}
/**
* Get the elegant metrics flag.
*
* @return true if elegant metrics are enabled for text drawing.
*/
public boolean isElegantTextHeight() {
int rawValue = nGetElegantTextHeight(mNativePaint);
switch (rawValue) {
case ELEGANT_TEXT_HEIGHT_DISABLED:
return false;
case ELEGANT_TEXT_HEIGHT_ENABLED:
return true;
case ELEGANT_TEXT_HEIGHT_UNSET:
default:
return com.android.text.flags.Flags.deprecateUiFonts();
}
}
// Note: the following three values must be equal to the ones in the JNI file: Paint.cpp
private static final int ELEGANT_TEXT_HEIGHT_UNSET = -1;
private static final int ELEGANT_TEXT_HEIGHT_ENABLED = 0;
private static final int ELEGANT_TEXT_HEIGHT_DISABLED = 1;
/**
* Set the paint's elegant height metrics flag. This setting selects font
* variants that have not been compacted to fit Latin-based vertical
* metrics, and also increases top and bottom bounds to provide more space.
*
* @param elegant set the paint's elegant metrics flag for drawing text.
*/
public void setElegantTextHeight(boolean elegant) {
nSetElegantTextHeight(mNativePaint,
elegant ? ELEGANT_TEXT_HEIGHT_ENABLED : ELEGANT_TEXT_HEIGHT_DISABLED);
}
/**
* A change ID for deprecating UI fonts.
*
* From API {@link Build.VERSION_CODES#VANILLA_ICE_CREAM}, the default value will be true by
* default if the app has a target SDK of API {@link Build.VERSION_CODES#VANILLA_ICE_CREAM} or
* later.
*
* @hide
*/
@ChangeId
@EnabledSince(targetSdkVersion = Build.VERSION_CODES.VANILLA_ICE_CREAM)
public static final long DEPRECATE_UI_FONT = 279646685L;
private void resetElegantTextHeight() {
if (CompatChanges.isChangeEnabled(DEPRECATE_UI_FONT)) {
nSetElegantTextHeight(mNativePaint, ELEGANT_TEXT_HEIGHT_UNSET);
} else {
nSetElegantTextHeight(mNativePaint, ELEGANT_TEXT_HEIGHT_DISABLED);
}
}
/**
* Return the paint's text size.
*
* @return the paint's text size in pixel units.
*/
public float getTextSize() {
return nGetTextSize(mNativePaint);
}
/**
* Set the paint's text size. This value must be > 0
*
* @param textSize set the paint's text size in pixel units.
*/
public void setTextSize(float textSize) {
nSetTextSize(mNativePaint, textSize);
}
/**
* Return the paint's horizontal scale factor for text. The default value
* is 1.0.
*
* @return the paint's scale factor in X for drawing/measuring text
*/
public float getTextScaleX() {
return nGetTextScaleX(mNativePaint);
}
/**
* Set the paint's horizontal scale factor for text. The default value
* is 1.0. Values > 1.0 will stretch the text wider. Values < 1.0 will
* stretch the text narrower.
*
* @param scaleX set the paint's scale in X for drawing/measuring text.
*/
public void setTextScaleX(float scaleX) {
nSetTextScaleX(mNativePaint, scaleX);
}
/**
* Return the paint's horizontal skew factor for text. The default value
* is 0.
*
* @return the paint's skew factor in X for drawing text.
*/
public float getTextSkewX() {
return nGetTextSkewX(mNativePaint);
}
/**
* Set the paint's horizontal skew factor for text. The default value
* is 0. For approximating oblique text, use values around -0.25.
*
* @param skewX set the paint's skew factor in X for drawing text.
*/
public void setTextSkewX(float skewX) {
nSetTextSkewX(mNativePaint, skewX);
}
/**
* Return the paint's letter-spacing for text. The default value
* is 0.
*
* @return the paint's letter-spacing for drawing text.
*/
public float getLetterSpacing() {
return nGetLetterSpacing(mNativePaint);
}
/**
* Set the paint's letter-spacing for text. The default value
* is 0. The value is in 'EM' units. Typical values for slight
* expansion will be around 0.05. Negative values tighten text.
*
* @param letterSpacing set the paint's letter-spacing for drawing text.
*/
public void setLetterSpacing(float letterSpacing) {
nSetLetterSpacing(mNativePaint, letterSpacing);
}
/**
* Return the paint's extra word-spacing for text.
*
* The default value is 0.
*
* @return the paint's extra word-spacing for drawing text in pixels.
* @see #setWordSpacing(float)
*/
public @Px float getWordSpacing() {
return nGetWordSpacing(mNativePaint);
}
/**
* Set the paint's extra word-spacing for text.
*
* Increases the white space width between words with the given amount of pixels.
* The default value is 0.
*
* @param wordSpacing set the paint's extra word-spacing for drawing text in pixels.
* @see #getWordSpacing()
*/
public void setWordSpacing(@Px float wordSpacing) {
nSetWordSpacing(mNativePaint, wordSpacing);
}
/**
* Returns the font feature settings. The format is the same as the CSS
* font-feature-settings attribute:
* <a href="https://www.w3.org/TR/css-fonts-3/#font-feature-settings-prop">
* https://www.w3.org/TR/css-fonts-3/#font-feature-settings-prop</a>
*
* @return the paint's currently set font feature settings. Default is null.
*
* @see #setFontFeatureSettings(String)
*/
public String getFontFeatureSettings() {
return mFontFeatureSettings;
}
/**
* Set font feature settings.
*
* The format is the same as the CSS font-feature-settings attribute:
* <a href="https://www.w3.org/TR/css-fonts-3/#font-feature-settings-prop">
* https://www.w3.org/TR/css-fonts-3/#font-feature-settings-prop</a>
*
* @see #getFontFeatureSettings()
*
* @param settings the font feature settings string to use, may be null.
*/
public void setFontFeatureSettings(String settings) {
if (settings != null && settings.equals("")) {
settings = null;
}
if ((settings == null && mFontFeatureSettings == null)
|| (settings != null && settings.equals(mFontFeatureSettings))) {
return;
}
mFontFeatureSettings = settings;
nSetFontFeatureSettings(mNativePaint, settings);
}
/**
* Returns the font variation settings.
*
* @return the paint's currently set font variation settings. Default is null.
*
* @see #setFontVariationSettings(String)
*/
public String getFontVariationSettings() {
return mFontVariationSettings;
}
/**
* Sets TrueType or OpenType font variation settings. The settings string is constructed from
* multiple pairs of axis tag and style values. The axis tag must contain four ASCII characters
* and must be wrapped with single quotes (U+0027) or double quotes (U+0022). Axis strings that
* are longer or shorter than four characters, or contain characters outside of U+0020..U+007E
* are invalid. If a specified axis name is not defined in the font, the settings will be
* ignored.
*
* Examples,
* <ul>
* <li>Set font width to 150.
* <pre>
* <code>
* Paint paint = new Paint();
* paint.setFontVariationSettings("'wdth' 150");
* </code>
* </pre>
* </li>
*
* <li>Set the font slant to 20 degrees and ask for italic style.
* <pre>
* <code>
* Paint paint = new Paint();
* paint.setFontVariationSettings("'slnt' 20, 'ital' 1");
* </code>
* </pre>
* </li>
* </ul>
*
* @param fontVariationSettings font variation settings. You can pass null or empty string as
* no variation settings.
*
* @return true if the given settings is effective to at least one font file underlying this
* typeface. This function also returns true for empty settings string. Otherwise
* returns false
*
* @throws IllegalArgumentException If given string is not a valid font variation settings
* format
*
* @see #getFontVariationSettings()
* @see FontVariationAxis
*/
public boolean setFontVariationSettings(String fontVariationSettings) {
final String settings = TextUtils.nullIfEmpty(fontVariationSettings);
if (settings == mFontVariationSettings
|| (settings != null && settings.equals(mFontVariationSettings))) {
return true;
}
if (settings == null || settings.length() == 0) {
mFontVariationSettings = null;
setTypeface(Typeface.createFromTypefaceWithVariation(mTypeface,
Collections.emptyList()));
return true;
}
// The null typeface is valid and it is equivalent to Typeface.DEFAULT.
// To call isSupportedAxes method, use Typeface.DEFAULT instance.
Typeface targetTypeface = mTypeface == null ? Typeface.DEFAULT : mTypeface;
FontVariationAxis[] axes = FontVariationAxis.fromFontVariationSettings(settings);
final ArrayList<FontVariationAxis> filteredAxes = new ArrayList<FontVariationAxis>();
for (final FontVariationAxis axis : axes) {
if (targetTypeface.isSupportedAxes(axis.getOpenTypeTagValue())) {
filteredAxes.add(axis);
}
}
if (filteredAxes.isEmpty()) {
return false;
}
mFontVariationSettings = settings;
setTypeface(Typeface.createFromTypefaceWithVariation(targetTypeface, filteredAxes));
return true;
}
/**
* Get the current value of start hyphen edit.
*
* The default value is 0 which is equivalent to {@link #START_HYPHEN_EDIT_NO_EDIT}.
*
* @return the current starting hyphen edit value
* @see #setStartHyphenEdit(int)
*/
public @StartHyphenEdit int getStartHyphenEdit() {
return nGetStartHyphenEdit(mNativePaint);
}
/**
* Get the current value of end hyphen edit.
*
* The default value is 0 which is equivalent to {@link #END_HYPHEN_EDIT_NO_EDIT}.
*
* @return the current starting hyphen edit value
* @see #setStartHyphenEdit(int)
*/
public @EndHyphenEdit int getEndHyphenEdit() {
return nGetEndHyphenEdit(mNativePaint);
}
/**
* Set a start hyphen edit on the paint.
*
* By setting start hyphen edit, the measurement and drawing is performed with modifying
* hyphenation at the start of line. For example, by passing
* {@link #START_HYPHEN_EDIT_INSERT_HYPHEN} like as follows, HYPHEN(U+2010)
* character is appended at the start of line.
*
* <pre>
* <code>
* Paint paint = new Paint();
* paint.setStartHyphenEdit(Paint.START_HYPHEN_EDIT_INSERT_HYPHEN);
* paint.measureText("abc", 0, 3); // Returns the width of "-abc"
* Canvas.drawText("abc", 0, 3, 0f, 0f, paint); // Draws "-abc"
* </code>
* </pre>
*
* The default value is 0 which is equivalent to
* {@link #START_HYPHEN_EDIT_NO_EDIT}.
*
* @param startHyphen a start hyphen edit value.
* @see #getStartHyphenEdit()
*/
public void setStartHyphenEdit(@StartHyphenEdit int startHyphen) {
nSetStartHyphenEdit(mNativePaint, startHyphen);
}
/**
* Set a end hyphen edit on the paint.
*
* By setting end hyphen edit, the measurement and drawing is performed with modifying
* hyphenation at the end of line. For example, by passing
* {@link #END_HYPHEN_EDIT_INSERT_HYPHEN} like as follows, HYPHEN(U+2010)
* character is appended at the end of line.
*
* <pre>
* <code>
* Paint paint = new Paint();
* paint.setEndHyphenEdit(Paint.END_HYPHEN_EDIT_INSERT_HYPHEN);
* paint.measureText("abc", 0, 3); // Returns the width of "abc-"
* Canvas.drawText("abc", 0, 3, 0f, 0f, paint); // Draws "abc-"
* </code>
* </pre>
*
* The default value is 0 which is equivalent to {@link #END_HYPHEN_EDIT_NO_EDIT}.
*
* @param endHyphen a end hyphen edit value.
* @see #getEndHyphenEdit()
*/
public void setEndHyphenEdit(@EndHyphenEdit int endHyphen) {
nSetEndHyphenEdit(mNativePaint, endHyphen);
}
/**
* Return the distance above (negative) the baseline (ascent) based on the
* current typeface and text size.
*
* <p>Note that this is the ascent of the main typeface, and actual text rendered may need a
* larger ascent because fallback fonts may get used in rendering the text.
*
* @return the distance above (negative) the baseline (ascent) based on the
* current typeface and text size.
*/
public float ascent() {
return nAscent(mNativePaint);
}
/**
* Return the distance below (positive) the baseline (descent) based on the
* current typeface and text size.
*
* <p>Note that this is the descent of the main typeface, and actual text rendered may need a
* larger descent because fallback fonts may get used in rendering the text.
*
* @return the distance below (positive) the baseline (descent) based on
* the current typeface and text size.
*/
public float descent() {
return nDescent(mNativePaint);
}
/**
* Class that describes the various metrics for a font at a given text size.
* Remember, Y values increase going down, so those values will be positive,
* and values that measure distances going up will be negative. This class
* is returned by getFontMetrics().
*/
public static class FontMetrics {
/**
* The maximum distance above the baseline for the tallest glyph in
* the font at a given text size.
*/
public float top;
/**
* The recommended distance above the baseline for singled spaced text.
*/
public float ascent;
/**
* The recommended distance below the baseline for singled spaced text.
*/
public float descent;
/**
* The maximum distance below the baseline for the lowest glyph in
* the font at a given text size.
*/
public float bottom;
/**
* The recommended additional space to add between lines of text.
*/
public float leading;
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || !(o instanceof FontMetrics)) return false;
FontMetrics that = (FontMetrics) o;
return that.top == top && that.ascent == ascent && that.descent == descent
&& that.bottom == bottom && that.leading == leading;
}
@Override
public int hashCode() {
return Objects.hash(top, ascent, descent, bottom, leading);
}
@Override
public String toString() {
return "FontMetrics{"
+ "top=" + top
+ ", ascent=" + ascent
+ ", descent=" + descent
+ ", bottom=" + bottom
+ ", leading=" + leading
+ '}';
}
}
/**
* Return the font's recommended interline spacing, given the Paint's
* settings for typeface, textSize, etc. If metrics is not null, return the
* fontmetric values in it.
*
* <p>Note that these are the values for the main typeface, and actual text rendered may need a
* larger set of values because fallback fonts may get used in rendering the text.
*
* @param metrics If this object is not null, its fields are filled with
* the appropriate values given the paint's text attributes.
* @return the font's recommended interline spacing.
*/
public float getFontMetrics(FontMetrics metrics) {
return nGetFontMetrics(mNativePaint, metrics, false);
}
/**
* Allocates a new FontMetrics object, and then calls getFontMetrics(fm)
* with it, returning the object.
*/
public FontMetrics getFontMetrics() {
FontMetrics fm = new FontMetrics();
getFontMetrics(fm);
return fm;
}
/**
* Get the font metrics used for the locale
*
* Obtain the metrics of the font that is used for the specified locale by
* {@link #setTextLocales(LocaleList)}. If multiple locales are specified, the minimum ascent
* and maximum descent will be set.
*
* This API is useful for determining the default line height of the empty text field, e.g.
* {@link android.widget.EditText}.
*
* Note, if the {@link android.graphics.Typeface} is created from the custom font files, its
* metrics are reserved, i.e. the ascent will be the custom font's ascent or smaller, the
* descent will be the custom font's descent or larger.
*
* Note, if the {@link android.graphics.Typeface} is a system fallback, e.g.
* {@link android.graphics.Typeface#SERIF}, the default font's metrics are reserved, i.e. the
* ascent will be the serif font's ascent or smaller, the descent will be the serif font's
* descent or larger.
*
* @param metrics an output parameter. All members will be set by calling this function.
*/
@FlaggedApi(FLAG_FIX_LINE_HEIGHT_FOR_LOCALE)
public void getFontMetricsForLocale(@NonNull FontMetrics metrics) {
nGetFontMetrics(mNativePaint, metrics, true);
}
/**
* Returns the font metrics value for the given text.
*
* If the text is rendered with multiple font files, this function returns the large ascent and
* descent that are enough for drawing all font files.
*
* The context range is used for shaping context. Some script, e.g. Arabic or Devanagari,
* changes letter shape based on its location or surrounding characters.
*
* @param text a text to be measured.
* @param start a starting offset in the text.
* @param count a length of the text to be measured.
* @param contextStart a context starting offset in the text.
* @param contextCount a length of the context to be used.
* @param isRtl true if measuring on RTL context, otherwise false.
* @param outMetrics the output font metrics.
*/
public void getFontMetricsInt(
@NonNull CharSequence text,
@IntRange(from = 0) int start, @IntRange(from = 0) int count,
@IntRange(from = 0) int contextStart, @IntRange(from = 0) int contextCount,
boolean isRtl,
@NonNull FontMetricsInt outMetrics) {
if (text == null) {
throw new IllegalArgumentException("text must not be null");
}
if (start < 0 || start >= text.length()) {
throw new IllegalArgumentException("start argument is out of bounds.");
}
if (count < 0 || start + count > text.length()) {
throw new IllegalArgumentException("count argument is out of bounds.");
}
if (contextStart < 0 || contextStart >= text.length()) {
throw new IllegalArgumentException("ctxStart argument is out of bounds.");
}
if (contextCount < 0 || contextStart + contextCount > text.length()) {
throw new IllegalArgumentException("ctxCount argument is out of bounds.");
}
if (outMetrics == null) {
throw new IllegalArgumentException("outMetrics must not be null.");
}
if (count == 0) {
getFontMetricsInt(outMetrics);
return;
}
if (text instanceof String) {
nGetFontMetricsIntForText(mNativePaint, (String) text, start, count, contextStart,
contextCount, isRtl, outMetrics);
} else {
char[] buf = TemporaryBuffer.obtain(contextCount);
try {
TextUtils.getChars(text, contextStart, contextStart + contextCount, buf, 0);
nGetFontMetricsIntForText(mNativePaint, buf, start - contextStart, count, 0,
contextCount, isRtl, outMetrics);
} finally {
TemporaryBuffer.recycle(buf);
}
}
}
/**
* Returns the font metrics value for the given text.
*
* If the text is rendered with multiple font files, this function returns the large ascent and
* descent that are enough for drawing all font files.
*
* The context range is used for shaping context. Some script, e.g. Arabic or Devanagari,
* changes letter shape based on its location or surrounding characters.
*
* @param text a text to be measured.
* @param start a starting offset in the text.
* @param count a length of the text to be measured.
* @param contextStart a context starting offset in the text.
* @param contextCount a length of the context to be used.
* @param isRtl true if measuring on RTL context, otherwise false.
* @param outMetrics the output font metrics.
*/
public void getFontMetricsInt(@NonNull char[] text,
@IntRange(from = 0) int start, @IntRange(from = 0) int count,
@IntRange(from = 0) int contextStart, @IntRange(from = 0) int contextCount,
boolean isRtl,
@NonNull FontMetricsInt outMetrics) {
if (text == null) {
throw new IllegalArgumentException("text must not be null");
}
if (start < 0 || start >= text.length) {
throw new IllegalArgumentException("start argument is out of bounds.");
}
if (count < 0 || start + count > text.length) {
throw new IllegalArgumentException("count argument is out of bounds.");
}
if (contextStart < 0 || contextStart >= text.length) {
throw new IllegalArgumentException("ctxStart argument is out of bounds.");
}
if (contextCount < 0 || contextStart + contextCount > text.length) {
throw new IllegalArgumentException("ctxCount argument is out of bounds.");
}
if (outMetrics == null) {
throw new IllegalArgumentException("outMetrics must not be null.");
}
if (count == 0) {
getFontMetricsInt(outMetrics);
return;
}
nGetFontMetricsIntForText(mNativePaint, text, start, count, contextStart, contextCount,
isRtl, outMetrics);
}
/**
* Convenience method for callers that want to have FontMetrics values as
* integers.
*/
public static class FontMetricsInt {
/**
* The maximum distance above the baseline for the tallest glyph in
* the font at a given text size.
*/
public int top;
/**
* The recommended distance above the baseline for singled spaced text.
*/
public int ascent;
/**
* The recommended distance below the baseline for singled spaced text.
*/
public int descent;
/**
* The maximum distance below the baseline for the lowest glyph in
* the font at a given text size.
*/
public int bottom;
/**
* The recommended additional space to add between lines of text.
*/
public int leading;
/**
* Set values from {@link FontMetricsInt}.
* @param fontMetricsInt a font metrics.
*/
@FlaggedApi(FLAG_FIX_LINE_HEIGHT_FOR_LOCALE)
public void set(@NonNull FontMetricsInt fontMetricsInt) {
top = fontMetricsInt.top;
ascent = fontMetricsInt.ascent;
descent = fontMetricsInt.descent;
bottom = fontMetricsInt.bottom;
leading = fontMetricsInt.leading;
}
/**
* Set values from {@link FontMetrics} with rounding accordingly.
* @param fontMetrics a font metrics.
*/
@FlaggedApi(FLAG_FIX_LINE_HEIGHT_FOR_LOCALE)
public void set(@NonNull FontMetrics fontMetrics) {
// See GraphicsJNI::set_metrics_int method for consistency.
top = (int) Math.floor(fontMetrics.top);
ascent = Math.round(fontMetrics.ascent);
descent = Math.round(fontMetrics.descent);
bottom = (int) Math.ceil(fontMetrics.bottom);
leading = Math.round(fontMetrics.leading);
}
@Override public String toString() {
return "FontMetricsInt: top=" + top + " ascent=" + ascent +
" descent=" + descent + " bottom=" + bottom +
" leading=" + leading;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (!(o instanceof FontMetricsInt)) return false;
FontMetricsInt that = (FontMetricsInt) o;
return top == that.top
&& ascent == that.ascent
&& descent == that.descent
&& bottom == that.bottom
&& leading == that.leading;
}
@Override
public int hashCode() {
return Objects.hash(top, ascent, descent, bottom, leading);
}
}
/**
* Return the font's interline spacing, given the Paint's settings for
* typeface, textSize, etc. If metrics is not null, return the fontmetric
* values in it. Note: all values have been converted to integers from
* floats, in such a way has to make the answers useful for both spacing
* and clipping. If you want more control over the rounding, call
* getFontMetrics().
*
* <p>Note that these are the values for the main typeface, and actual text rendered may need a
* larger set of values because fallback fonts may get used in rendering the text.
*
* @return the font's interline spacing.
*/
public int getFontMetricsInt(FontMetricsInt fmi) {
return nGetFontMetricsInt(mNativePaint, fmi, false);
}
public FontMetricsInt getFontMetricsInt() {
FontMetricsInt fm = new FontMetricsInt();
getFontMetricsInt(fm);
return fm;
}
/**
* Get the font metrics used for the locale
*
* Obtain the metrics of the font that is used for the specified locale by
* {@link #setTextLocales(LocaleList)}. If multiple locales are specified, the minimum ascent
* and maximum descent will be set.
*
* This API is useful for determining the default line height of the empty text field, e.g.
* {@link android.widget.EditText}.
*
* Note, if the {@link android.graphics.Typeface} is created from the custom font files, its
* metrics are reserved, i.e. the ascent will be the custom font's ascent or smaller, the
* descent will be the custom font's descent or larger.
*
* Note, if the {@link android.graphics.Typeface} is a system fallback, e.g.
* {@link android.graphics.Typeface#SERIF}, the default font's metrics are reserved, i.e. the
* ascent will be the serif font's ascent or smaller, the descent will be the serif font's
* descent or larger.
*
* @param metrics an output parameter. All members will be set by calling this function.
*/
@FlaggedApi(FLAG_FIX_LINE_HEIGHT_FOR_LOCALE)
public void getFontMetricsIntForLocale(@NonNull FontMetricsInt metrics) {
nGetFontMetricsInt(mNativePaint, metrics, true);
}
/** @hide */
public static final class RunInfo {
private int mClusterCount = 0;
public int getClusterCount() {
return mClusterCount;
}
public void setClusterCount(int clusterCount) {
mClusterCount = clusterCount;
}
}
/**
* Return the recommend line spacing based on the current typeface and
* text size.
*
* <p>Note that this is the value for the main typeface, and actual text rendered may need a
* larger value because fallback fonts may get used in rendering the text.
*
* @return recommend line spacing based on the current typeface and
* text size.
*/
public float getFontSpacing() {
return getFontMetrics(null);
}
/**
* Return the width of the text.
*
* @param text The text to measure. Cannot be null.
* @param index The index of the first character to start measuring
* @param count THe number of characters to measure, beginning with start
* @return The width of the text
*/
public float measureText(char[] text, int index, int count) {
if (text == null) {
throw new IllegalArgumentException("text cannot be null");
}
if ((index | count) < 0 || index + count > text.length) {
throw new ArrayIndexOutOfBoundsException();
}
if (text.length == 0 || count == 0) {
return 0f;
}
int oldFlag = getFlags();
setFlags(getFlags() | (TEXT_RUN_FLAG_LEFT_EDGE | TEXT_RUN_FLAG_RIGHT_EDGE));
try {
if (!mHasCompatScaling) {
return (float) Math.ceil(nGetTextAdvances(mNativePaint, text,
index, count, index, count, mBidiFlags, null, 0));
}
final float oldSize = getTextSize();
setTextSize(oldSize * mCompatScaling);
final float w = nGetTextAdvances(mNativePaint, text, index, count, index, count,
mBidiFlags, null, 0);
setTextSize(oldSize);
return (float) Math.ceil(w * mInvCompatScaling);
} finally {
setFlags(oldFlag);
}
}
/**
* Return the width of the text.
*
* @param text The text to measure. Cannot be null.
* @param start The index of the first character to start measuring
* @param end 1 beyond the index of the last character to measure
* @return The width of the text
*/
public float measureText(String text, int start, int end) {
if (text == null) {
throw new IllegalArgumentException("text cannot be null");
}
if ((start | end | (end - start) | (text.length() - end)) < 0) {
throw new IndexOutOfBoundsException();
}
if (text.length() == 0 || start == end) {
return 0f;
}
int oldFlag = getFlags();
setFlags(getFlags() | (TEXT_RUN_FLAG_LEFT_EDGE | TEXT_RUN_FLAG_RIGHT_EDGE));
try {
if (!mHasCompatScaling) {
return (float) Math.ceil(nGetTextAdvances(mNativePaint, text,
start, end, start, end, mBidiFlags, null, 0));
}
final float oldSize = getTextSize();
setTextSize(oldSize * mCompatScaling);
final float w = nGetTextAdvances(mNativePaint, text, start, end, start, end, mBidiFlags,
null, 0);
setTextSize(oldSize);
return (float) Math.ceil(w * mInvCompatScaling);
} finally {
setFlags(oldFlag);
}
}
/**
* Return the width of the text.
*
* @param text The text to measure. Cannot be null.
* @return The width of the text
*/
public float measureText(String text) {
if (text == null) {
throw new IllegalArgumentException("text cannot be null");
}
return measureText(text, 0, text.length());
}
/**
* Return the width of the text.
*
* @param text The text to measure
* @param start The index of the first character to start measuring
* @param end 1 beyond the index of the last character to measure
* @return The width of the text
*/
public float measureText(CharSequence text, int start, int end) {
if (text == null) {
throw new IllegalArgumentException("text cannot be null");
}
if ((start | end | (end - start) | (text.length() - end)) < 0) {
throw new IndexOutOfBoundsException();
}
if (text.length() == 0 || start == end) {
return 0f;
}
if (text instanceof String) {
return measureText((String)text, start, end);
}
if (text instanceof SpannedString ||
text instanceof SpannableString) {
return measureText(text.toString(), start, end);
}
if (text instanceof GraphicsOperations) {
return ((GraphicsOperations)text).measureText(start, end, this);
}
char[] buf = TemporaryBuffer.obtain(end - start);
TextUtils.getChars(text, start, end, buf, 0);
float result = measureText(buf, 0, end - start);
TemporaryBuffer.recycle(buf);
return result;
}
/**
* Measure the text, stopping early if the measured width exceeds maxWidth.
* Return the number of chars that were measured, and if measuredWidth is
* not null, return in it the actual width measured.
*
* @param text The text to measure. Cannot be null.
* @param index The offset into text to begin measuring at
* @param count The number of maximum number of entries to measure. If count
* is negative, then the characters are measured in reverse order.
* @param maxWidth The maximum width to accumulate.
* @param measuredWidth Optional. If not null, returns the actual width
* measured.
* @return The number of chars that were measured. Will always be <=
* abs(count).
*/
public int breakText(char[] text, int index, int count,
float maxWidth, float[] measuredWidth) {
if (text == null) {
throw new IllegalArgumentException("text cannot be null");
}
if (index < 0 || text.length - index < Math.abs(count)) {
throw new ArrayIndexOutOfBoundsException();
}
if (text.length == 0 || count == 0) {
return 0;
}
if (!mHasCompatScaling) {
return nBreakText(mNativePaint, text, index, count, maxWidth, mBidiFlags,
measuredWidth);
}
final float oldSize = getTextSize();
setTextSize(oldSize * mCompatScaling);
final int res = nBreakText(mNativePaint, text, index, count, maxWidth * mCompatScaling,
mBidiFlags, measuredWidth);
setTextSize(oldSize);
if (measuredWidth != null) measuredWidth[0] *= mInvCompatScaling;
return res;
}
/**
* Measure the text, stopping early if the measured width exceeds maxWidth.
* Return the number of chars that were measured, and if measuredWidth is
* not null, return in it the actual width measured.
*
* @param text The text to measure. Cannot be null.
* @param start The offset into text to begin measuring at
* @param end The end of the text slice to measure.
* @param measureForwards If true, measure forwards, starting at start.
* Otherwise, measure backwards, starting with end.
* @param maxWidth The maximum width to accumulate.
* @param measuredWidth Optional. If not null, returns the actual width
* measured.
* @return The number of chars that were measured. Will always be <=
* abs(end - start).
*/
public int breakText(CharSequence text, int start, int end,
boolean measureForwards,
float maxWidth, float[] measuredWidth) {
if (text == null) {
throw new IllegalArgumentException("text cannot be null");
}
if ((start | end | (end - start) | (text.length() - end)) < 0) {
throw new IndexOutOfBoundsException();
}
if (text.length() == 0 || start == end) {
return 0;
}
if (start == 0 && text instanceof String && end == text.length()) {
return breakText((String) text, measureForwards, maxWidth,
measuredWidth);
}
char[] buf = TemporaryBuffer.obtain(end - start);
int result;
TextUtils.getChars(text, start, end, buf, 0);
if (measureForwards) {
result = breakText(buf, 0, end - start, maxWidth, measuredWidth);
} else {
result = breakText(buf, 0, -(end - start), maxWidth, measuredWidth);
}
TemporaryBuffer.recycle(buf);
return result;
}
/**
* Measure the text, stopping early if the measured width exceeds maxWidth.
* Return the number of chars that were measured, and if measuredWidth is
* not null, return in it the actual width measured.
*
* @param text The text to measure. Cannot be null.
* @param measureForwards If true, measure forwards, starting with the
* first character in the string. Otherwise,
* measure backwards, starting with the
* last character in the string.
* @param maxWidth The maximum width to accumulate.
* @param measuredWidth Optional. If not null, returns the actual width
* measured.
* @return The number of chars that were measured. Will always be <=
* abs(count).
*/
public int breakText(String text, boolean measureForwards,
float maxWidth, float[] measuredWidth) {
if (text == null) {
throw new IllegalArgumentException("text cannot be null");
}
if (text.length() == 0) {
return 0;
}
if (!mHasCompatScaling) {
return nBreakText(mNativePaint, text, measureForwards,
maxWidth, mBidiFlags, measuredWidth);
}
final float oldSize = getTextSize();
setTextSize(oldSize*mCompatScaling);
final int res = nBreakText(mNativePaint, text, measureForwards, maxWidth*mCompatScaling,
mBidiFlags, measuredWidth);
setTextSize(oldSize);
if (measuredWidth != null) measuredWidth[0] *= mInvCompatScaling;
return res;
}
/**
* Return the advance widths for the characters in the string.
*
* @param text The text to measure. Cannot be null.
* @param index The index of the first char to to measure
* @param count The number of chars starting with index to measure
* @param widths array to receive the advance widths of the characters.
* Must be at least a large as count.
* @return the actual number of widths returned.
*/
public int getTextWidths(char[] text, int index, int count,
float[] widths) {
if (text == null) {
throw new IllegalArgumentException("text cannot be null");
}
if ((index | count) < 0 || index + count > text.length
|| count > widths.length) {
throw new ArrayIndexOutOfBoundsException();
}
if (text.length == 0 || count == 0) {
return 0;
}
int oldFlag = getFlags();
setFlags(getFlags() | (TEXT_RUN_FLAG_LEFT_EDGE | TEXT_RUN_FLAG_RIGHT_EDGE));
try {
if (!mHasCompatScaling) {
nGetTextAdvances(mNativePaint, text, index, count, index, count, mBidiFlags, widths,
0);
return count;
}
final float oldSize = getTextSize();
setTextSize(oldSize * mCompatScaling);
nGetTextAdvances(mNativePaint, text, index, count, index, count, mBidiFlags, widths, 0);
setTextSize(oldSize);
for (int i = 0; i < count; i++) {
widths[i] *= mInvCompatScaling;
}
return count;
} finally {
setFlags(oldFlag);
}
}
/**
* Return the advance widths for the characters in the string.
*
* @param text The text to measure. Cannot be null.
* @param start The index of the first char to to measure
* @param end The end of the text slice to measure
* @param widths array to receive the advance widths of the characters.
* Must be at least a large as (end - start).
* @return the actual number of widths returned.
*/
public int getTextWidths(CharSequence text, int start, int end,
float[] widths) {
if (text == null) {
throw new IllegalArgumentException("text cannot be null");
}
if ((start | end | (end - start) | (text.length() - end)) < 0) {
throw new IndexOutOfBoundsException();
}
if (end - start > widths.length) {
throw new ArrayIndexOutOfBoundsException();
}
if (text.length() == 0 || start == end) {
return 0;
}
if (text instanceof String) {
return getTextWidths((String) text, start, end, widths);
}
if (text instanceof SpannedString ||
text instanceof SpannableString) {
return getTextWidths(text.toString(), start, end, widths);
}
if (text instanceof GraphicsOperations) {
return ((GraphicsOperations) text).getTextWidths(start, end,
widths, this);
}
char[] buf = TemporaryBuffer.obtain(end - start);
TextUtils.getChars(text, start, end, buf, 0);
int result = getTextWidths(buf, 0, end - start, widths);
TemporaryBuffer.recycle(buf);
return result;
}
/**
* Return the advance widths for the characters in the string.
*
* @param text The text to measure. Cannot be null.
* @param start The index of the first char to to measure
* @param end The end of the text slice to measure
* @param widths array to receive the advance widths of the characters.
* Must be at least a large as the text.
* @return the number of code units in the specified text.
*/
public int getTextWidths(String text, int start, int end, float[] widths) {
if (text == null) {
throw new IllegalArgumentException("text cannot be null");
}
if ((start | end | (end - start) | (text.length() - end)) < 0) {
throw new IndexOutOfBoundsException();
}
if (end - start > widths.length) {
throw new ArrayIndexOutOfBoundsException();
}
if (text.length() == 0 || start == end) {
return 0;
}
int oldFlag = getFlags();
setFlags(getFlags() | (TEXT_RUN_FLAG_LEFT_EDGE | TEXT_RUN_FLAG_RIGHT_EDGE));
try {
if (!mHasCompatScaling) {
nGetTextAdvances(mNativePaint, text, start, end, start, end, mBidiFlags, widths, 0);
return end - start;
}
final float oldSize = getTextSize();
setTextSize(oldSize * mCompatScaling);
nGetTextAdvances(mNativePaint, text, start, end, start, end, mBidiFlags, widths, 0);
setTextSize(oldSize);
for (int i = 0; i < end - start; i++) {
widths[i] *= mInvCompatScaling;
}
return end - start;
} finally {
setFlags(oldFlag);
}
}
/**
* Return the advance widths for the characters in the string.
*
* @param text The text to measure
* @param widths array to receive the advance widths of the characters.
* Must be at least a large as the text.
* @return the number of code units in the specified text.
*/
public int getTextWidths(String text, float[] widths) {
return getTextWidths(text, 0, text.length(), widths);
}
/**
* Retrieve the character advances of the text.
*
* Returns the total advance width for the characters in the run from {@code index} for
* {@code count} of chars, and if {@code advances} is not null, the advance assigned to each of
* these characters (java chars).
*
* <p>
* The trailing surrogate in a valid surrogate pair is assigned an advance of 0. Thus the
* number of returned advances is always equal to count, not to the number of unicode codepoints
* represented by the run.
* </p>
*
* <p>
* In the case of conjuncts or combining marks, the total advance is assigned to the first
* logical character, and the following characters are assigned an advance of 0.
* </p>
*
* <p>
* This generates the sum of the advances of glyphs for characters in a reordered cluster as the
* width of the first logical character in the cluster, and 0 for the widths of all other
* characters in the cluster. In effect, such clusters are treated like conjuncts.
* </p>
*
* <p>
* The shaping bounds limit the amount of context available outside start and end that can be
* used for shaping analysis. These bounds typically reflect changes in bidi level or font
* metrics across which shaping does not occur.
* </p>
*
* @param chars the text to measure.
* @param index the index of the first character to measure
* @param count the number of characters to measure
* @param contextIndex the index of the first character to use for shaping context.
* Context must cover the measureing target.
* @param contextCount the number of character to use for shaping context.
* Context must cover the measureing target.
* @param isRtl whether the run is in RTL direction
* @param advances array to receive the advances, must have room for all advances.
* This can be null if only total advance is needed
* @param advancesIndex the position in advances at which to put the advance corresponding to
* the character at start
* @return the total advance in pixels
*/
public float getTextRunAdvances(@NonNull char[] chars, @IntRange(from = 0) int index,
@IntRange(from = 0) int count, @IntRange(from = 0) int contextIndex,
@IntRange(from = 0) int contextCount, boolean isRtl, @Nullable float[] advances,
@IntRange(from = 0) int advancesIndex) {
if (chars == null) {
throw new IllegalArgumentException("text cannot be null");
}
if ((index | count | contextIndex | contextCount | advancesIndex
| (index - contextIndex) | (contextCount - count)
| ((contextIndex + contextCount) - (index + count))
| (chars.length - (contextIndex + contextCount))
| (advances == null ? 0 :
(advances.length - (advancesIndex + count)))) < 0) {
throw new IndexOutOfBoundsException();
}
if (chars.length == 0 || count == 0){
return 0f;
}
if (!mHasCompatScaling) {
return nGetTextAdvances(mNativePaint, chars, index, count, contextIndex, contextCount,
isRtl ? BIDI_FORCE_RTL : BIDI_FORCE_LTR, advances,
advancesIndex);
}
final float oldSize = getTextSize();
setTextSize(oldSize * mCompatScaling);
final float res = nGetTextAdvances(mNativePaint, chars, index, count, contextIndex,
contextCount, isRtl ? BIDI_FORCE_RTL : BIDI_FORCE_LTR, advances, advancesIndex);
setTextSize(oldSize);
if (advances != null) {
for (int i = advancesIndex, e = i + count; i < e; i++) {
advances[i] *= mInvCompatScaling;
}
}
return res * mInvCompatScaling; // assume errors are not significant
}
/**
* Returns the next cursor position in the run.
*
* This avoids placing the cursor between surrogates, between characters that form conjuncts,
* between base characters and combining marks, or within a reordering cluster.
*
* <p>
* ContextStart and offset are relative to the start of text.
* The context is the shaping context for cursor movement, generally the bounds of the metric
* span enclosing the cursor in the direction of movement.
*
* <p>
* If cursorOpt is {@link #CURSOR_AT} and the offset is not a valid cursor position, this
* returns -1. Otherwise this will never return a value before contextStart or after
* contextStart + contextLength.
*
* @param text the text
* @param contextStart the start of the context
* @param contextLength the length of the context
* @param isRtl true if the paragraph context is RTL, otherwise false
* @param offset the cursor position to move from
* @param cursorOpt how to move the cursor
* @return the offset of the next position, or -1
*/
public int getTextRunCursor(@NonNull char[] text, @IntRange(from = 0) int contextStart,
@IntRange(from = 0) int contextLength, boolean isRtl, @IntRange(from = 0) int offset,
@CursorOption int cursorOpt) {
int contextEnd = contextStart + contextLength;
if (((contextStart | contextEnd | offset | (contextEnd - contextStart)
| (offset - contextStart) | (contextEnd - offset)
| (text.length - contextEnd) | cursorOpt) < 0)
|| cursorOpt > CURSOR_OPT_MAX_VALUE) {
throw new IndexOutOfBoundsException();
}
return nGetTextRunCursor(mNativePaint, text, contextStart, contextLength,
isRtl ? DIRECTION_RTL : DIRECTION_LTR, offset, cursorOpt);
}
/**
* Returns the next cursor position in the run.
*
* This avoids placing the cursor between surrogates, between characters that form conjuncts,
* between base characters and combining marks, or within a reordering cluster.
*
* <p>
* ContextStart, contextEnd, and offset are relative to the start of
* text. The context is the shaping context for cursor movement, generally
* the bounds of the metric span enclosing the cursor in the direction of
* movement.
*
* <p>
* If cursorOpt is {@link #CURSOR_AT} and the offset is not a valid cursor position, this
* returns -1. Otherwise this will never return a value before contextStart or after
* contextEnd.
*
* @param text the text
* @param contextStart the start of the context
* @param contextEnd the end of the context
* @param isRtl true if the paragraph context is RTL, otherwise false
* @param offset the cursor position to move from
* @param cursorOpt how to move the cursor
* @return the offset of the next position, or -1
*/
public int getTextRunCursor(@NonNull CharSequence text, @IntRange(from = 0) int contextStart,
@IntRange(from = 0) int contextEnd, boolean isRtl, @IntRange(from = 0) int offset,
@CursorOption int cursorOpt) {
if (text instanceof String || text instanceof SpannedString ||
text instanceof SpannableString) {
return getTextRunCursor(text.toString(), contextStart, contextEnd,
isRtl, offset, cursorOpt);
}
if (text instanceof GraphicsOperations) {
return ((GraphicsOperations) text).getTextRunCursor(
contextStart, contextEnd, isRtl, offset, cursorOpt, this);
}
int contextLen = contextEnd - contextStart;
char[] buf = TemporaryBuffer.obtain(contextLen);
TextUtils.getChars(text, contextStart, contextEnd, buf, 0);
int relPos = getTextRunCursor(buf, 0, contextLen, isRtl, offset - contextStart, cursorOpt);
TemporaryBuffer.recycle(buf);
return (relPos == -1) ? -1 : relPos + contextStart;
}
/**
* Returns the next cursor position in the run.
*
* This avoids placing the cursor between surrogates, between characters that form conjuncts,
* between base characters and combining marks, or within a reordering cluster.
*
* <p>
* ContextStart, contextEnd, and offset are relative to the start of text. The context is the
* shaping context for cursor movement, generally the bounds of the metric span enclosing the
* cursor in the direction of movement.
* </p>
*
* <p>
* If cursorOpt is {@link #CURSOR_AT} and the offset is not a valid cursor position, this
* returns -1. Otherwise this will never return a value before contextStart or after
* contextEnd.
* </p>
*
* @param text the text
* @param contextStart the start of the context
* @param contextEnd the end of the context
* @param isRtl true if the paragraph context is RTL, otherwise false.
* @param offset the cursor position to move from
* @param cursorOpt how to move the cursor
* @return the offset of the next position, or -1
* @hide
*/
public int getTextRunCursor(@NonNull String text, @IntRange(from = 0) int contextStart,
@IntRange(from = 0) int contextEnd, boolean isRtl, @IntRange(from = 0) int offset,
@CursorOption int cursorOpt) {
if (((contextStart | contextEnd | offset | (contextEnd - contextStart)
| (offset - contextStart) | (contextEnd - offset)
| (text.length() - contextEnd) | cursorOpt) < 0)
|| cursorOpt > CURSOR_OPT_MAX_VALUE) {
throw new IndexOutOfBoundsException();
}
return nGetTextRunCursor(mNativePaint, text, contextStart, contextEnd,
isRtl ? DIRECTION_RTL : DIRECTION_LTR, offset, cursorOpt);
}
/**
* Return the path (outline) for the specified text.
* Note: just like Canvas.drawText, this will respect the Align setting in
* the paint.
*
* @param text the text to retrieve the path from
* @param index the index of the first character in text
* @param count the number of characters starting with index
* @param x the x coordinate of the text's origin
* @param y the y coordinate of the text's origin
* @param path the path to receive the data describing the text. Must be allocated by the caller
*/
public void getTextPath(char[] text, int index, int count,
float x, float y, Path path) {
if ((index | count) < 0 || index + count > text.length) {
throw new ArrayIndexOutOfBoundsException();
}
nGetTextPath(mNativePaint, mBidiFlags, text, index, count, x, y, path.mutateNI());
}
/**
* Return the path (outline) for the specified text.
* Note: just like Canvas.drawText, this will respect the Align setting
* in the paint.
*
* @param text the text to retrieve the path from
* @param start the first character in the text
* @param end 1 past the last character in the text
* @param x the x coordinate of the text's origin
* @param y the y coordinate of the text's origin
* @param path the path to receive the data describing the text. Must be allocated by the caller
*/
public void getTextPath(String text, int start, int end,
float x, float y, Path path) {
if ((start | end | (end - start) | (text.length() - end)) < 0) {
throw new IndexOutOfBoundsException();
}
nGetTextPath(mNativePaint, mBidiFlags, text, start, end, x, y, path.mutateNI());
}
/**
* Retrieve the text boundary box and store to bounds.
*
* Return in bounds (allocated by the caller) the smallest rectangle that
* encloses all of the characters, with an implied origin at (0,0).
*
* @param text string to measure and return its bounds
* @param start index of the first char in the string to measure
* @param end 1 past the last char in the string to measure
* @param bounds returns the unioned bounds of all the text. Must be allocated by the caller
*/
public void getTextBounds(String text, int start, int end, Rect bounds) {
if ((start | end | (end - start) | (text.length() - end)) < 0) {
throw new IndexOutOfBoundsException();
}
if (bounds == null) {
throw new NullPointerException("need bounds Rect");
}
nGetStringBounds(mNativePaint, text, start, end, mBidiFlags, bounds);
}
/**
* Retrieve the text boundary box and store to bounds.
*
* Return in bounds (allocated by the caller) the smallest rectangle that
* encloses all of the characters, with an implied origin at (0,0).
*
* Note that styles are ignored even if you pass {@link android.text.Spanned} instance.
* Use {@link android.text.StaticLayout} for measuring bounds of {@link android.text.Spanned}.
*
* @param text text to measure and return its bounds
* @param start index of the first char in the text to measure
* @param end 1 past the last char in the text to measure
* @param bounds returns the unioned bounds of all the text. Must be allocated by the caller
*/
public void getTextBounds(@NonNull CharSequence text, int start, int end,
@NonNull Rect bounds) {
if ((start | end | (end - start) | (text.length() - end)) < 0) {
throw new IndexOutOfBoundsException();
}
if (bounds == null) {
throw new NullPointerException("need bounds Rect");
}
char[] buf = TemporaryBuffer.obtain(end - start);
TextUtils.getChars(text, start, end, buf, 0);
getTextBounds(buf, 0, end - start, bounds);
TemporaryBuffer.recycle(buf);
}
/**
* Return in bounds (allocated by the caller) the smallest rectangle that
* encloses all of the characters, with an implied origin at (0,0).
*
* @param text array of chars to measure and return their unioned bounds
* @param index index of the first char in the array to measure
* @param count the number of chars, beginning at index, to measure
* @param bounds returns the unioned bounds of all the text. Must be allocated by the caller
*/
public void getTextBounds(char[] text, int index, int count, Rect bounds) {
if ((index | count) < 0 || index + count > text.length) {
throw new ArrayIndexOutOfBoundsException();
}
if (bounds == null) {
throw new NullPointerException("need bounds Rect");
}
nGetCharArrayBounds(mNativePaint, text, index, count, mBidiFlags,
bounds);
}
/**
* Determine whether the typeface set on the paint has a glyph supporting the string. The
* simplest case is when the string contains a single character, in which this method
* determines whether the font has the character. In the case of multiple characters, the
* method returns true if there is a single glyph representing the ligature. For example, if
* the input is a pair of regional indicator symbols, determine whether there is an emoji flag
* for the pair.
*
* <p>Finally, if the string contains a variation selector, the method only returns true if
* the fonts contains a glyph specific to that variation.
*
* <p>Checking is done on the entire fallback chain, not just the immediate font referenced.
*
* @param string the string to test whether there is glyph support
* @return true if the typeface has a glyph for the string
*/
public boolean hasGlyph(String string) {
return nHasGlyph(mNativePaint, mBidiFlags, string);
}
/**
* Measure cursor position within a run of text.
*
* <p>The run of text includes the characters from {@code start} to {@code end} in the text. In
* addition, the range {@code contextStart} to {@code contextEnd} is used as context for the
* purpose of complex text shaping, such as Arabic text potentially shaped differently based on
* the text next to it.
*
* <p>All text outside the range {@code contextStart..contextEnd} is ignored. The text between
* {@code start} and {@code end} will be laid out to be measured.
*
* <p>The returned width measurement is the advance from {@code start} to {@code offset}. It is
* generally a positive value, no matter the direction of the run. If {@code offset == end},
* the return value is simply the width of the whole run from {@code start} to {@code end}.
*
* <p>Ligatures are formed for characters in the range {@code start..end} (but not for
* {@code start..contextStart} or {@code end..contextEnd}). If {@code offset} points to a
* character in the middle of such a formed ligature, but at a grapheme cluster boundary, the
* return value will also reflect an advance in the middle of the ligature. See
* {@link #getOffsetForAdvance} for more discussion of grapheme cluster boundaries.
*
* <p>The direction of the run is explicitly specified by {@code isRtl}. Thus, this method is
* suitable only for runs of a single direction.
*
* <p>All indices are relative to the start of {@code text}. Further, {@code 0 <= contextStart
* <= start <= offset <= end <= contextEnd <= text.length} must hold on entry.
*
* @param text the text to measure. Cannot be null.
* @param start the index of the start of the range to measure
* @param end the index + 1 of the end of the range to measure
* @param contextStart the index of the start of the shaping context
* @param contextEnd the index + 1 of the end of the shaping context
* @param isRtl whether the run is in RTL direction
* @param offset index of caret position
* @return width measurement between start and offset
*/
public float getRunAdvance(char[] text, int start, int end, int contextStart, int contextEnd,
boolean isRtl, int offset) {
if (text == null) {
throw new IllegalArgumentException("text cannot be null");
}
if ((contextStart | start | offset | end | contextEnd
| start - contextStart | offset - start | end - offset
| contextEnd - end | text.length - contextEnd) < 0) {
throw new IndexOutOfBoundsException();
}
if (end == start) {
return 0.0f;
}
// TODO: take mCompatScaling into account (or eliminate compat scaling)?
return nGetRunAdvance(mNativePaint, text, start, end, contextStart, contextEnd, isRtl,
offset);
}
/**
* @see #getRunAdvance(char[], int, int, int, int, boolean, int)
*
* @param text the text to measure. Cannot be null.
* @param start the index of the start of the range to measure
* @param end the index + 1 of the end of the range to measure
* @param contextStart the index of the start of the shaping context
* @param contextEnd the index + 1 of the end of the shaping context
* @param isRtl whether the run is in RTL direction
* @param offset index of caret position
* @return width measurement between start and offset
*/
public float getRunAdvance(CharSequence text, int start, int end, int contextStart,
int contextEnd, boolean isRtl, int offset) {
if (text == null) {
throw new IllegalArgumentException("text cannot be null");
}
if ((contextStart | start | offset | end | contextEnd
| start - contextStart | offset - start | end - offset
| contextEnd - end | text.length() - contextEnd) < 0) {
throw new IndexOutOfBoundsException();
}
if (end == start) {
return 0.0f;
}
// TODO performance: specialized alternatives to avoid buffer copy, if win is significant
char[] buf = TemporaryBuffer.obtain(contextEnd - contextStart);
TextUtils.getChars(text, contextStart, contextEnd, buf, 0);
float result = getRunAdvance(buf, start - contextStart, end - contextStart, 0,
contextEnd - contextStart, isRtl, offset - contextStart);
TemporaryBuffer.recycle(buf);
return result;
}
/**
* Measure the advance of each character within a run of text and also return the cursor
* position within the run.
*
* @see #getRunAdvance(char[], int, int, int, int, boolean, int) for more details.
*
* @param text the text to measure. Cannot be null.
* @param start the start index of the range to measure, inclusive
* @param end the end index of the range to measure, exclusive
* @param contextStart the start index of the shaping context, inclusive
* @param contextEnd the end index of the shaping context, exclusive
* @param isRtl whether the run is in RTL direction
* @param offset index of caret position
* @param advances the array that receives the computed character advances
* @param advancesIndex the start index from which the advances array is filled
* @return width measurement between start and offset
* @throws IndexOutOfBoundsException if a) contextStart or contextEnd is out of array's range
* or contextStart is larger than contextEnd,
* b) start or end is not within the range [contextStart, contextEnd), or start is larger than
* end,
* c) offset is not within the range [start, end),
* d) advances.length - advanceIndex is smaller than the length of the run, which equals to
* end - start.
*
*/
public float getRunCharacterAdvance(@NonNull char[] text, int start, int end, int contextStart,
int contextEnd, boolean isRtl, int offset,
@Nullable float[] advances, int advancesIndex) {
return getRunCharacterAdvance(text, start, end, contextStart, contextEnd, isRtl, offset,
advances, advancesIndex, null, null);
}
/**
* Measure the advance of each character within a run of text and also return the cursor
* position within the run.
*
* @see #getRunAdvance(char[], int, int, int, int, boolean, int) for more details.
*
* @param text the text to measure. Cannot be null.
* @param start the start index of the range to measure, inclusive
* @param end the end index of the range to measure, exclusive
* @param contextStart the start index of the shaping context, inclusive
* @param contextEnd the end index of the shaping context, exclusive
* @param isRtl whether the run is in RTL direction
* @param offset index of caret position
* @param advances the array that receives the computed character advances
* @param advancesIndex the start index from which the advances array is filled
* @param drawBounds the output parameter for the bounding box of drawing text, optional
* @param runInfo the output parameter for storing run information.
* @return width measurement between start and offset
* @hide TODO: Reorganize APIs
*/
public float getRunCharacterAdvance(@NonNull char[] text, int start, int end, int contextStart,
int contextEnd, boolean isRtl, int offset,
@Nullable float[] advances, int advancesIndex, @Nullable RectF drawBounds,
@Nullable RunInfo runInfo) {
if (text == null) {
throw new IllegalArgumentException("text cannot be null");
}
if (contextStart < 0 || contextEnd > text.length) {
throw new IndexOutOfBoundsException("Invalid Context Range: " + contextStart + ", "
+ contextEnd + " must be in 0, " + text.length);
}
if (start < contextStart || contextEnd < end) {
throw new IndexOutOfBoundsException("Invalid start/end range: " + start + ", " + end
+ " must be in " + contextStart + ", " + contextEnd);
}
if (offset < start || end < offset) {
throw new IndexOutOfBoundsException("Invalid offset position: " + offset
+ " must be in " + start + ", " + end);
}
if (advances != null && advances.length < advancesIndex - start + end) {
throw new IndexOutOfBoundsException("Given array doesn't have enough space to receive "
+ "the result, advances.length: " + advances.length + " advanceIndex: "
+ advancesIndex + " needed space: " + (offset - start));
}
if (end == start) {
if (runInfo != null) {
runInfo.setClusterCount(0);
}
return 0.0f;
}
return nGetRunCharacterAdvance(mNativePaint, text, start, end, contextStart, contextEnd,
isRtl, offset, advances, advancesIndex, drawBounds, runInfo);
}
/**
* @see #getRunCharacterAdvance(char[], int, int, int, int, boolean, int, float[], int)
*
* @param text the text to measure. Cannot be null.
* @param start the index of the start of the range to measure
* @param end the index + 1 of the end of the range to measure
* @param contextStart the index of the start of the shaping context
* @param contextEnd the index + 1 of the end of the shaping context
* @param isRtl whether the run is in RTL direction
* @param offset index of caret position
* @param advances the array that receives the computed character advances
* @param advancesIndex the start index from which the advances array is filled
* @return width measurement between start and offset
* @throws IndexOutOfBoundsException if a) contextStart or contextEnd is out of array's range
* or contextStart is larger than contextEnd,
* b) start or end is not within the range [contextStart, contextEnd), or end is larger than
* start,
* c) offset is not within the range [start, end),
* d) advances.length - advanceIndex is smaller than the run length, which equals to
* end - start.
*/
public float getRunCharacterAdvance(@NonNull CharSequence text, int start, int end,
int contextStart, int contextEnd, boolean isRtl, int offset,
@Nullable float[] advances, int advancesIndex) {
return getRunCharacterAdvance(text, start, end, contextStart, contextEnd, isRtl, offset,
advances, advancesIndex, null, null);
}
/**
* @see #getRunCharacterAdvance(char[], int, int, int, int, boolean, int, float[], int)
*
* @param text the text to measure. Cannot be null.
* @param start the index of the start of the range to measure
* @param end the index + 1 of the end of the range to measure
* @param contextStart the index of the start of the shaping context
* @param contextEnd the index + 1 of the end of the shaping context
* @param isRtl whether the run is in RTL direction
* @param offset index of caret position
* @param advances the array that receives the computed character advances
* @param advancesIndex the start index from which the advances array is filled
* @param drawBounds the output parameter for the bounding box of drawing text, optional
* @param runInfo an optional output parameter for filling run information.
* @return width measurement between start and offset
* @hide TODO: Reorganize APIs
*/
public float getRunCharacterAdvance(@NonNull CharSequence text, int start, int end,
int contextStart, int contextEnd, boolean isRtl, int offset,
@Nullable float[] advances, int advancesIndex, @Nullable RectF drawBounds,
@Nullable RunInfo runInfo) {
if (text == null) {
throw new IllegalArgumentException("text cannot be null");
}
if (contextStart < 0 || contextEnd > text.length()) {
throw new IndexOutOfBoundsException("Invalid Context Range: " + contextStart + ", "
+ contextEnd + " must be in 0, " + text.length());
}
if (start < contextStart || contextEnd < end) {
throw new IndexOutOfBoundsException("Invalid start/end range: " + start + ", " + end
+ " must be in " + contextStart + ", " + contextEnd);
}
if (offset < start || end < offset) {
throw new IndexOutOfBoundsException("Invalid offset position: " + offset
+ " must be in " + start + ", " + end);
}
if (advances != null && advances.length < advancesIndex - start + end) {
throw new IndexOutOfBoundsException("Given array doesn't have enough space to receive "
+ "the result, advances.length: " + advances.length + " advanceIndex: "
+ advancesIndex + " needed space: " + (offset - start));
}
if (end == start) {
return 0.0f;
}
char[] buf = TemporaryBuffer.obtain(contextEnd - contextStart);
TextUtils.getChars(text, contextStart, contextEnd, buf, 0);
final float result = getRunCharacterAdvance(buf, start - contextStart, end - contextStart,
0, contextEnd - contextStart, isRtl, offset - contextStart,
advances, advancesIndex, drawBounds, runInfo);
TemporaryBuffer.recycle(buf);
return result;
}
/**
* Get the character offset within the string whose position is closest to the specified
* horizontal position.
*
* <p>The returned value is generally the value of {@code offset} for which
* {@link #getRunAdvance} yields a result most closely approximating {@code advance},
* and which is also on a grapheme cluster boundary. As such, it is the preferred method
* for positioning a cursor in response to a touch or pointer event. The grapheme cluster
* boundaries are based on
* <a href="http://unicode.org/reports/tr29/">Unicode Standard Annex #29</a> but with some
* tailoring for better user experience.
*
* <p>Note that {@code advance} is a (generally positive) width measurement relative to the start
* of the run. Thus, for RTL runs it the distance from the point to the right edge.
*
* <p>All indices are relative to the start of {@code text}. Further, {@code 0 <= contextStart
* <= start <= end <= contextEnd <= text.length} must hold on entry, and {@code start <= result
* <= end} will hold on return.
*
* @param text the text to measure. Cannot be null.
* @param start the index of the start of the range to measure
* @param end the index + 1 of the end of the range to measure
* @param contextStart the index of the start of the shaping context
* @param contextEnd the index + 1 of the end of the range to measure
* @param isRtl whether the run is in RTL direction
* @param advance width relative to start of run
* @return index of offset
*/
public int getOffsetForAdvance(char[] text, int start, int end, int contextStart,
int contextEnd, boolean isRtl, float advance) {
if (text == null) {
throw new IllegalArgumentException("text cannot be null");
}
if ((contextStart | start | end | contextEnd
| start - contextStart | end - start | contextEnd - end
| text.length - contextEnd) < 0) {
throw new IndexOutOfBoundsException();
}
// TODO: take mCompatScaling into account (or eliminate compat scaling)?
return nGetOffsetForAdvance(mNativePaint, text, start, end, contextStart, contextEnd,
isRtl, advance);
}
/**
* @see #getOffsetForAdvance(char[], int, int, int, int, boolean, float)
*
* @param text the text to measure. Cannot be null.
* @param start the index of the start of the range to measure
* @param end the index + 1 of the end of the range to measure
* @param contextStart the index of the start of the shaping context
* @param contextEnd the index + 1 of the end of the range to measure
* @param isRtl whether the run is in RTL direction
* @param advance width relative to start of run
* @return index of offset
*/
public int getOffsetForAdvance(CharSequence text, int start, int end, int contextStart,
int contextEnd, boolean isRtl, float advance) {
if (text == null) {
throw new IllegalArgumentException("text cannot be null");
}
if ((contextStart | start | end | contextEnd
| start - contextStart | end - start | contextEnd - end
| text.length() - contextEnd) < 0) {
throw new IndexOutOfBoundsException();
}
// TODO performance: specialized alternatives to avoid buffer copy, if win is significant
char[] buf = TemporaryBuffer.obtain(contextEnd - contextStart);
TextUtils.getChars(text, contextStart, contextEnd, buf, 0);
int result = getOffsetForAdvance(buf, start - contextStart, end - contextStart, 0,
contextEnd - contextStart, isRtl, advance) + contextStart;
TemporaryBuffer.recycle(buf);
return result;
}
/**
* Returns true of the passed {@link Paint} will have the same effect on text measurement
*
* @param other A {@link Paint} object.
* @return true if the other {@link Paint} has the same effect on text measurement.
*/
public boolean equalsForTextMeasurement(@NonNull Paint other) {
return nEqualsForTextMeasurement(mNativePaint, other.mNativePaint);
}
// regular JNI
private static native long nGetNativeFinalizer();
private static native long nInit();
private static native long nInitWithPaint(long paint);
private static native int nBreakText(long nObject, char[] text, int index, int count,
float maxWidth, int bidiFlags, float[] measuredWidth);
private static native int nBreakText(long nObject, String text, boolean measureForwards,
float maxWidth, int bidiFlags, float[] measuredWidth);
private static native float nGetTextAdvances(long paintPtr, char[] text, int index, int count,
int contextIndex, int contextCount, int bidiFlags, float[] advances, int advancesIndex);
private static native float nGetTextAdvances(long paintPtr, String text, int start, int end,
int contextStart, int contextEnd, int bidiFlags, float[] advances, int advancesIndex);
private native int nGetTextRunCursor(long paintPtr, char[] text, int contextStart,
int contextLength, int dir, int offset, int cursorOpt);
private native int nGetTextRunCursor(long paintPtr, String text, int contextStart,
int contextEnd, int dir, int offset, int cursorOpt);
private static native void nGetTextPath(long paintPtr, int bidiFlags, char[] text, int index,
int count, float x, float y, long path);
private static native void nGetTextPath(long paintPtr, int bidiFlags, String text, int start,
int end, float x, float y, long path);
private static native void nGetStringBounds(long nativePaint, String text, int start, int end,
int bidiFlags, Rect bounds);
private static native void nGetCharArrayBounds(long nativePaint, char[] text, int index,
int count, int bidiFlags, Rect bounds);
private static native boolean nHasGlyph(long paintPtr, int bidiFlags, String string);
private static native float nGetRunAdvance(long paintPtr, char[] text, int start, int end,
int contextStart, int contextEnd, boolean isRtl, int offset);
private static native float nGetRunCharacterAdvance(long paintPtr, char[] text, int start,
int end, int contextStart, int contextEnd, boolean isRtl, int offset, float[] advances,
int advancesIndex, RectF drawingBounds, RunInfo runInfo);
private static native int nGetOffsetForAdvance(long paintPtr, char[] text, int start, int end,
int contextStart, int contextEnd, boolean isRtl, float advance);
private static native void nGetFontMetricsIntForText(long paintPtr, char[] text,
int start, int count, int ctxStart, int ctxCount, boolean isRtl,
FontMetricsInt outMetrics);
private static native void nGetFontMetricsIntForText(long paintPtr, String text,
int start, int count, int ctxStart, int ctxCount, boolean isRtl,
FontMetricsInt outMetrics);
// ---------------- @FastNative ------------------------
@FastNative
private static native int nSetTextLocales(long paintPtr, String locales);
@FastNative
private static native void nSetFontFeatureSettings(long paintPtr, String settings);
@FastNative
private static native float nGetFontMetrics(long paintPtr, FontMetrics metrics,
boolean useLocale);
@FastNative
private static native int nGetFontMetricsInt(long paintPtr, FontMetricsInt fmi,
boolean useLocale);
// ---------------- @CriticalNative ------------------------
@CriticalNative
private static native void nReset(long paintPtr);
@CriticalNative
private static native void nSet(long paintPtrDest, long paintPtrSrc);
@CriticalNative
private static native int nGetStyle(long paintPtr);
@CriticalNative
private static native void nSetStyle(long paintPtr, int style);
@CriticalNative
private static native int nGetStrokeCap(long paintPtr);
@CriticalNative
private static native void nSetStrokeCap(long paintPtr, int cap);
@CriticalNative
private static native int nGetStrokeJoin(long paintPtr);
@CriticalNative
private static native void nSetStrokeJoin(long paintPtr, int join);
@CriticalNative
private static native boolean nGetFillPath(long paintPtr, long src, long dst);
@CriticalNative
private static native long nSetShader(long paintPtr, long shader);
@CriticalNative
private static native long nSetColorFilter(long paintPtr, long filter);
@CriticalNative
private static native void nSetXfermode(long paintPtr, int xfermode);
@CriticalNative
private static native long nSetPathEffect(long paintPtr, long effect);
@CriticalNative
private static native long nSetMaskFilter(long paintPtr, long maskfilter);
@CriticalNative
private static native void nSetTypeface(long paintPtr, long typeface);
@CriticalNative
private static native int nGetTextAlign(long paintPtr);
@CriticalNative
private static native void nSetTextAlign(long paintPtr, int align);
@CriticalNative
private static native void nSetTextLocalesByMinikinLocaleListId(long paintPtr,
int mMinikinLocaleListId);
@CriticalNative
private static native void nSetShadowLayer(long paintPtr,
float radius, float dx, float dy, long colorSpaceHandle,
@ColorLong long shadowColor);
@CriticalNative
private static native boolean nHasShadowLayer(long paintPtr);
@CriticalNative
private static native float nGetLetterSpacing(long paintPtr);
@CriticalNative
private static native void nSetLetterSpacing(long paintPtr, float letterSpacing);
@CriticalNative
private static native float nGetWordSpacing(long paintPtr);
@CriticalNative
private static native void nSetWordSpacing(long paintPtr, float wordSpacing);
@CriticalNative
private static native int nGetStartHyphenEdit(long paintPtr);
@CriticalNative
private static native int nGetEndHyphenEdit(long paintPtr);
@CriticalNative
private static native void nSetStartHyphenEdit(long paintPtr, int hyphen);
@CriticalNative
private static native void nSetEndHyphenEdit(long paintPtr, int hyphen);
@CriticalNative
private static native void nSetStrokeMiter(long paintPtr, float miter);
@CriticalNative
private static native float nGetStrokeMiter(long paintPtr);
@CriticalNative
private static native void nSetStrokeWidth(long paintPtr, float width);
@CriticalNative
private static native float nGetStrokeWidth(long paintPtr);
@CriticalNative
private static native void nSetAlpha(long paintPtr, int a);
@CriticalNative
private static native void nSetDither(long paintPtr, boolean dither);
@CriticalNative
private static native int nGetFlags(long paintPtr);
@CriticalNative
private static native void nSetFlags(long paintPtr, int flags);
@CriticalNative
private static native int nGetHinting(long paintPtr);
@CriticalNative
private static native void nSetHinting(long paintPtr, int mode);
@CriticalNative
private static native void nSetAntiAlias(long paintPtr, boolean aa);
@CriticalNative
private static native void nSetLinearText(long paintPtr, boolean linearText);
@CriticalNative
private static native void nSetSubpixelText(long paintPtr, boolean subpixelText);
@CriticalNative
private static native void nSetUnderlineText(long paintPtr, boolean underlineText);
@CriticalNative
private static native void nSetFakeBoldText(long paintPtr, boolean fakeBoldText);
@CriticalNative
private static native void nSetFilterBitmap(long paintPtr, boolean filter);
@CriticalNative
private static native void nSetColor(long paintPtr, long colorSpaceHandle,
@ColorLong long color);
@CriticalNative
private static native void nSetColor(long paintPtr, @ColorInt int color);
@CriticalNative
private static native void nSetStrikeThruText(long paintPtr, boolean strikeThruText);
@CriticalNative
private static native int nGetElegantTextHeight(long paintPtr);
@CriticalNative
private static native void nSetElegantTextHeight(long paintPtr, int elegant);
@CriticalNative
private static native float nGetTextSize(long paintPtr);
@CriticalNative
private static native float nGetTextScaleX(long paintPtr);
@CriticalNative
private static native void nSetTextScaleX(long paintPtr, float scaleX);
@CriticalNative
private static native float nGetTextSkewX(long paintPtr);
@CriticalNative
private static native void nSetTextSkewX(long paintPtr, float skewX);
@CriticalNative
private static native float nAscent(long paintPtr);
@CriticalNative
private static native float nDescent(long paintPtr);
@CriticalNative
private static native float nGetUnderlinePosition(long paintPtr);
@CriticalNative
private static native float nGetUnderlineThickness(long paintPtr);
@CriticalNative
private static native float nGetStrikeThruPosition(long paintPtr);
@CriticalNative
private static native float nGetStrikeThruThickness(long paintPtr);
@CriticalNative
private static native void nSetTextSize(long paintPtr, float textSize);
@CriticalNative
private static native boolean nEqualsForTextMeasurement(long leftPaintPtr, long rightPaintPtr);
// Following Native methods are kept for old Robolectric JNI signature used by
// SystemUIGoogleRoboRNGTests
private static native float nGetRunCharacterAdvance(long paintPtr, char[] text,
int start, int end, int contextStart, int contextEnd, boolean isRtl, int offset,
float[] advances, int advancesIndex, RectF drawingBounds);
}
Reference in New Issue Copy Permalink