File	Doc	Category	Size	Date	Package
Paint.java	API Doc	Android 5.1 API	84539	Thu Mar 12 22:22:30 GMT 2015	android.graphics

Paint

• java.lang.Object

Fields Summary
public long	mNativePaint
public long	mNativeTypeface
private ColorFilter	mColorFilter
private MaskFilter	mMaskFilter
private PathEffect	mPathEffect
private Rasterizer	mRasterizer
private Shader	mShader
private Typeface	mTypeface
private Xfermode	mXfermode
private boolean	mHasCompatScaling
private float	mCompatScaling
private float	mInvCompatScaling
private Locale	mLocale
private String	mFontFeatureSettings
public int	mBidiFlags
static final Style[]	sStyleArray
static final Cap[]	sCapArray
static final Join[]	sJoinArray
static final Align[]	sAlignArray
public static final int	ANTI_ALIAS_FLAG Paint flag that enables antialiasing when drawing. Enabling this flag will cause all draw operations that support antialiasing to use it.
public static final int	FILTER_BITMAP_FLAG Paint flag that enables bilinear sampling on scaled bitmaps. 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. If bitmaps are scaled for device density at creation time (as resource bitmaps often are) the filtering will already have been done.
public static final int	DITHER_FLAG Paint flag that enables dithering when blitting. Enabling this flag applies a dither to any blit operation where the target's colour space is more constrained than the source.
public static final int	UNDERLINE_TEXT_FLAG Paint flag that applies an underline decoration to drawn text.
public static final int	STRIKE_THRU_TEXT_FLAG Paint flag that applies a strike-through decoration to drawn text.
public static final int	FAKE_BOLD_TEXT_FLAG Paint flag that applies a synthetic bolding effect to drawn text. Enabling this flag will cause text draw operations to apply a simulated bold effect when drawing a {@link Typeface} that is not already bold.
public static final int	LINEAR_TEXT_FLAG Paint flag that enables smooth linear scaling of text. 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. {@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.
public static final int	SUBPIXEL_TEXT_FLAG Paint flag that enables subpixel positioning of text. Enabling this flag causes glyph advances to be computed with subpixel accuracy. This can be used with {@link #LINEAR_TEXT_FLAG} to prevent text from jittering during smooth scale transitions.
public static final int	DEV_KERN_TEXT_FLAG Legacy Paint flag, no longer used.
public static final int	LCD_RENDER_TEXT_FLAG
public static final int	EMBEDDED_BITMAP_TEXT_FLAG Paint flag that enables the use of bitmap fonts when drawing text. 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.
public static final int	AUTO_HINTING_TEXT_FLAG
public static final int	VERTICAL_TEXT_FLAG
static final int	DEFAULT_PAINT_FLAGS
public static final int	HINTING_OFF Font hinter option that disables font hinting.
public static final int	HINTING_ON Font hinter option that enables font hinting.
public static final int	BIDI_LTR Bidi flag to set LTR paragraph direction.
public static final int	BIDI_RTL Bidi flag to set RTL paragraph direction.
public static final int	BIDI_DEFAULT_LTR Bidi flag to detect paragraph direction via heuristics, defaulting to LTR.
public static final int	BIDI_DEFAULT_RTL Bidi flag to detect paragraph direction via heuristics, defaulting to RTL.
public static final int	BIDI_FORCE_LTR Bidi flag to override direction to all LTR (ignore bidi).
public static final int	BIDI_FORCE_RTL Bidi flag to override direction to all RTL (ignore bidi).
private static final int	BIDI_MAX_FLAG_VALUE Maximum Bidi flag value.
private static final int	BIDI_FLAG_MASK Mask for bidi flags.
public static final int	DIRECTION_LTR Flag for getTextRunAdvances indicating left-to-right run direction.
public static final int	DIRECTION_RTL Flag for getTextRunAdvances indicating right-to-left run direction.
public static final int	CURSOR_AFTER Option for getTextRunCursor to compute the valid cursor after offset or the limit of the context, whichever is less.
public static final int	CURSOR_AT_OR_AFTER Option for getTextRunCursor to compute the valid cursor at or after the offset or the limit of the context, whichever is less.
public static final int	CURSOR_BEFORE Option for getTextRunCursor to compute the valid cursor before offset or the start of the context, whichever is greater.
public static final int	CURSOR_AT_OR_BEFORE Option for getTextRunCursor to compute the valid cursor at or before offset or the start of the context, whichever is greater.
public static final int	CURSOR_AT Option for getTextRunCursor to return offset if the cursor at offset is valid, or -1 if it isn't.
private static final int	CURSOR_OPT_MAX_VALUE Maximum cursor option value.

Constructors Summary
public Paint() Create a new paint with default settings. this(0);
public Paint(int flags) Create a new paint with the specified flags. Use setFlags() to change these after the paint is created. param flags initial flag bits, as if they were passed via setFlags(). mNativePaint = native_init(); setFlags(flags | 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; setTextLocale(Locale.getDefault());
public Paint(Paint paint) 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. mNativePaint = native_initWithPaint(paint.mNativePaint); setClassVariablesFrom(paint);

Methods Summary
public native float	ascent() Return the distance above (negative) the baseline (ascent) based on the current typeface and text size. return the distance above (negative) the baseline (ascent) based on the current typeface and text size.
public int	breakText(char[] text, int index, int count, float maxWidth, float[] measuredWidth) 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). 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 native_breakText(mNativePaint, mNativeTypeface, text, index, count, maxWidth, mBidiFlags, measuredWidth); } final float oldSize = getTextSize(); setTextSize(oldSize * mCompatScaling); int res = native_breakText(mNativePaint, mNativeTypeface, text, index, count, maxWidth * mCompatScaling, mBidiFlags, measuredWidth); setTextSize(oldSize); if (measuredWidth != null) measuredWidth[0] *= mInvCompatScaling; return res;
public int	breakText(java.lang.CharSequence text, int start, int end, boolean measureForwards, float maxWidth, float[] measuredWidth) 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). 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;
public int	breakText(java.lang.String text, boolean measureForwards, float maxWidth, float[] measuredWidth) 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). if (text == null) { throw new IllegalArgumentException("text cannot be null"); } if (text.length() == 0) { return 0; } if (!mHasCompatScaling) { return native_breakText(mNativePaint, mNativeTypeface, text, measureForwards, maxWidth, mBidiFlags, measuredWidth); } final float oldSize = getTextSize(); setTextSize(oldSize*mCompatScaling); int res = native_breakText(mNativePaint, mNativeTypeface, text, measureForwards, maxWidth*mCompatScaling, mBidiFlags, measuredWidth); setTextSize(oldSize); if (measuredWidth != null) measuredWidth[0] *= mInvCompatScaling; return res;
public void	clearShadowLayer() Clear the shadow layer. setShadowLayer(0, 0, 0, 0);
public native float	descent() Return the distance below (positive) the baseline (descent) based on the current typeface and text size. return the distance below (positive) the baseline (descent) based on the current typeface and text size.
protected void	finalize() try { finalizer(mNativePaint); } finally { super.finalize(); }
private static native void	finalizer(long nativePaint)
public native int	getAlpha() 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	getBidiFlags() Return the bidi flags on the paint. return the bidi flags on the paint hide return mBidiFlags;
public native int	getColor() Return the paint's color. 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).
public ColorFilter	getColorFilter() Get the paint's colorfilter (maybe be null). return the paint's colorfilter (maybe be null) return mColorFilter;
public boolean	getFillPath(Path src, Path dst) 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) return native_getFillPath(mNativePaint, src.ni(), dst.ni());
public native int	getFlags() 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 java.lang.String	getFontFeatureSettings() Get font feature settings. Default is null. return the paint's currently set font feature settings. return mFontFeatureSettings;
public native float	getFontMetrics(android.graphics.Paint$FontMetrics metrics) 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. 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 android.graphics.Paint$FontMetrics	getFontMetrics() Allocates a new FontMetrics object, and then calls getFontMetrics(fm) with it, returning the object. FontMetrics fm = new FontMetrics(); getFontMetrics(fm); return fm;
public native int	getFontMetricsInt(android.graphics.Paint$FontMetricsInt fmi) 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(). return the font's interline spacing.
public android.graphics.Paint$FontMetricsInt	getFontMetricsInt() FontMetricsInt fm = new FontMetricsInt(); getFontMetricsInt(fm); return fm;
public float	getFontSpacing() Return the recommend line spacing based on the current typeface and text size. return recommend line spacing based on the current typeface and text size. return getFontMetrics(null);
public native int	getHinting() Return the paint's hinting mode. Returns either {@link #HINTING_OFF} or {@link #HINTING_ON}.
public float	getLetterSpacing() Return the paint's letter-spacing for text. The default value is 0. return the paint's letter-spacing for drawing text. return native_getLetterSpacing(mNativePaint);
public MaskFilter	getMaskFilter() Get the paint's maskfilter object. return the paint's maskfilter (or null) return mMaskFilter;
public PathEffect	getPathEffect() Get the paint's patheffect object. return the paint's patheffect (or null) return mPathEffect;
public Rasterizer	getRasterizer() Get the paint's rasterizer (or null). 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. return mRasterizer;
public Shader	getShader() Get the paint's shader object. return the paint's shader (or null) return mShader;
public android.graphics.Paint$Cap	getStrokeCap() 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. return sCapArray[native_getStrokeCap(mNativePaint)];
public android.graphics.Paint$Join	getStrokeJoin() Return the paint's stroke join type. return the paint's Join. return sJoinArray[native_getStrokeJoin(mNativePaint)];
public native float	getStrokeMiter() 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 native float	getStrokeWidth() Return the width for stroking. A value of 0 strokes in hairline mode. Hairlines always draws a single pixel independent of the canva's matrix. return the paint's stroke width, used whenever the paint's style is Stroke or StrokeAndFill.
public android.graphics.Paint$Style	getStyle() 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) return sStyleArray[native_getStyle(mNativePaint)];
public android.graphics.Paint$Align	getTextAlign() 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 specifieds the LEFT edge of the text) and so on. return the paint's Align value for drawing text. return sAlignArray[native_getTextAlign(mNativePaint)];
public void	getTextBounds(java.lang.String text, int start, int end, Rect 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 measure param bounds Returns the unioned bounds of all the text. Must be allocated by the caller. if ((start | end | (end - start) | (text.length() - end)) < 0) { throw new IndexOutOfBoundsException(); } if (bounds == null) { throw new NullPointerException("need bounds Rect"); } nativeGetStringBounds(mNativePaint, mNativeTypeface, text, start, end, mBidiFlags, bounds);
public void	getTextBounds(char[] text, int index, int count, Rect 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 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. if ((index | count) < 0 || index + count > text.length) { throw new ArrayIndexOutOfBoundsException(); } if (bounds == null) { throw new NullPointerException("need bounds Rect"); } nativeGetCharArrayBounds(mNativePaint, mNativeTypeface, text, index, count, mBidiFlags, bounds);
public java.util.Locale	getTextLocale() Get the text Locale. return the paint's Locale used for drawing text, never null. return mLocale;
public void	getTextPath(char[] text, int index, int count, float x, float y, Path path) 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 characterss 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. if ((index | count) < 0 || index + count > text.length) { throw new ArrayIndexOutOfBoundsException(); } native_getTextPath(mNativePaint, mNativeTypeface, mBidiFlags, text, index, count, x, y, path.ni());
public void	getTextPath(java.lang.String text, int start, int end, float x, float y, Path path) 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 charcter 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. if ((start | end | (end - start) | (text.length() - end)) < 0) { throw new IndexOutOfBoundsException(); } native_getTextPath(mNativePaint, mNativeTypeface, mBidiFlags, text, start, end, x, y, path.ni());
public float	getTextRunAdvances(char[] chars, int index, int count, int contextIndex, int contextCount, boolean isRtl, float[] advances, int advancesIndex) Convenience overload that takes a char array instead of a String. see #getTextRunAdvances(String, int, int, int, int, int, float[], int) hide 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 native_getTextRunAdvances(mNativePaint, mNativeTypeface, chars, index, count, contextIndex, contextCount, isRtl, advances, advancesIndex); } final float oldSize = getTextSize(); setTextSize(oldSize * mCompatScaling); float res = native_getTextRunAdvances(mNativePaint, mNativeTypeface, chars, index, count, contextIndex, contextCount, isRtl, 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
public float	getTextRunAdvances(java.lang.CharSequence text, int start, int end, int contextStart, int contextEnd, boolean isRtl, float[] advances, int advancesIndex) Convenience overload that takes a CharSequence instead of a String. see #getTextRunAdvances(String, int, int, int, int, int, float[], int) hide if (text == null) { throw new IllegalArgumentException("text cannot be null"); } if ((start | end | contextStart | contextEnd | advancesIndex | (end - start) | (start - contextStart) | (contextEnd - end) | (text.length() - contextEnd) | (advances == null ? 0 : (advances.length - advancesIndex - (end - start)))) < 0) { throw new IndexOutOfBoundsException(); } if (text instanceof String) { return getTextRunAdvances((String) text, start, end, contextStart, contextEnd, isRtl, advances, advancesIndex); } if (text instanceof SpannedString || text instanceof SpannableString) { return getTextRunAdvances(text.toString(), start, end, contextStart, contextEnd, isRtl, advances, advancesIndex); } if (text instanceof GraphicsOperations) { return ((GraphicsOperations) text).getTextRunAdvances(start, end, contextStart, contextEnd, isRtl, advances, advancesIndex, this); } if (text.length() == 0 || end == start) { return 0f; } int contextLen = contextEnd - contextStart; int len = end - start; char[] buf = TemporaryBuffer.obtain(contextLen); TextUtils.getChars(text, contextStart, contextEnd, buf, 0); float result = getTextRunAdvances(buf, start - contextStart, len, 0, contextLen, isRtl, advances, advancesIndex); TemporaryBuffer.recycle(buf); return result;
public float	getTextRunAdvances(java.lang.String text, int start, int end, int contextStart, int contextEnd, boolean isRtl, float[] advances, int advancesIndex) Returns the total advance width for the characters in the run between start and end, and if advances is not null, the advance assigned to each of these characters (java chars). 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. 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. 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. 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. param text the text to measure. Cannot be null. param start the index of the first character to measure param end the index past the last character to measure param contextStart the index of the first character to use for shaping context, must be <= start param contextEnd the index past the last character to use for shaping context, must be >= end param isRtl whether the run is in RTL direction param advances array to receive the advances, must have room for all advances, 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 hide if (text == null) { throw new IllegalArgumentException("text cannot be null"); } if ((start | end | contextStart | contextEnd | advancesIndex | (end - start) | (start - contextStart) | (contextEnd - end) | (text.length() - contextEnd) | (advances == null ? 0 : (advances.length - advancesIndex - (end - start)))) < 0) { throw new IndexOutOfBoundsException(); } if (text.length() == 0 || start == end) { return 0f; } if (!mHasCompatScaling) { return native_getTextRunAdvances(mNativePaint, mNativeTypeface, text, start, end, contextStart, contextEnd, isRtl, advances, advancesIndex); } final float oldSize = getTextSize(); setTextSize(oldSize * mCompatScaling); float totalAdvance = native_getTextRunAdvances(mNativePaint, mNativeTypeface, text, start, end, contextStart, contextEnd, isRtl, advances, advancesIndex); setTextSize(oldSize); if (advances != null) { for (int i = advancesIndex, e = i + (end - start); i < e; i++) { advances[i] *= mInvCompatScaling; } } return totalAdvance * mInvCompatScaling; // assume errors are insignificant
public int	getTextRunCursor(char[] text, int contextStart, int contextLength, int dir, int offset, int 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. 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. 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 dir either {@link #DIRECTION_RTL} or {@link #DIRECTION_LTR} param offset the cursor position to move from param cursorOpt how to move the cursor, one of {@link #CURSOR_AFTER}, {@link #CURSOR_AT_OR_AFTER}, {@link #CURSOR_BEFORE}, {@link #CURSOR_AT_OR_BEFORE}, or {@link #CURSOR_AT} return the offset of the next position, or -1 hide 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 native_getTextRunCursor(mNativePaint, text, contextStart, contextLength, dir, offset, cursorOpt);
public int	getTextRunCursor(java.lang.CharSequence text, int contextStart, int contextEnd, int dir, int offset, int 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. 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. 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 dir either {@link #DIRECTION_RTL} or {@link #DIRECTION_LTR} param offset the cursor position to move from param cursorOpt how to move the cursor, one of {@link #CURSOR_AFTER}, {@link #CURSOR_AT_OR_AFTER}, {@link #CURSOR_BEFORE}, {@link #CURSOR_AT_OR_BEFORE}, or {@link #CURSOR_AT} return the offset of the next position, or -1 hide if (text instanceof String || text instanceof SpannedString || text instanceof SpannableString) { return getTextRunCursor(text.toString(), contextStart, contextEnd, dir, offset, cursorOpt); } if (text instanceof GraphicsOperations) { return ((GraphicsOperations) text).getTextRunCursor( contextStart, contextEnd, dir, offset, cursorOpt, this); } int contextLen = contextEnd - contextStart; char[] buf = TemporaryBuffer.obtain(contextLen); TextUtils.getChars(text, contextStart, contextEnd, buf, 0); int result = getTextRunCursor(buf, 0, contextLen, dir, offset - contextStart, cursorOpt); TemporaryBuffer.recycle(buf); return result;
public int	getTextRunCursor(java.lang.String text, int contextStart, int contextEnd, int dir, int offset, int 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. 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. 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 dir either {@link #DIRECTION_RTL} or {@link #DIRECTION_LTR} param offset the cursor position to move from param cursorOpt how to move the cursor, one of {@link #CURSOR_AFTER}, {@link #CURSOR_AT_OR_AFTER}, {@link #CURSOR_BEFORE}, {@link #CURSOR_AT_OR_BEFORE}, or {@link #CURSOR_AT} return the offset of the next position, or -1 hide if (((contextStart | contextEnd | offset | (contextEnd - contextStart) | (offset - contextStart) | (contextEnd - offset) | (text.length() - contextEnd) | cursorOpt) < 0) || cursorOpt > CURSOR_OPT_MAX_VALUE) { throw new IndexOutOfBoundsException(); } return native_getTextRunCursor(mNativePaint, text, contextStart, contextEnd, dir, offset, cursorOpt);
public native float	getTextScaleX() 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 native float	getTextSize() Return the paint's text size. return the paint's text size.
public native float	getTextSkewX() 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 int	getTextWidths(java.lang.String text, int start, int end, float[] widths) 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 unichars in the specified text. 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 (!mHasCompatScaling) { return native_getTextWidths(mNativePaint, mNativeTypeface, text, start, end, mBidiFlags, widths); } final float oldSize = getTextSize(); setTextSize(oldSize*mCompatScaling); int res = native_getTextWidths(mNativePaint, mNativeTypeface, text, start, end, mBidiFlags, widths); setTextSize(oldSize); for (int i=0; i<res; i++) { widths[i] *= mInvCompatScaling; } return res;
public int	getTextWidths(java.lang.String text, float[] widths) 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 unichars in the specified text. return getTextWidths(text, 0, text.length(), widths);
public int	getTextWidths(char[] text, int index, int count, float[] widths) 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. 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; } if (!mHasCompatScaling) { return native_getTextWidths(mNativePaint, mNativeTypeface, text, index, count, mBidiFlags, widths); } final float oldSize = getTextSize(); setTextSize(oldSize*mCompatScaling); int res = native_getTextWidths(mNativePaint, mNativeTypeface, text, index, count, mBidiFlags, widths); setTextSize(oldSize); for (int i=0; i<res; i++) { widths[i] *= mInvCompatScaling; } return res;
public int	getTextWidths(java.lang.CharSequence text, int start, int end, float[] widths) 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. 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;
public Typeface	getTypeface() Get the paint's typeface object. The typeface object identifies which font to use when drawing or measuring text. return the paint's typeface (or null) return mTypeface;
public Xfermode	getXfermode() Get the paint's xfermode object. return the paint's xfermode (or null) return mXfermode;
public boolean	hasShadowLayer() Checks if the paint has a shadow layer attached return true if the paint has a shadow layer attached and false otherwise hide return native_hasShadowLayer(mNativePaint);
public final boolean	isAntiAlias() 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. return (getFlags() & ANTI_ALIAS_FLAG) != 0;
public final boolean	isDither() 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. return (getFlags() & DITHER_FLAG) != 0;
public native boolean	isElegantTextHeight() Get the elegant metrics flag. return true if elegant metrics are enabled for text drawing.
public final boolean	isFakeBoldText() 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. return (getFlags() & FAKE_BOLD_TEXT_FLAG) != 0;
public final boolean	isFilterBitmap() 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() return (getFlags() & FILTER_BITMAP_FLAG) != 0;
public final boolean	isLinearText() 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 return (getFlags() & LINEAR_TEXT_FLAG) != 0;
public final boolean	isStrikeThruText() Helper for getFlags(), returning true if STRIKE_THRU_TEXT_FLAG bit is set return true if the strikeThruText bit is set in the paint's flags. return (getFlags() & STRIKE_THRU_TEXT_FLAG) != 0;
public final boolean	isSubpixelText() 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 return (getFlags() & SUBPIXEL_TEXT_FLAG) != 0;
public final boolean	isUnderlineText() 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. return (getFlags() & UNDERLINE_TEXT_FLAG) != 0;
public float	measureText(char[] text, int index, int count) 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 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; } if (!mHasCompatScaling) { return (float) Math.ceil(native_measureText(text, index, count, mBidiFlags)); } final float oldSize = getTextSize(); setTextSize(oldSize*mCompatScaling); float w = native_measureText(text, index, count, mBidiFlags); setTextSize(oldSize); return (float) Math.ceil(w*mInvCompatScaling);
public float	measureText(java.lang.String text, int start, int end) 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 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 (!mHasCompatScaling) { return (float) Math.ceil(native_measureText(text, start, end, mBidiFlags)); } final float oldSize = getTextSize(); setTextSize(oldSize*mCompatScaling); float w = native_measureText(text, start, end, mBidiFlags); setTextSize(oldSize); return (float) Math.ceil(w*mInvCompatScaling);
public float	measureText(java.lang.String text) Return the width of the text. param text The text to measure. Cannot be null. return The width of the text if (text == null) { throw new IllegalArgumentException("text cannot be null"); } if (text.length() == 0) { return 0f; } if (!mHasCompatScaling) { return (float) Math.ceil(native_measureText(text, mBidiFlags)); } final float oldSize = getTextSize(); setTextSize(oldSize*mCompatScaling); float w = native_measureText(text, mBidiFlags); setTextSize(oldSize); return (float) Math.ceil(w*mInvCompatScaling);
public float	measureText(java.lang.CharSequence text, int start, int end) 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 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;
private static native void	nativeGetCharArrayBounds(long nativePaint, long native_typeface, char[] text, int index, int count, int bidiFlags, Rect bounds)
private static native void	nativeGetStringBounds(long nativePaint, long native_typeface, java.lang.String text, int start, int end, int bidiFlags, Rect bounds)
private static native int	native_breakText(long native_object, long native_typeface, char[] text, int index, int count, float maxWidth, int bidiFlags, float[] measuredWidth)
private static native int	native_breakText(long native_object, long native_typeface, java.lang.String text, boolean measureForwards, float maxWidth, int bidiFlags, float[] measuredWidth)
private static native boolean	native_getFillPath(long native_object, long src, long dst)
private static native float	native_getLetterSpacing(long native_object)
private static native int	native_getStrokeCap(long native_object)
private static native int	native_getStrokeJoin(long native_object)
private static native int	native_getStyle(long native_object)
private static native int	native_getTextAlign(long native_object)
private static native int	native_getTextGlyphs(long native_object, java.lang.String text, int start, int end, int contextStart, int contextEnd, int flags, char[] glyphs)
private static native void	native_getTextPath(long native_object, long native_typeface, int bidiFlags, char[] text, int index, int count, float x, float y, long path)
private static native void	native_getTextPath(long native_object, long native_typeface, int bidiFlags, java.lang.String text, int start, int end, float x, float y, long path)
private static native float	native_getTextRunAdvances(long native_object, long native_typeface, char[] text, int index, int count, int contextIndex, int contextCount, boolean isRtl, float[] advances, int advancesIndex)
private static native float	native_getTextRunAdvances(long native_object, long native_typeface, java.lang.String text, int start, int end, int contextStart, int contextEnd, boolean isRtl, float[] advances, int advancesIndex)
private native int	native_getTextRunCursor(long native_object, char[] text, int contextStart, int contextLength, int dir, int offset, int cursorOpt)
private native int	native_getTextRunCursor(long native_object, java.lang.String text, int contextStart, int contextEnd, int dir, int offset, int cursorOpt)
private static native int	native_getTextWidths(long native_object, long native_typeface, char[] text, int index, int count, int bidiFlags, float[] widths)
private static native int	native_getTextWidths(long native_object, long native_typeface, java.lang.String text, int start, int end, int bidiFlags, float[] widths)
private static native boolean	native_hasShadowLayer(long native_object)
private static native long	native_init()
private static native long	native_initWithPaint(long paint)
private native float	native_measureText(char[] text, int index, int count, int bidiFlags)
private native float	native_measureText(java.lang.String text, int start, int end, int bidiFlags)
private native float	native_measureText(java.lang.String text, int bidiFlags)
private static native void	native_reset(long native_object)
private static native void	native_set(long native_dst, long native_src)
private static native long	native_setColorFilter(long native_object, long filter)
private static native void	native_setFontFeatureSettings(long native_object, java.lang.String settings)
private static native void	native_setLetterSpacing(long native_object, float letterSpacing)
private static native long	native_setMaskFilter(long native_object, long maskfilter)
private static native long	native_setPathEffect(long native_object, long effect)
private static native long	native_setRasterizer(long native_object, long rasterizer)
private static native long	native_setShader(long native_object, long shader)
private static native void	native_setShadowLayer(long native_object, float radius, float dx, float dy, int color)
private static native void	native_setStrokeCap(long native_object, int cap)
private static native void	native_setStrokeJoin(long native_object, int join)
private static native void	native_setStyle(long native_object, int style)
private static native void	native_setTextAlign(long native_object, int align)
private static native void	native_setTextLocale(long native_object, java.lang.String locale)
private static native long	native_setTypeface(long native_object, long typeface)
private static native long	native_setXfermode(long native_object, long xfermode)
public void	reset() Restores the paint to its default settings. native_reset(mNativePaint); setFlags(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); mColorFilter = null; mMaskFilter = null; mPathEffect = null; mRasterizer = null; mShader = null; mTypeface = null; mNativeTypeface = 0; mXfermode = null; mHasCompatScaling = false; mCompatScaling = 1; mInvCompatScaling = 1; mBidiFlags = BIDI_DEFAULT_LTR; setTextLocale(Locale.getDefault()); setElegantTextHeight(false); mFontFeatureSettings = null;
public void	set(android.graphics.Paint src) 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. if (this != src) { // copy over the native settings native_set(mNativePaint, src.mNativePaint); setClassVariablesFrom(src); }
public void	setARGB(int a, int r, int g, int b) 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. setColor((a << 24) | (r << 16) | (g << 8) | b);
public native void	setAlpha(int a) 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 native void	setAntiAlias(boolean aa) 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	setBidiFlags(int flags) Set the bidi flags on the paint. hide // 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;
private void	setClassVariablesFrom(android.graphics.Paint paint) Set all class variables using current values from the given {@link Paint}. mColorFilter = paint.mColorFilter; mMaskFilter = paint.mMaskFilter; mPathEffect = paint.mPathEffect; mRasterizer = paint.mRasterizer; if (paint.mShader != null) { mShader = paint.mShader.copy(); } else { mShader = null; } mTypeface = paint.mTypeface; mNativeTypeface = paint.mNativeTypeface; mXfermode = paint.mXfermode; mHasCompatScaling = paint.mHasCompatScaling; mCompatScaling = paint.mCompatScaling; mInvCompatScaling = paint.mInvCompatScaling; mBidiFlags = paint.mBidiFlags; mLocale = paint.mLocale; mFontFeatureSettings = paint.mFontFeatureSettings;
public native void	setColor(int color) 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 ColorFilter	setColorFilter(ColorFilter filter) 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 long filterNative = 0; if (filter != null) filterNative = filter.native_instance; native_setColorFilter(mNativePaint, filterNative); mColorFilter = filter; return filter;
public void	setCompatibilityScaling(float factor) hide if (factor == 1.0) { mHasCompatScaling = false; mCompatScaling = mInvCompatScaling = 1.0f; } else { mHasCompatScaling = true; mCompatScaling = factor; mInvCompatScaling = 1.0f/factor; }
public native void	setDither(boolean dither) 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 native void	setElegantTextHeight(boolean elegant) 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 native void	setFakeBoldText(boolean fakeBoldText) 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 native void	setFilterBitmap(boolean filter) 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.
public native void	setFlags(int flags) Set the paint's flags. Use the Flag enum to specific flag values. param flags The new flag bits for the paint
public void	setFontFeatureSettings(java.lang.String settings) Set font feature settings. The format is the same as the CSS font-feature-settings attribute: http://dev.w3.org/csswg/css-fonts/#propdef-font-feature-settings param settings the font feature settings string to use, may be null. if (settings != null && settings.equals("")) { settings = null; } if ((settings == null && mFontFeatureSettings == null) || (settings != null && settings.equals(mFontFeatureSettings))) { return; } mFontFeatureSettings = settings; native_setFontFeatureSettings(mNativePaint, settings);
public native void	setHinting(int mode) Set the paint's hinting mode. May be either {@link #HINTING_OFF} or {@link #HINTING_ON}.
public void	setLetterSpacing(float letterSpacing) 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. native_setLetterSpacing(mNativePaint, letterSpacing);
public native void	setLinearText(boolean linearText) 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 MaskFilter	setMaskFilter(MaskFilter maskfilter) Set or clear the maskfilter object. 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 long maskfilterNative = 0; if (maskfilter != null) { maskfilterNative = maskfilter.native_instance; } native_setMaskFilter(mNativePaint, maskfilterNative); mMaskFilter = maskfilter; return maskfilter;
public PathEffect	setPathEffect(PathEffect effect) Set or clear the patheffect object. 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 long effectNative = 0; if (effect != null) { effectNative = effect.native_instance; } native_setPathEffect(mNativePaint, effectNative); mPathEffect = effect; return effect;
public Rasterizer	setRasterizer(Rasterizer rasterizer) Set or clear the rasterizer object. 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. long rasterizerNative = 0; if (rasterizer != null) { rasterizerNative = rasterizer.native_instance; } native_setRasterizer(mNativePaint, rasterizerNative); mRasterizer = rasterizer; return rasterizer;
public Shader	setShader(Shader shader) Set or clear the shader object. 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 long shaderNative = 0; if (shader != null) shaderNative = shader.getNativeInstance(); native_setShader(mNativePaint, shaderNative); mShader = shader; return shader;
public void	setShadowLayer(float radius, float dx, float dy, int 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. Can be used to create a blurred shadow underneath text. Support for use with other drawing operations is constrained to the software rendering pipeline. 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. native_setShadowLayer(mNativePaint, radius, dx, dy, shadowColor);
public native void	setStrikeThruText(boolean strikeThruText) 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.
public void	setStrokeCap(android.graphics.Paint$Cap cap) Set the paint's Cap. param cap set the paint's line cap style, used whenever the paint's style is Stroke or StrokeAndFill. native_setStrokeCap(mNativePaint, cap.nativeInt);
public void	setStrokeJoin(android.graphics.Paint$Join join) Set the paint's Join. param join set the paint's Join, used whenever the paint's style is Stroke or StrokeAndFill. native_setStrokeJoin(mNativePaint, join.nativeInt);
public native void	setStrokeMiter(float miter) 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 native void	setStrokeWidth(float width) Set the width for stroking. Pass 0 to stroke in hairline mode. Hairlines always draws a single pixel independent of the canva's matrix. param width set the paint's stroke width, used whenever the paint's style is Stroke or StrokeAndFill.
public void	setStyle(android.graphics.Paint$Style style) 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 native_setStyle(mNativePaint, style.nativeInt);
public native void	setSubpixelText(boolean subpixelText) 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	setTextAlign(android.graphics.Paint$Align align) 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 specifieds the LEFT edge of the text) and so on. param align set the paint's Align value for drawing text. native_setTextAlign(mNativePaint, align.nativeInt);
public void	setTextLocale(java.util.Locale locale) Set the text locale. The text locale affects how the text is drawn for some languages. For example, if the locale is {@link Locale#CHINESE} or {@link Locale#CHINA}, then the text renderer will prefer to draw text using a Chinese font. Likewise, if the locale is {@link Locale#JAPANESE} or {@link Locale#JAPAN}, then the text renderer will prefer to draw text using a Japanese 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 is initialized to the system locale (as returned by {@link Locale#getDefault}). This assumes that the text to be rendered will most likely be in the user's preferred language. If the actual language of the text is known, then it 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 locale just helps it do a better job in certain ambiguous cases param locale the paint's locale value for drawing text, must not be null. if (locale == null) { throw new IllegalArgumentException("locale cannot be null"); } if (locale.equals(mLocale)) return; mLocale = locale; native_setTextLocale(mNativePaint, locale.toString());
public native void	setTextScaleX(float scaleX) 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 native void	setTextSize(float textSize) Set the paint's text size. This value must be > 0 param textSize set the paint's text size.
public native void	setTextSkewX(float skewX) 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 Typeface	setTypeface(Typeface typeface) Set or clear the typeface object. 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 long typefaceNative = 0; if (typeface != null) { typefaceNative = typeface.native_instance; } native_setTypeface(mNativePaint, typefaceNative); mTypeface = typeface; mNativeTypeface = typefaceNative; return typeface;
public native void	setUnderlineText(boolean underlineText) 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.
public Xfermode	setXfermode(Xfermode xfermode) Set or clear the xfermode object. Pass null to clear any previous xfermode. As a convenience, the parameter passed is also returned. param xfermode May be null. The xfermode to be installed in the paint return xfermode long xfermodeNative = 0; if (xfermode != null) xfermodeNative = xfermode.native_instance; native_setXfermode(mNativePaint, xfermodeNative); mXfermode = xfermode; return xfermode;