Paint

ANTI_ALIAS_FLAG

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.

Constant Value: 1 (0x00000001)

DEV_KERN_TEXT_FLAG

int DEV_KERN_TEXT_FLAG

Legacy Paint flag, no longer used.

Constant Value: 256 (0x00000100)

DITHER_FLAG

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.

Constant Value: 4 (0x00000004)

EMBEDDED_BITMAP_TEXT_FLAG

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.

Constant Value: 1024 (0x00000400)

FAKE_BOLD_TEXT_FLAG

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 Typeface that is not already bold.

Constant Value: 32 (0x00000020)

FILTER_BITMAP_FLAG

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.

Constant Value: 2 (0x00000002)

HINTING_OFF

int HINTING_OFF

Font hinter option that disables font hinting.

Constant Value: 0 (0x00000000)

HINTING_ON

int HINTING_ON

Font hinter option that enables font hinting.

Constant Value: 1 (0x00000001)

LINEAR_TEXT_FLAG

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.

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.

Constant Value: 64 (0x00000040)

STRIKE_THRU_TEXT_FLAG

int STRIKE_THRU_TEXT_FLAG

Paint flag that applies a strike-through decoration to drawn text.

Constant Value: 16 (0x00000010)

SUBPIXEL_TEXT_FLAG

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 LINEAR_TEXT_FLAG to prevent text from jittering during smooth scale transitions.

Constant Value: 128 (0x00000080)

UNDERLINE_TEXT_FLAG

int UNDERLINE_TEXT_FLAG

Paint flag that applies an underline decoration to drawn text.

Constant Value: 8 (0x00000008)

Paint

Paint ()

Create a new paint with default settings.

Paint

Paint (int flags)

Create a new paint with the specified flags. Use setFlags() to change these after the paint is created.

Paint

Paint (Paint paint)

Create a new paint, initialized with the attributes in the specified paint parameter.

ascent

float ascent ()

Return the distance above (negative) the baseline (ascent) based on the current typeface and text size.

breakText

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.

breakText

int breakText (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.

breakText

int breakText (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.

clearShadowLayer

void clearShadowLayer ()

Clear the shadow layer.

descent

float descent ()

Return the distance below (positive) the baseline (descent) based on the current typeface and text size.

getAlpha

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).

getColor

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.

getColorFilter

ColorFilter getColorFilter ()

Get the paint's colorfilter (maybe be null).

getFillPath

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).

getFlags

int getFlags ()

Return the paint's flags. Use the Flag enum to test flag values.

getFontFeatureSettings

String getFontFeatureSettings ()

Returns the 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

getFontMetrics

float getFontMetrics (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.

getFontMetrics

Paint.FontMetrics getFontMetrics ()

Allocates a new FontMetrics object, and then calls getFontMetrics(fm) with it, returning the object.

getFontMetricsInt

int getFontMetricsInt (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().

getFontMetricsInt

Paint.FontMetricsInt getFontMetricsInt ()

getFontSpacing

float getFontSpacing ()

Return the recommend line spacing based on the current typeface and text size.

getHinting

int getHinting ()

Return the paint's hinting mode. Returns either HINTING_OFF or HINTING_ON.

getLetterSpacing

float getLetterSpacing ()

Return the paint's letter-spacing for text. The default value is 0.

getMaskFilter

MaskFilter getMaskFilter ()

Get the paint's maskfilter object.

getOffsetForAdvance

int getOffsetForAdvance (char[] text, 
                int start, 
                int end, 
                int contextStart, 
                int contextEnd, 
                boolean isRtl, 
                float advance)

Get the character offset within the string whose position is closest to the specified horizontal position.

The returned value is generally the value of offset for which getRunAdvance(char[], int, int, int, int, boolean, int) yields a result most closely approximating 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 Unicode Standard Annex #29 but with some tailoring for better user experience.

Note that 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.

All indices are relative to the start of text. Further, 0 <= contextStart <= start <= end <= contextEnd <= text.length must hold on entry, and start <= result <= end will hold on return.

getOffsetForAdvance

int getOffsetForAdvance (CharSequence text, 
                int start, 
                int end, 
                int contextStart, 
                int contextEnd, 
                boolean isRtl, 
                float advance)

getPathEffect

PathEffect getPathEffect ()

Get the paint's patheffect object.

getRasterizer

Rasterizer getRasterizer ()

This method was deprecated in API level 21.
Rasterizer is not supported by either the HW or PDF backends.

Get the paint's rasterizer (or null).

The raster controls/modifies how paths/text are turned into alpha masks.

getRunAdvance

float getRunAdvance (char[] text, 
                int start, 
                int end, 
                int contextStart, 
                int contextEnd, 
                boolean isRtl, 
                int offset)

Measure cursor position within a run of text.

The run of text includes the characters from start to end in the text. In addition, the range contextStart to 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.

All text outside the range contextStart..contextEnd is ignored. The text between start and end will be laid out to be measured.

The returned width measurement is the advance from start to offset. It is generally a positive value, no matter the direction of the run. If offset == end, the return value is simply the width of the whole run from start to end.

Ligatures are formed for characters in the range start..end (but not for start..contextStart or end..contextEnd). If 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 getOffsetForAdvance(char[], int, int, int, int, boolean, float) for more discussion of grapheme cluster boundaries.

The direction of the run is explicitly specified by isRtl. Thus, this method is suitable only for runs of a single direction.

All indices are relative to the start of text. Further, 0 <= contextStart <= start <= offset <= end <= contextEnd <= text.length must hold on entry.

getRunAdvance

float getRunAdvance (CharSequence text, 
                int start, 
                int end, 
                int contextStart, 
                int contextEnd, 
                boolean isRtl, 
                int offset)

getShader

Shader getShader ()

Get the paint's shader object.

getStrokeCap

Paint.Cap getStrokeCap ()

Return the paint's Cap, controlling how the start and end of stroked lines and paths are treated.

getStrokeJoin

Paint.Join getStrokeJoin ()

Return the paint's stroke join type.

getStrokeMiter

float getStrokeMiter ()

Return the paint's stroke miter value. Used to control the behavior of miter joins when the joins angle is sharp.

getStrokeWidth

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.

getStyle

Paint.Style getStyle ()

Return the paint's style, used for controlling how primitives' geometries are interpreted (except for drawBitmap, which always assumes FILL_STYLE).

getTextAlign

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.

getTextBounds

void getTextBounds (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).

getTextBounds

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).

getTextLocale

Locale getTextLocale ()

Get the text's primary Locale. Note that this is not all of the locale-related information Paint has. Use getTextLocales() to get the complete list.

getTextLocales

LocaleList getTextLocales ()

Get the text locale list.

getTextPath

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.

getTextPath

void getTextPath (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.

getTextScaleX

float getTextScaleX ()

Return the paint's horizontal scale factor for text. The default value is 1.0.

getTextSize

float getTextSize ()

Return the paint's text size.

getTextSkewX

float getTextSkewX ()

Return the paint's horizontal skew factor for text. The default value is 0.

getTextWidths

int getTextWidths (char[] text, 
                int index, 
                int count, 
                float[] widths)

Return the advance widths for the characters in the string.

getTextWidths

int getTextWidths (String text, 
                float[] widths)

Return the advance widths for the characters in the string.

getTextWidths

int getTextWidths (String text, 
                int start, 
                int end, 
                float[] widths)

Return the advance widths for the characters in the string.

getTextWidths

int getTextWidths (CharSequence text, 
                int start, 
                int end, 
                float[] widths)

Return the advance widths for the characters in the string.

getTypeface

Typeface getTypeface ()

Get the paint's typeface object.

The typeface object identifies which font to use when drawing or measuring text.

getXfermode

Xfermode getXfermode ()

Get the paint's xfermode object.

hasGlyph

boolean hasGlyph (String string)

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.

Finally, if the string contains a variation selector, the method only returns true if the fonts contains a glyph specific to that variation.

Checking is done on the entire fallback chain, not just the immediate font referenced.

isAntiAlias

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.

isDither

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.

isElegantTextHeight

boolean isElegantTextHeight ()

Get the elegant metrics flag.

isFakeBoldText

boolean isFakeBoldText ()

Helper for getFlags(), returning true if FAKE_BOLD_TEXT_FLAG bit is set

isFilterBitmap

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.

isLinearText

boolean isLinearText ()

Helper for getFlags(), returning true if LINEAR_TEXT_FLAG bit is set

isStrikeThruText

boolean isStrikeThruText ()

Helper for getFlags(), returning true if STRIKE_THRU_TEXT_FLAG bit is set

isSubpixelText

boolean isSubpixelText ()

Helper for getFlags(), returning true if SUBPIXEL_TEXT_FLAG bit is set

isUnderlineText

boolean isUnderlineText ()

Helper for getFlags(), returning true if UNDERLINE_TEXT_FLAG bit is set

measureText

float measureText (char[] text, 
                int index, 
                int count)

Return the width of the text.

measureText

float measureText (CharSequence text, 
                int start, 
                int end)

Return the width of the text.

measureText

float measureText (String text, 
                int start, 
                int end)

Return the width of the text.

measureText

float measureText (String text)

Return the width of the text.

reset

void reset ()

Restores the paint to its default settings.

set

void set (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.

setARGB

void setARGB (int a, 
                int r, 
                int g, 
                int b)

Helper to setColor(), that takes a,r,g,b and constructs the color int

setAlpha

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]

setAntiAlias

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.

setColor

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.

setColorFilter

ColorFilter setColorFilter (ColorFilter filter)

Set or clear the paint's colorfilter, returning the parameter.

setDither

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.

setElegantTextHeight

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.

setFakeBoldText

void setFakeBoldText (boolean fakeBoldText)

Helper for setFlags(), setting or clearing the FAKE_BOLD_TEXT_FLAG bit

setFilterBitmap

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.

setFlags

void setFlags (int flags)

Set the paint's flags. Use the Flag enum to specific flag values.

setFontFeatureSettings

void setFontFeatureSettings (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

setHinting

void setHinting (int mode)

Set the paint's hinting mode. May be either HINTING_OFF or HINTING_ON.

setLetterSpacing

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.

setLinearText

void setLinearText (boolean linearText)

Helper for setFlags(), setting or clearing the LINEAR_TEXT_FLAG bit

setMaskFilter

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.

setPathEffect

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.

setRasterizer

Rasterizer setRasterizer (Rasterizer rasterizer)

This method was deprecated in API level 21.
Rasterizer is not supported by either the HW or PDF backends.

Set or clear the rasterizer object.

Pass null to clear any previous rasterizer. As a convenience, the parameter passed is also returned.

setShader

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.

setShadowLayer

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.

setStrikeThruText

void setStrikeThruText (boolean strikeThruText)

Helper for setFlags(), setting or clearing the STRIKE_THRU_TEXT_FLAG bit

setStrokeCap

void setStrokeCap (Paint.Cap cap)

Set the paint's Cap.

setStrokeJoin

void setStrokeJoin (Paint.Join join)

Set the paint's Join.

setStrokeMiter

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.

setStrokeWidth

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.

setStyle

void setStyle (Paint.Style style)

Set the paint's style, used for controlling how primitives' geometries are interpreted (except for drawBitmap, which always assumes Fill).

setSubpixelText

void setSubpixelText (boolean subpixelText)

Helper for setFlags(), setting or clearing the SUBPIXEL_TEXT_FLAG bit

setTextAlign

void setTextAlign (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.

setTextLocale

void setTextLocale (Locale locale)

Set the text locale list to a one-member list consisting of just the locale. See setTextLocales(LocaleList) for how the locale list affects the way the text is drawn for some languages.

setTextLocales

void setTextLocales (LocaleList locales)

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 CHINESE or CHINA, then the text renderer will prefer to draw text using a Chinese font. Likewise, if the locale list contains JAPANESE or 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.

setTextScaleX

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.

setTextSize

void setTextSize (float textSize)

Set the paint's text size. This value must be > 0

setTextSkewX

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.

setTypeface

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.

setUnderlineText

void setUnderlineText (boolean underlineText)

Helper for setFlags(), setting or clearing the UNDERLINE_TEXT_FLAG bit

setXfermode

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.