Paint controls options applied when drawing and measuring. Paint collects all options outside of the Canvas Clip and Canvas Matrix.
Various options apply to text, strokes and fills, and images.
Some options may not be implemented on all platforms; in these cases, setting the option has no effect. Some options are conveniences that duplicate Canvas functionality; for instance, text size is identical to matrix scale.
Paint options are rarely exclusive; each option modifies a stage of the drawing pipeline and multiple pipeline stages may be affected by a single Paint.
Paint collects effects and filters that describe single-pass and multiple-pass algorithms that alter the drawing geometry, color, and transparency. For instance, Paint does not directly implement dashing or blur, but contains the objects that do so.
The objects contained by Paint are opaque, and cannot be edited outside of the Paint to affect it. The implementation is free to defer computations associated with the Paint, or ignore them altogether. For instance, some GPU implementations draw all Path geometries with Anti Aliasing, regardless of how SkPaint::kAntiAlias Flag is set in Paint.
Paint describes a single color, a single font, a single image quality, and so on. Multiple colors are drawn either by using multiple paints or with objects like Shader attached to Paint.
Constructs Paint with default values.
| attribute | default value |
|---|---|
| Anti Alias | false |
| Blend Mode | SkBlendMode::kSrcOver |
| Color | SK ColorBLACK |
| Color Alpha | 255 |
| Color Filter | nullptr |
| Dither | false |
| Draw Looper | nullptr |
| Fake Bold | false |
| Filter Quality | kNone_SkFilterQuality |
| Font Embedded Bitmaps | false |
| Automatic Hinting | false |
| Full Hinting Spacing | false |
| Hinting | kNormal Hinting |
| Image Filter | nullptr |
| LCD Text | false |
| Linear Text | false |
| Miter Limit | 4 |
| Mask Filter | nullptr |
| Path Effect | nullptr |
| Shader | nullptr |
| Style | kFill Style |
| Text Encoding | kUTF8 TextEncoding |
| Text Scale X | 1 |
| Text Size | 12 |
| Text Skew X | 0 |
| Typeface | nullptr |
| Stroke Cap | kButt Cap |
| Stroke Join | kMiter Join |
| Stroke Width | 0 |
| Subpixel Text | false |
The flags, text size, hinting, and miter limit may be overridden at compile time by defining paint default values. The overrides may be included in "SkUserConfig.h" or predefined by the build system.
default initialized Paint
Makes a shallow copy of SkPaint. SkTypeface, SkPathEffect, SkShader, SkMaskFilter, SkColorFilter, SkDrawLooper, and SkImageFilter are shared between the original paint and the copy. Objects containing SkRefCnt increment their references by one.
The referenced objects SkPathEffect, SkShader, SkMaskFilter, SkColorFilter, SkDrawLooper, and SkImageFilter cannot be modified after they are created. This prevents objects with SkRefCnt from being modified once SkPaint refers to them.
shallow copy of paint
SK_ColorRED == paint1.getColor() SK_ColorBLUE == paint2.getColor()
Implements a move constructor to avoid increasing the reference counts of objects referenced by the paint.
After the call, paint is undefined, and can be safely destructed.
content of paint
path effect unique: true
Sets all SkPaint contents to their initial values. This is equivalent to replacing SkPaint with the result of SkPaint().
paint1 == paint2
Decreases SkPaint SkRefCnt of owned objects: SkTypeface, SkPathEffect, SkShader, SkMaskFilter, SkColorFilter, SkDrawLooper, and SkImageFilter. If the objects containing SkRefCnt go to zero, they are deleted.
Makes a shallow copy of SkPaint. SkTypeface, SkPathEffect, SkShader, SkMaskFilter, SkColorFilter, SkDrawLooper, and SkImageFilter are shared between the original paint and the copy. Objects containing SkRefCnt in the prior destination are decreased by one, and the referenced objects are deleted if the resulting count is zero. Objects containing SkRefCnt in the parameter paint are increased by one. paint is unmodified.
content of paint
SK_ColorRED == paint1.getColor() SK_ColorRED == paint2.getColor()
Moves the paint to avoid increasing the reference counts of objects referenced by the paint parameter. Objects containing SkRefCnt in the prior destination are decreased by one; those objects are deleted if the resulting count is zero.
After the call, paint is undefined, and can be safely destructed.
content of paint
SK_ColorRED == paint2.getColor()
Compares a and b, and returns true if a and b are equivalent. May return false if SkTypeface, SkPathEffect, SkShader, SkMaskFilter, SkColorFilter, SkDrawLooper, or SkImageFilter have identical contents but different pointers.
true if SkPaint pair are equivalent
paint1 == paint2 paint1 != paint2
operator!=(const SkPaint& a, const SkPaint& b)
Compares a and b, and returns true if a and b are not equivalent. May return true if SkTypeface, SkPathEffect, SkShader, SkMaskFilter, SkColorFilter, SkDrawLooper, or SkImageFilter have identical contents but different pointers.
true if SkPaint pair are not equivalent
paint1 == paint2 paint1 == paint2
operator==(const SkPaint& a, const SkPaint& b)
Returns a hash generated from SkPaint values and pointers. Identical hashes guarantee that the paints are equivalent, but differing hashes do not guarantee that the paints have differing contents.
If operator==(const SkPaint& a, const SkPaint& b) returns true for two paints, their hashes are also equal.
The hash returned is platform and implementation specific.
a shallow hash
paint1 == paint2 paint1.getHash() == paint2.getHash()
Hinting adjusts the glyph outlines so that the shape provides a uniform look at a given point size on font engines that support it. Hinting may have a muted effect or no effect at all depending on the platform.
The four levels roughly control corresponding features on platforms that use FreeType as the Font Engine.
On OS X and iOS, hinting controls whether Core Graphics dilates the font outlines to account for LCD text. No hinting uses Core Text grayscale output. Normal hinting uses Core Text LCD output. If kLCDRenderText Flag is clear, the LCD output is reduced to a single grayscale channel.
On Windows with DirectWrite, Hinting has no effect.
Hinting defaults to kNormal Hinting. Set SkPaintDefaults Hinting at compile time to change the default setting.
Returns level of glyph outline adjustment.
one of: kNo_Hinting, kSlight_Hinting, kNormal_Hinting, kFull_Hinting
SkPaint::kNormal_Hinting == paint.getHinting()
Sets level of glyph outline adjustment. Does not check for valid values of hintingLevel.
| Hinting | value | effect on generated glyph outlines |
|---|---|---|
| kNo Hinting | 0 | leaves glyph outlines unchanged from their native representation |
| kSlight Hinting | 1 | modifies glyph outlines minimally to improve contrast |
| kNormal Hinting | 2 | modifies glyph outlines to improve contrast |
| kFull Hinting | 3 | modifies glyph outlines for maximum contrast |
paint1 == paint2
The bit values stored in Flags. The default value for Flags, normally zero, can be changed at compile time with a custom definition of SkPaintDefaults Flags. All flags can be read and written explicitly; Flags allows manipulating multiple settings at once.
To be deprecated soon.
Only valid for Android framework.
Returns paint settings described by SkPaint::Flags. Each setting uses one bit, and can be tested with SkPaint::Flags members.
zero, one, or more bits described by SkPaint::Flags
(SkPaint::kAntiAlias_Flag & paint.getFlags()) != 0
Replaces SkPaint::Flags with flags, the union of the SkPaint::Flags members. All SkPaint::Flags members may be cleared, or one or more may be set.
paint.isAntiAlias() paint.isDither()
Anti Alias drawing approximates partial pixel coverage with transparency. If kAntiAlias Flag is clear, pixel centers contained by the shape edge are drawn opaque. If kAntiAlias Flag is set, pixels are drawn with Color Alpha equal to their coverage.
The rule for Aliased pixels is inconsistent across platforms. A shape edge passing through the pixel center may, but is not required to, draw the pixel.
Raster Engine draws Aliased pixels whose centers are on or to the right of the start of an active Path edge, and whose center is to the left of the end of the active Path edge.
A platform may only support Anti Aliased drawing. Some GPU-backed platforms use Supersampling to Anti Alias all drawing, and have no mechanism to selectively Alias.
The amount of coverage computed for Anti Aliased pixels also varies across platforms.
Anti Alias is disabled by default. Anti Alias can be enabled by default by setting SkPaintDefaults Flags to kAntiAlias Flag at compile time.
Returns true if pixels on the active edges of SkPath may be drawn with partial transparency.
Equivalent to getFlags() masked with kAntiAlias_Flag.
kAntiAlias_Flag state
paint.isAntiAlias() == !!(paint.getFlags() & SkPaint::kAntiAlias_Flag) paint.isAntiAlias() == !!(paint.getFlags() & SkPaint::kAntiAlias_Flag)
Requests, but does not require, that SkPath edge pixels draw opaque or with partial transparency.
Sets kAntiAlias_Flag if aa is true. Clears kAntiAlias_Flag if aa is false.
paint1 == paint2
Dither increases fidelity by adjusting the color of adjacent pixels. This can help to smooth color transitions and reducing banding in gradients. Dithering lessens visible banding from kRGB_565_SkColorType and kRGBA_8888_SkColorType gradients, and improves rendering into a kRGB_565_SkColorType Surface.
Dithering is always enabled for linear gradients drawing into kRGB_565_SkColorType Surface and kRGBA_8888_SkColorType Surface. Dither cannot be enabled for kAlpha_8_SkColorType Surface and kRGBA_F16_SkColorType Surface.
Dither is disabled by default. Dither can be enabled by default by setting SkPaintDefaults Flags to kDither Flag at compile time.
Some platform implementations may ignore dithering. Set SK_IGNORE_GPU_DITHERto ignore Dither on GPU Surface.
Gradient kRGB_565_SkColorType
Returns true if color error may be distributed to smooth color transition.
Equivalent to getFlags() masked with kDither_Flag.
kDither_Flag state
paint.isDither() == !!(paint.getFlags() & SkPaint::kDither_Flag) paint.isDither() == !!(paint.getFlags() & SkPaint::kDither_Flag)
Requests, but does not require, to distribute color error.
Sets kDither_Flag if dither is true. Clears kDither_Flag if dither is false.
paint1 == paint2
kRGB_565_SkColorType
LCD Text and Subpixel Text increase the precision of glyph position.
When set, Flags kLCDRenderText Flag takes advantage of the organization of RGB stripes that create a color, and relies on the small size of the stripe and visual perception to make the color fringing imperceptible. LCD Text can be enabled on devices that orient stripes horizontally or vertically, and that order the color components as RGB or BGR.
Flags kSubpixelText Flag uses the pixel transparency to represent a fractional offset. As the opaqueness of the color increases, the edge of the glyph appears to move towards the outside of the pixel.
Either or both techniques can be enabled. kLCDRenderText Flag and kSubpixelText Flag are clear by default. LCD Text or Subpixel Text can be enabled by default by setting SkPaintDefaults Flags to kLCDRenderText Flag or kSubpixelText Flag (or both) at compile time.
Linear Text selects whether text is rendered as a Glyph or as a Path. If kLinearText Flag is set, it has the same effect as setting Hinting to kNormal Hinting. If kLinearText Flag is clear, it is the same as setting Hinting to kNo Hinting.
Returns true if text is converted to SkPath before drawing and measuring.
Equivalent to getFlags() masked with kLinearText_Flag.
kLinearText_Flag state
setLinearText Hinting
Returns true if text is converted to SkPath before drawing and measuring. By default, kLinearText_Flag is clear.
Sets kLinearText_Flag if linearText is true. Clears kLinearText_Flag if linearText is false.
isLinearText Hinting
Flags kSubpixelText Flag uses the pixel transparency to represent a fractional offset. As the opaqueness of the color increases, the edge of the glyph appears to move towards the outside of the pixel.
Returns true if glyphs at different sub-pixel positions may differ on pixel edge coverage.
Equivalent to getFlags() masked with kSubpixelText_Flag.
kSubpixelText_Flag state
paint.isSubpixelText() == !!(paint.getFlags() & SkPaint::kSubpixelText_Flag) paint.isSubpixelText() == !!(paint.getFlags() & SkPaint::kSubpixelText_Flag)
Requests, but does not require, that glyphs respect sub-pixel positioning.
Sets kSubpixelText_Flag if subpixelText is true. Clears kSubpixelText_Flag if subpixelText is false.
paint1 == paint2
When set, Flags kLCDRenderText Flag takes advantage of the organization of RGB stripes that create a color, and relies on the small size of the stripe and visual perception to make the color fringing imperceptible. LCD Text can be enabled on devices that orient stripes horizontally or vertically, and that order the color components as RGB or BGR.
Returns true if glyphs may use LCD striping to improve glyph edges.
Returns true if SkPaint::Flags kLCDRenderText_Flag is set.
kLCDRenderText_Flag state
paint.isLCDRenderText() == !!(paint.getFlags() & SkPaint::kLCDRenderText_Flag) paint.isLCDRenderText() == !!(paint.getFlags() & SkPaint::kLCDRenderText_Flag)
Requests, but does not require, that glyphs use LCD striping for glyph edges.
Sets kLCDRenderText_Flag if lcdText is true. Clears kLCDRenderText_Flag if lcdText is false.
paint1 == paint2
Font Embedded Bitmaps allows selecting custom sized bitmap Glyphs. Flags kEmbeddedBitmapText Flag when set chooses an embedded bitmap glyph over an outline contained in a font if the platform supports this option.
FreeType selects the bitmap glyph if available when kEmbeddedBitmapText Flag is set, and selects the outline glyph if kEmbeddedBitmapText Flag is clear. Windows may select the bitmap glyph but is not required to do so. OS X and iOS do not support this option.
Font Embedded Bitmaps is disabled by default. Font Embedded Bitmaps can be enabled by default by setting SkPaintDefaults Flags to kEmbeddedBitmapText Flag at compile time.
Returns true if font engine may return glyphs from font bitmaps instead of from outlines.
Equivalent to getFlags() masked with kEmbeddedBitmapText_Flag.
kEmbeddedBitmapText_Flag state
paint.isEmbeddedBitmapText() == !!(paint.getFlags() & SkPaint::kEmbeddedBitmapText_Flag) paint.isEmbeddedBitmapText() == !!(paint.getFlags() & SkPaint::kEmbeddedBitmapText_Flag)
Requests, but does not require, to use bitmaps in fonts instead of outlines.
Sets kEmbeddedBitmapText_Flag if useEmbeddedBitmapText is true. Clears kEmbeddedBitmapText_Flag if useEmbeddedBitmapText is false.
paint1 == paint2
If Hinting is set to kNormal Hinting or kFull Hinting, Automatic Hinting instructs the Font Manager to always hint Glyphs. Automatic Hinting has no effect if Hinting is set to kNo Hinting or kSlight Hinting.
Automatic Hinting only affects platforms that use FreeType as the Font Manager.
Returns true if SkPaint::Hinting is set to kNormal_Hinting or kFull_Hinting, and if platform uses FreeType as the font manager. If true, instructs the font manager to always hint glyphs.
Equivalent to getFlags() masked with kAutoHinting_Flag.
kAutoHinting_Flag state
paint.isAutohinted() == !!(paint.getFlags() & SkPaint::kAutoHinting_Flag) paint.isAutohinted() == !!(paint.getFlags() & SkPaint::kAutoHinting_Flag)
setAutohinted Hinting
Sets whether to always hint glyphs. If SkPaint::Hinting is set to kNormal_Hinting or kFull_Hinting and useAutohinter is set, instructs the font manager to always hint glyphs. auto-hinting has no effect if SkPaint::Hinting is set to kNo_Hinting or kSlight_Hinting.
Only affects platforms that use FreeType as the font manager.
Sets kAutoHinting_Flag if useAutohinter is true. Clears kAutoHinting_Flag if useAutohinter is false.
isAutohinted Hinting
Fake Bold approximates the bold font style accompanying a normal font when a bold font face is not available. Skia does not provide font substitution; it is up to the client to find the bold font face using the platform Font Manager.
Use Text Skew X to approximate an italic font style when the italic font face is not available.
A FreeType based port may define SK_USE_FREETYPE_EMBOLDEN at compile time to direct the font engine to create the bold Glyphs. Otherwise, the extra bold is computed by increasing the stroke width and setting the Style to kStrokeAndFill Style as needed.
Fake Bold is disabled by default.
Returns true if approximate bold by increasing the stroke width when creating glyph bitmaps from outlines.
Equivalent to getFlags() masked with kFakeBoldText_Flag.
kFakeBoldText_Flag state
paint.isFakeBoldText() == !!(paint.getFlags() & SkPaint::kFakeBoldText_Flag) paint.isFakeBoldText() == !!(paint.getFlags() & SkPaint::kFakeBoldText_Flag)
Increases stroke width when creating glyph bitmaps to approximate a bold typeface.
Sets kFakeBoldText_Flag if fakeBoldText is true. Clears kFakeBoldText_Flag if fakeBoldText is false.
paint1 == paint2
if Hinting is set to kFull Hinting, Full Hinting Spacing adjusts the character spacing by the difference of the hinted and unhinted Left Side Bearing and Right Side Bearing. Full Hinting Spacing only applies to platforms that use FreeType as their Font Engine.
Full Hinting Spacing is not related to text kerning, where the space between a specific pair of characters is adjusted using data in the font kerning tables.
Deprecated.
Deprecated.
Filter Quality trades speed for image filtering when the image is scaled. A lower Filter Quality draws faster, but has less fidelity. A higher Filter Quality draws slower, but looks better. If the image is drawn without scaling, the Filter Quality choice will not result in a noticeable difference.
Filter Quality is used in Paint passed as a parameter to
and when Paint has a Shader specialization that uses Image or Bitmap.
Filter Quality is kNone_SkFilterQuality by default.
Returns SkFilterQuality, the image filtering level. A lower setting draws faster; a higher setting looks better when the image is scaled.
one of: kNone_SkFilterQuality, kLow_SkFilterQuality,
kMedium_SkFilterQuality, kHigh_SkFilterQuality
kNone_SkFilterQuality == paint.getFilterQuality()
Sets SkFilterQuality, the image filtering level. A lower setting draws faster; a higher setting looks better when the image is scaled. Does not check to see if quality is valid.
kMedium_SkFilterQuality, kHigh_SkFilterQuality
kHigh_SkFilterQuality == paint.getFilterQuality()
SkFilterQuality Image Scaling
| name | description |
|---|---|
| getColor | returns Color Alpha and RGB, one drawing color |
| setColor | sets Color Alpha and RGB, one drawing color |
Color specifies the red, blue, green, and Color Alpha values used to draw a filled or stroked shape in a 32-bit value. Each component occupies 8-bits, ranging from zero: no contribution; to 255: full intensity. All values in any combination are valid.
Color is not Premultiplied; Color Alpha sets the transparency independent of RGB: red, blue, and green.
The bit positions of Color Alpha and RGB are independent of the bit positions on the output device, which may have more or fewer bits, and may have a different arrangement.
| bit positions | Color Alpha | red | blue | green |
|---|---|---|---|---|
| 31 - 24 | 23 - 16 | 15 - 8 | 7 - 0 |
Retrieves alpha and RGB, unpremultiplied, packed into 32 bits. Use helpers SkColorGetA(), SkColorGetR(), SkColorGetG(), and SkColorGetB() to extract a color component.
unpremultiplied ARGB
Yellow is 100% red, 100% green, and 0% blue.
getColor4f SkColor
Retrieves alpha and RGB, unpremultiplied, as four floating point values. RGB are are extended sRGB values (sRGB gamut, and encoded with the sRGB transfer function).
unpremultiplied RGBA
Yellow is 100% red, 100% green, and 0% blue.
getColor SkColor
Sets alpha and RGB used when stroking and filling. The color is a 32-bit value, unpremultiplied, packing 8-bit components for alpha, red, blue, and green.
green1 == green2
SkColor setColor4f setARGB SkColorSetARGB
Sets alpha and RGB used when stroking and filling. The color is four floating point values, unpremultiplied. The color values are interpreted as being in the colorSpace. If colorSpace is nullptr, then color is assumed to be in the sRGB color space.
green1 == green2
SkColor setColor setARGB SkColorSetARGB
Color Alpha sets the transparency independent of RGB: red, blue, and green.
Retrieves alpha from the color used when stroking and filling.
alpha ranging from zero, fully transparent, to 255, fully opaque
255 == paint.getAlpha()
Replaces alpha, leaving RGB unchanged. An out of range value triggers an assert in the debug build. a is a value from zero to 255. a set to zero makes color fully transparent; a set to 255 makes color fully opaque.
0x44112233 == paint.getColor()
Sets color used when drawing solid fills. The color components range from 0 to 255. The color is unpremultiplied; alpha sets the transparency independent of RGB.
transRed1 == transRed2
setColor SkColorSetARGB
Style specifies if the geometry is filled, stroked, or both filled and stroked. Some shapes ignore Style and are always drawn filled or stroked.
Set Style to kFill Style to fill the shape. The fill covers the area inside the geometry for most shapes.
Set Style to kStroke Style to stroke the shape.
The stroke covers the area described by following the shape edge with a pen or brush of Stroke Width. The area covered where the shape starts and stops is described by Stroke Cap. The area covered where the shape turns a corner is described by Stroke Join. The stroke is centered on the shape; it extends equally on either side of the shape edge.As Stroke Width gets smaller, the drawn path frame is thinner. Stroke Width less than one may have gaps, and if kAntiAlias Flag is set, Color Alpha will increase to visually decrease coverage.
Path Fill Type Path Effect Style Fill Style Stroke
Stroke Width of zero has a special meaning and switches drawing to use Hairline. Hairline draws the thinnest continuous frame. If kAntiAlias Flag is clear, adjacent pixels flow horizontally, vertically,or diagonally.
Path drawing with Hairline may hit the same pixel more than once. For instance, Path containing two lines in one Path Contour will draw the corner point once, but may both lines may draw the adjacent pixel. If kAntiAlias Flag is set, transparency is applied twice, resulting in a darker pixel. Some GPU-backed implementations apply transparency at a later drawing stage, avoiding double hit pixels while stroking.
Path Fill Type Path Effect Style Fill Style Stroke
Set Style to fill, stroke, or both fill and stroke geometry. The stroke and fill share all paint attributes; for instance, they are drawn with the same color.
Use kStrokeAndFill Style to avoid hitting the same pixels twice with a stroke draw and a fill draw.
Returns whether the geometry is filled, stroked, or filled and stroked.
one of:kFill_Style, kStroke_Style, kStrokeAndFill_Style
SkPaint::kFill_Style == paint.getStyle()
Style setStyle
Sets whether the geometry is filled, stroked, or filled and stroked. Has no effect if style is not a legal SkPaint::Style value.
Style getStyle
Stroke Width sets the width for stroking. The width is the thickness of the stroke perpendicular to the path direction when the paint style is set to kStroke Style or kStrokeAndFill Style.
When width is greater than zero, the stroke encompasses as many pixels partially or fully as needed. When the width equals zero, the paint enables hairlines; the stroke is always one pixel wide.
The stroke dimensions are scaled by the canvas matrix, but Hairline stroke remains one pixel wide regardless of scaling.
The default width for the paint is zero.
Returns the thickness of the pen used by SkPaint to outline the shape.
zero for hairline, greater than zero for pen thickness
0 == paint.getStrokeWidth()
Sets the thickness of the pen used by the paint to outline the shape. Has no effect if width is less than zero.
5 == paint.getStrokeWidth()
Miter Limit specifies the maximum miter length, relative to the stroke width.
Miter Limit is used when the Stroke Join is set to kMiter Join, and the Style is either kStroke Style or kStrokeAndFill Style.
If the miter at a corner exceeds this limit, kMiter Join is replaced with kBevel Join.
Miter Limit can be computed from the corner angle using: miter limit = 1 / sin ( angle / 2 ).
Miter Limit default value is 4. The default may be changed at compile time by setting SkPaintDefaults MiterLimit in "SkUserConfig.h" or as a define supplied by the build environment.
Here are some miter limits and the angles that triggers them.
| miter limit | angle in degrees |
|---|---|
| 10 | 11.48 |
| 9 | 12.76 |
| 8 | 14.36 |
| 7 | 16.43 |
| 6 | 19.19 |
| 5 | 23.07 |
| 4 | 28.96 |
| 3 | 38.94 |
| 2 | 60 |
| 1 | 180 |
Returns the limit at which a sharp corner is drawn beveled.
zero and greater miter limit
default miter limit == 4
Miter Limit setStrokeMiter Join
Sets the limit at which a sharp corner is drawn beveled. Valid values are zero and greater. Has no effect if miter is less than zero.
default miter limit == 8
Miter Limit getStrokeMiter Join
Stroke Cap draws at the beginning and end of an open Path Contour.
Stroke describes the area covered by a pen of Stroke Width as it follows the Path Contour, moving parallel to the contour direction.
If the Path Contour is not terminated by SkPath::kClose Verb, the contour has a visible beginning and end.
Path Contour may start and end at the same point; defining Zero Length Contour.
kButt Cap and Zero Length Contour is not drawn. kRound Cap and Zero Length Contour draws a circle of diameter Stroke Width at the contour point. kSquare Cap and Zero Length Contour draws an upright square with a side of Stroke Width at the contour point.
Stroke Cap is kButt Cap by default.
Returns the geometry drawn at the beginning and end of strokes.
one of: kButt_Cap, kRound_Cap, kSquare_Cap
kButt_Cap == default stroke cap
Stroke Cap setStrokeCap
Sets the geometry drawn at the beginning and end of strokes.
has no effect if cap is not valid
kRound_Cap == paint.getStrokeCap()
Stroke Cap getStrokeCap
Stroke Join draws at the sharp corners of an open or closed Path Contour.
Stroke describes the area covered by a pen of Stroke Width as it follows the Path Contour, moving parallel to the contour direction.
If the contour direction changes abruptly, because the tangent direction leading to the end of a curve within the contour does not match the tangent direction of the following curve, the pair of curves meet at Stroke Join.
Join specifies how corners are drawn when a shape is stroked. Join affects the four corners of a stroked rectangle, and the connected segments in a stroked path.
Choose miter join to draw sharp corners. Choose round join to draw a circle with a radius equal to the stroke width on top of the corner. Choose bevel join to minimally connect the thick strokes.
The fill path constructed to describe the stroked path respects the join setting but may not contain the actual join. For instance, a fill path constructed with round joins does not necessarily include circles at each connected segment.
setStrokeJoin getStrokeJoin setStrokeMiter getStrokeMiter
Returns the geometry drawn at the corners of strokes.
one of: kMiter_Join, kRound_Join, kBevel_Join
kMiter_Join == default stroke join
Stroke Join setStrokeJoin
Sets the geometry drawn at the corners of strokes.
otherwise, has no effect
kMiter_Join == paint.getStrokeJoin()
Stroke Join getStrokeJoin
Miter Limit
Fill Path creates a Path by applying the Path Effect, followed by the Style Stroke.
If Paint contains Path Effect, Path Effect operates on the source Path; the result replaces the destination Path. Otherwise, the source Path is replaces the destination Path.
Fill Path can request the Path Effect to restrict to a culling rectangle, but the Path Effect is not required to do so.
If Style is kStroke Style or kStrokeAndFill Style, and Stroke Width is greater than zero, the Stroke Width, Stroke Cap, Stroke Join, and Miter Limit operate on the destination Path, replacing it.
Fill Path can specify the precision used by Stroke Width to approximate the stroke geometry.
If the Style is kStroke Style and the Stroke Width is zero, getFillPath returns false since Hairline has no filled equivalent.
Style Stroke Stroke Width Path Effect
Returns the filled equivalent of the stroked path.
to favor speed and size
true if the path represents style fill, or false if it represents hairline
Returns the filled equivalent of the stroked path.
Replaces dst with the src path modified by SkPathEffect and style stroke. SkPathEffect, if any, is not culled. stroke width is created with default precision.
true if the path represents style fill, or false if it represents hairline
Shader defines the colors used when drawing a shape. Shader may be an image, a gradient, or a computed fill. If Paint has no Shader, then Color fills the shape.
Shader is modulated by Color Alpha component of Color. If Shader object defines only Color Alpha, then Color modulated by Color Alpha describes the fill.
The drawn transparency can be modified without altering Shader, by changing Color Alpha.
If Shader generates only Color Alpha then all components of Color modulate the output.
Returns optional colors used when filling a path, such as a gradient.
Does not alter SkShader SkRefCnt.
SkShader if previously set, nullptr otherwise
nullptr == shader nullptr != shader
Returns optional colors used when filling a path, such as a gradient.
Increases SkShader SkRefCnt by one.
SkShader if previously set, nullptr otherwise
shader unique: true shader unique: false
Sets optional colors used when filling a path, such as a gradient.
Sets SkShader to shader, decreasing SkRefCnt of the previous SkShader. Increments shader SkRefCnt by one.
Color Filter alters the color used when drawing a shape. Color Filter may apply Blend Mode, transform the color through a matrix, or composite multiple filters. If Paint has no Color Filter, the color is unaltered.
The drawn transparency can be modified without altering Color Filter, by changing Color Alpha.
Returns SkColorFilter if set, or nullptr. Does not alter SkColorFilter SkRefCnt.
SkColorFilter if previously set, nullptr otherwise
nullptr == color filter nullptr != color filter
Returns SkColorFilter if set, or nullptr. Increases SkColorFilter SkRefCnt by one.
SkColorFilter if set, or nullptr
color filter unique: true color filter unique: false
Sets SkColorFilter to filter, decreasing SkRefCnt of the previous SkColorFilter. Pass nullptr to clear SkColorFilter.
Increments filter SkRefCnt by one.
Blend Mode describes how Color combines with the destination color. The default setting, SkBlendMode::kSrcOver, draws the source color over the destination color.
Blend Mode
Returns SkBlendMode. By default, returns SkBlendMode::kSrcOver.
mode used to combine source color with destination color
kSrcOver == getBlendMode kSrcOver != getBlendMode
Returns true if SkBlendMode is SkBlendMode::kSrcOver, the default.
true if SkBlendMode is SkBlendMode::kSrcOver
isSrcOver == true isSrcOver != true
Sets SkBlendMode to mode. Does not check for valid input.
isSrcOver == true isSrcOver != true
Path Effect modifies the path geometry before drawing it. Path Effect may implement dashing, custom fill effects and custom stroke effects. If Paint has no Path Effect, the path geometry is unaltered when filled or stroked.
Path Effect
Returns SkPathEffect if set, or nullptr. Does not alter SkPathEffect SkRefCnt.
SkPathEffect if previously set, nullptr otherwise
nullptr == path effect nullptr != path effect
Returns SkPathEffect if set, or nullptr. Increases SkPathEffect SkRefCnt by one.
SkPathEffect if previously set, nullptr otherwise
path effect unique: true path effect unique: false
Sets SkPathEffect to pathEffect, decreasing SkRefCnt of the previous SkPathEffect. Pass nullptr to leave the path geometry unaltered.
Increments pathEffect SkRefCnt by one.
Mask Filter uses coverage of the shape drawn to create Mask Alpha. Mask Filter takes a Mask, and returns a Mask.
Mask Filter may change the geometry and transparency of the shape, such as creating a blur effect. Set Mask Filter to nullptr to prevent Mask Filter from modifying the draw.
Returns SkMaskFilter if set, or nullptr. Does not alter SkMaskFilter SkRefCnt.
SkMaskFilter if previously set, nullptr otherwise
nullptr == mask filter nullptr != mask filter
Returns SkMaskFilter if set, or nullptr.
Increases SkMaskFilter SkRefCnt by one.
SkMaskFilter if previously set, nullptr otherwise
mask filter unique: true mask filter unique: false
Sets SkMaskFilter to maskFilter, decreasing SkRefCnt of the previous SkMaskFilter. Pass nullptr to clear SkMaskFilter and leave SkMaskFilter effect on mask alpha unaltered.
Increments maskFilter SkRefCnt by one.
Typeface identifies the font used when drawing and measuring text. Typeface may be specified by name, from a file, or from a data stream. The default Typeface defers to the platform-specific default font implementation.
Returns SkTypeface if set, or nullptr. Does not alter SkTypeface SkRefCnt.
SkTypeface if previously set, nullptr otherwise
nullptr == typeface nullptr != typeface
Increases SkTypeface SkRefCnt by one.
SkTypeface if previously set, nullptr otherwise
typeface1 != typeface2 typeface1 == typeface2
Sets SkTypeface to typeface, decreasing SkRefCnt of the previous SkTypeface. Pass nullptr to clear SkTypeface and use the default typeface. Increments typeface SkRefCnt by one.
Image Filter operates on the pixel representation of the shape, as modified by Paint with Blend Mode set to SkBlendMode::kSrcOver. Image Filter creates a new bitmap, which is drawn to the device using the set Blend Mode.
Image Filter is higher level than Mask Filter; for instance, an Image Filter can operate on all channels of Color, while Mask Filter generates Alpha only. Image Filter operates independently of and can be used in combination with Mask Filter.
Returns SkImageFilter if set, or nullptr. Does not alter SkImageFilter SkRefCnt.
SkImageFilter if previously set, nullptr otherwise
nullptr == image filter nullptr != image filter
Returns SkImageFilter if set, or nullptr. Increases SkImageFilter SkRefCnt by one.
SkImageFilter if previously set, nullptr otherwise
image filter unique: true image filter unique: false
Sets SkImageFilter to imageFilter, decreasing SkRefCnt of the previous SkImageFilter. Pass nullptr to clear SkImageFilter, and remove SkImageFilter effect on drawing.
Increments imageFilter SkRefCnt by one.
Draw Looper sets a modifier that communicates state from one Draw Layer to another to construct the draw.
Draw Looper draws one or more times, modifying the canvas and paint each time. Draw Looper may be used to draw multiple colors or create a colored shadow. Set Draw Looper to nullptr to prevent Draw Looper from modifying the draw.
Returns SkDrawLooper if set, or nullptr. Does not alter SkDrawLooper SkRefCnt.
SkDrawLooper if previously set, nullptr otherwise
nullptr == draw looper nullptr != draw looper
Returns SkDrawLooper if set, or nullptr. Increases SkDrawLooper SkRefCnt by one.
SkDrawLooper if previously set, nullptr otherwise
draw looper unique: true draw looper unique: false
Deprecated.
Sets SkDrawLooper to drawLooper, decreasing SkRefCnt of the previous drawLooper. Pass nullptr to clear SkDrawLooper and leave SkDrawLooper effect on drawing unaltered.
Increments drawLooper SkRefCnt by one.
Deprecated.
Deprecated.
Deprecated.
Deprecated.
Text Size adjusts the overall text size in points. Text Size can be set to any positive value or zero. Text Size defaults to 12. Set SkPaintDefaults TextSize at compile time to change the default setting.
Returns text size in points.
typographic height of text
Sets text size in points. Has no effect if textSize is not greater than or equal to zero.
Text Scale X adjusts the text horizontal scale. Text scaling approximates condensed and expanded type faces when the actual face is not available. Text Scale X can be set to any value. Text Scale X defaults to 1.
Returns text scale on x-axis. Default value is 1.
text horizontal scale
Sets text scale on x-axis. Default value is 1.
Text Skew X adjusts the text horizontal slant. Text skewing approximates italic and oblique type faces when the actual face is not available. Text Skew X can be set to any value. Text Skew X defaults to 0.
Returns text skew on x-axis. Default value is zero.
additional shear on x-axis relative to y-axis
Sets text skew on x-axis. Default value is zero.
TextEncoding determines whether text specifies character codes and their encoded size, or glyph indices. Characters are encoded as specified by the Unicode standard .
Character codes encoded size are specified by UTF-8, UTF-16, or UTF-32. All character code formats are able to represent all of Unicode, differing only in the total storage required.
UTF-8 (RFC 3629) encodes each character as one or more 8-bit bytes.
UTF-16 (RFC 2781) encodes each character as one or two 16-bit words.
UTF-32 encodes each character as one 32-bit word.
Font Manager uses font data to convert character code points into glyph indices. A glyph index is a 16-bit word.
TextEncoding is set to kUTF8 TextEncoding by default.
Returns SkPaint::TextEncoding. SkPaint::TextEncoding determines how character code points are mapped to font glyph indices.
one of: kUTF8_TextEncoding, kUTF16_TextEncoding, kUTF32_TextEncoding, or
kGlyphID_TextEncoding
kUTF8_TextEncoding == text encoding kGlyphID_TextEncoding == text encoding
Sets SkPaint::TextEncoding to encoding. SkPaint::TextEncoding determines how character code points are mapped to font glyph indices. Invalid values for encoding are ignored.
kGlyphID_TextEncoding
4 != text encoding
Font Metrics describe dimensions common to the Glyphs in Typeface. The dimensions are computed by Font Manager from font data and do not take Paint settings other than Text Size into account.
Font dimensions specify the anchor to the left of the glyph at baseline as the origin. X-axis values to the left of the glyph are negative, and to the right of the left glyph edge are positive. Y-axis values above the baseline are negative, and below the baseline are positive.
FontMetrics is filled out by getFontMetrics. FontMetrics contents reflect the values computed by Font Manager using Typeface. Values are set to zero if they are not available.
All vertical values are relative to the baseline, on a y-axis pointing down. Zero is on the baseline, negative values are above the baseline, and positive values are below the baseline.
fUnderlineThickness and fUnderlinePosition have a bit set in fFlags if their values are valid, since their value may be zero.
fStrikeoutThickness and fStrikeoutPosition have a bit set in fFlags if their values are valid, since their value may be zero.
FontMetricsFlags are set in fFlags when underline and strikeout metrics are valid; the underline or strikeout metric may be valid and zero. Fonts with embedded bitmaps may not have valid underline or strikeout metrics.
If the metric is valid, the kUnderlinePositionIsValid Flag is set in fFlags. If kUnderlinePositionIsValid Flag is clear, fUnderlinePosition is zero.
If the metric is valid, the kStrikeoutPositionIsValid Flag is set in fFlags. If kStrikeoutPositionIsValid Flag is clear, fStrikeoutPosition is zero.
Returns true if SkPaint::FontMetrics has a valid underline thickness, and sets thickness to that value. If the underline thickness is not valid, return false, and ignore thickness.
true if font specifies underline width
Returns true if SkPaint::FontMetrics has a valid underline position, and sets position to that value. If the underline position is not valid, return false, and ignore position.
true if font specifies underline position
Returns true if SkPaint::FontMetrics has a valid strikeout thickness, and sets thickness to that value. If the underline thickness is not valid, return false, and ignore thickness.
true if font specifies strikeout width
Returns true if SkPaint::FontMetrics has a valid strikeout position, and sets position to that value. If the underline position is not valid, return false, and ignore position.
true if font specifies strikeout position
Returns SkPaint::FontMetrics associated with SkTypeface. The return value is the recommended spacing between lines: the sum of metrics descent, ascent, and leading. If metrics is not nullptr, SkPaint::FontMetrics is copied to metrics. Results are scaled by text size but does not take into account dimensions required by text scale x, text skew x, fake bold, style stroke, and SkPathEffect. Results can be additionally scaled by scale; a scale of zero is ignored.
recommended spacing between lines
Text Size Typeface Typeface Methods
Returns the recommended spacing between lines: the sum of metrics descent, ascent, and leading. Result is scaled by text size but does not take into account dimensions required by stroking and SkPathEffect. Returns the same result as getFontMetrics().
recommended spacing between lines
textSize: 12 fontSpacing: 13.9688 textSize: 18 fontSpacing: 20.9531 textSize: 24 fontSpacing: 27.9375 textSize: 32 fontSpacing: 37.25
Returns the union of bounds of all glyphs. Returned dimensions are computed by font manager from font data, ignoring SkPaint::Hinting. Includes text size, text scale x, and text skew x, but not fake bold or SkPathEffect.
If text size is large, text scale x is one, and text skew x is zero, returns the same bounds as: { FontMetrics::fXMin, FontMetrics::fTop, FontMetrics::fXMax, FontMetrics::fBottom }.
union of bounds of all glyphs
metrics bounds = { -12.2461, -14.7891, 21.5215, 5.55469 }
font bounds = { -12.2461, -14.7891, 21.5215, 5.55469 }
Converts text into glyph indices. Returns the number of glyph indices represented by text. SkPaint::TextEncoding specifies how text represents characters or glyphs. glyphs may be nullptr, to compute the glyph count.
Does not check text for valid character codes or valid glyph indices.
If byteLength equals zero, returns zero. If byteLength includes a partial character, the partial character is ignored.
If SkPaint::TextEncoding is kUTF8_TextEncoding and text contains an invalid UTF-8 sequence, zero is returned.
number of glyphs represented by text of length byteLength
Returns the number of glyphs in text. Uses SkPaint::TextEncoding to count the glyphs. Returns the same result as textToGlyphs().
number of glyphs represented by text of length byteLength
count = 5
Returns true if all text corresponds to a non-zero glyph index. Returns false if any characters in text are not supported in SkTypeface.
If SkPaint::TextEncoding is kGlyphID_TextEncoding, returns true if all glyph indices in text are non-zero; does not check to see if text contains valid glyph indices for SkTypeface.
Returns true if byteLength is zero.
true if all text corresponds to a non-zero glyph index
0x00b0 == has char 0xd800 != has char
0x01ff == has glyph 0x0000 != has glyph 0xffff == has glyph
setTextEncoding Typeface
Converts glyphs into text if possible. Glyph values without direct Unicode equivalents are mapped to zero. Uses the SkTypeface, but is unaffected by SkPaint::TextEncoding; the text values returned are equivalent to kUTF32_TextEncoding.
Only supported on platforms that use FreeType as the font engine.
Returns the advance width of text. The advance is the normal distance to move before drawing additional text. Uses SkPaint::TextEncoding to decode text, SkTypeface to get the font metrics, and text size, text scale x, text skew x, stroke width, and SkPathEffect to scale the metrics and bounds. Returns the bounding box of text if bounds is not nullptr. The bounding box is computed as if the text was drawn at the origin.
advance width or height
Returns the advance width of text. The advance is the normal distance to move before drawing additional text. Uses SkPaint::TextEncoding to decode text, SkTypeface to get the font metrics, and text size to scale the metrics. Does not scale the advance or bounds by fake bold or SkPathEffect.
advance width or height
default width = 5 double width = 10
Returns the bytes of text that fit within maxWidth. The text fragment fits if its advance width is less than or equal to maxWidth. Measures only while the advance is less than or equal to maxWidth. Returns the advance or the text fragment in measuredWidth if it not nullptr. Uses SkPaint::TextEncoding to decode text, SkTypeface to get the font metrics, and text size to scale the metrics. Does not scale the advance or bounds by fake bold or SkPathEffect.
bytes of text that fit, always less than or equal to length
Retrieves the advance and bounds for each glyph in text, and returns the glyph count in text. Both widths and bounds may be nullptr. If widths is not nullptr, widths must be an array of glyph count entries. if bounds is not nullptr, bounds must be an array of glyph count entries. Uses SkPaint::TextEncoding to decode text, SkTypeface to get the font metrics, and text size to scale the widths and bounds. Does not scale the advance by fake bold or SkPathEffect. Does include fake bold and SkPathEffect in the bounds.
glyph count in text
Text Path describes the geometry of Glyphs used to draw text.
Returns the geometry as SkPath equivalent to the drawn text. Uses SkPaint::TextEncoding to decode text, SkTypeface to get the glyph paths, and text size, fake bold, and SkPathEffect to scale and modify the glyph paths. All of the glyph paths are stored in path. Uses x, y, and SkPaint::Align to position path.
Returns the geometry as SkPath equivalent to the drawn text. Uses SkPaint::TextEncoding to decode text, SkTypeface to get the glyph paths, and text size, fake bold, and SkPathEffect to scale and modify the glyph paths. All of the glyph paths are stored in path. Uses pos array and SkPaint::Align to position path. pos contains a position for each glyph.
Text Intercepts describe the intersection of drawn text Glyphs with a pair of lines parallel to the text advance. Text Intercepts permits creating a underline that skips Descenders.
Returns the number of intervals that intersect bounds. bounds describes a pair of lines parallel to the text advance. The return count is zero or a multiple of two, and is at most twice the number of glyphs in the string. Uses SkPaint::TextEncoding to decode text, SkTypeface to get the glyph paths, and text size, fake bold, and SkPathEffect to scale and modify the glyph paths. Uses x, y, and SkPaint::Align to position intervals.
Pass nullptr for intervals to determine the size of the interval array.
intervals are cached to improve performance for multiple calls.
number of intersections; may be zero
Returns the number of intervals that intersect bounds. bounds describes a pair of lines parallel to the text advance. The return count is zero or a multiple of two, and is at most twice the number of glyphs in the string. Uses SkPaint::TextEncoding to decode text, SkTypeface to get the glyph paths, and text size, fake bold, and SkPathEffect to scale and modify the glyph paths. Uses pos array and SkPaint::Align to position intervals.
Pass nullptr for intervals to determine the size of the interval array.
intervals are cached to improve performance for multiple calls.
number of intersections; may be zero
Returns the number of intervals that intersect bounds. bounds describes a pair of lines parallel to the text advance. The return count is zero or a multiple of two, and is at most twice the number of glyphs in the string. Uses SkPaint::TextEncoding to decode text, SkTypeface to get the glyph paths, and text size, fake bold, and SkPathEffect to scale and modify the glyph paths. Uses xpos array, constY, and SkPaint::Align to position intervals.
Pass nullptr for intervals to determine the size of the interval array.
intervals are cached to improve performance for multiple calls.
number of intersections; may be zero
Returns the number of intervals that intersect bounds. bounds describes a pair of lines parallel to the text advance. The return count is zero or a multiple of two, and is at most twice the number of glyphs in the string. Uses SkTypeface to get the glyph paths, and text size, fake bold, and SkPathEffect to scale and modify the glyph paths. Uses run array and SkPaint::Align to position intervals.
SkPaint::TextEncoding must be set to SkPaint::kGlyphID_TextEncoding.
Pass nullptr for intervals to determine the size of the interval array.
intervals are cached to improve performance for multiple calls.
number of intersections; may be zero
Returns true if SkPaint prevents all drawing; otherwise, the SkPaint may or may not allow drawing.
Returns true if, for example, SkBlendMode combined with alpha computes a new alpha of zero.
true if SkPaint prevents all drawing
initial nothing to draw: false blend dst nothing to draw: true blend src over nothing to draw: false alpha 0 nothing to draw: true
Private: To be made private.
Fast Bounds functions conservatively outset a drawing bounds by additional area Paint may draw to.
Private: (to be made private)
Returns true if Paint does not include elements requiring extensive computation to compute Device bounds of drawn geometry. For instance, Paint with Path Effect always returns false.
true if Paint allows for fast computation of bounds
Private: (to be made private)
Only call this if canComputeFastBounds returned true. This takes a raw rectangle (the raw bounds of a shape), and adjusts it for stylistic effects in the paint (e.g. stroking). If needed, it uses the storage parameter. It returns the adjusted bounds that can then be used for SkCanvas::quickReject tests.
The returned Rect will either be orig or storage, thus the caller should not rely on storage being set to the result, but should always use the returned value. It is legal for orig and storage to be the same Rect.
Private: For example: if (!path.isInverseFillType() && paint.canComputeFastBounds()) { SkRect storage; if (canvas->quickReject(paint.computeFastBounds(path.getBounds(), &storage))) { return; // do not draw the path } } // draw the path
fast computed bounds
Private: (to be made private)
fast computed bounds
Private: (to be made private)
Computes the bounds, overriding the Paint Style. This can be used to account for additional width required by stroking orig, without altering Style set to fill.
fast computed bounds