Search documentation of wx

# wxGraphicsContext (wx v2.5.4)

Copy Markdown View Source

A `wxGraphicsContext` instance is the object that is drawn upon.

It is created by a renderer using `wxGraphicsRenderer:createContext/2`. This can be either directly using a renderer instance, or indirectly using the static convenience `create/1` functions of `wxGraphicsContext` that always delegate the task to the default renderer.

Remark: For some renderers (like Direct2D or Cairo) processing of drawing operations may be deferred (Direct2D render target normally builds up a batch of rendering commands but defers processing of these commands, Cairo operates on a separate surface) so to make drawing results visible you need to update the content of the context by calling `wxGraphicsContext::Flush()` (not implemented in wx) or by destroying the context.

See:

- `wxGraphicsRenderer:createContext/2`

- `wxGCDC`

- `wxDC`

This class is derived, and can use functions, from:

- `wxGraphicsObject`

wxWidgets docs: wxGraphicsContext

## Summary

### Types

wxGraphicsContext()

### Functions

clip(This, Region)

Sets the clipping region to the intersection of the given region and the previously set clipping region.

clip(This, X, Y, W, H)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

concatTransform(This, Matrix)

Concatenates the passed in transform with the current transform of this context.

create()

Create a lightweight context that can be used only for measuring text.

create(WindowDC)

Creates a `wxGraphicsContext` from a `wxWindowDC`.

createBrush(This, Brush)

Creates a native brush from a `wxBrush`.

createFont(This, Font)

Equivalent to `createFont(This, Font, [])`.

createFont/3

Creates a native graphics font from a `wxFont` and a text colour.

createFont/4

Creates a font object with the specified attributes.

createLinearGradientBrush(This, X1, Y1, X2, Y2, Stops)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

createLinearGradientBrush(This, X1, Y1, X2, Y2, C1, C2)

`Creates a native brush with a linear gradient. The brush starts at (@a x1, @a y1) and ends at (@a x2, @a y2). Either just the start and end gradient colours (@a c1 and @a c2) or full set of gradient @a stops can be specified. The version taking wxGraphicsGradientStops is new in wxWidgets 2.9.1.` The `matrix` parameter was added in wxWidgets 3.1.3

createMatrix(This)

Equivalent to `createMatrix(This, [])`.

createMatrix/2

Creates a native affine transformation matrix from the passed in values.

createPath(This)

Creates a native graphics path which is initially empty.

createPen(This, Pen)

Creates a native pen from a `wxPen`.

createRadialGradientBrush(This, StartX, StartY, EndX, EndY, Radius, Stops)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

createRadialGradientBrush(This, StartX, StartY, EndX, EndY, Radius, OColor, CColor)

`Creates a native brush with a radial gradient. The brush originates at (@a startX, @a startY) and ends on a circle around (@a endX, @a endY) with the given @a radius. The gradient may be specified either by its start and end colours @a oColor and @a cColor or by a full set of gradient @a stops. The version taking wxGraphicsGradientStops is new in wxWidgets 2.9.1.` The ability to apply a transformation matrix to the gradient was added in 3.1.3

destroy(This)

Destroys the object

drawBitmap(This, Bmp, X, Y, W, H)

Draws the bitmap.

drawEllipse(This, X, Y, W, H)

Draws an ellipse.

drawIcon(This, Icon, X, Y, W, H)

Draws the icon.

drawLines(This, Points)

Equivalent to `drawLines(This, Points, [])`.

drawLines/3

Draws a polygon.

drawPath(This, Path)

Equivalent to `drawPath(This, Path, [])`.

drawPath/3

Draws the path by first filling and then stroking.

drawRectangle(This, X, Y, W, H)

Draws a rectangle.

drawRoundedRectangle(This, X, Y, W, H, Radius)

Draws a rounded rectangle.

drawText(This, Str, X, Y)

Draws text at the defined position.

drawText/5

Draws text at the defined position.

drawText(This, Str, X, Y, Angle, BackgroundBrush)

Draws text at the defined position.

fillPath(This, Path)

Equivalent to `fillPath(This, Path, [])`.

fillPath/3

Fills the path with the current brush.

getPartialTextExtents(This, Text)

Fills the `widths` array with the widths from the beginning of `text` to the corresponding character of `text`.

getTextExtent(This, Text)

Gets the dimensions of the string using the currently selected font.

getTransform(This)

Gets the current transformation matrix of this context.

resetClip(This)

Resets the clipping to original shape.

rotate(This, Angle)

Rotates the current transformation matrix (in radians).

scale(This, XScale, YScale)

Scales the current transformation matrix.

setBrush(This, Brush)

Sets the brush for filling paths.

setFont(This, Font)

Sets the font for drawing text.

setFont(This, Font, Colour)

Sets the font for drawing text.

setPen(This, Pen)

Sets the pen used for stroking.

setTransform(This, Matrix)

Sets the current transformation matrix of this context.

strokeLine(This, X1, Y1, X2, Y2)

Strokes a single line.

strokeLines(This, Points)

Stroke lines connecting all the points.

strokePath(This, Path)

Strokes along a path with the current pen.

translate(This, Dx, Dy)

Translates the current transformation matrix.

## Types

# wxGraphicsContext()

    -type wxGraphicsContext() :: wx:wx_object().

## Functions

# clip(This, Region)

    -spec clip(This, Region) -> ok when This :: wxGraphicsContext(), Region :: wxRegion:wxRegion().

Sets the clipping region to the intersection of the given region and the previously set clipping region.

The clipping region is an area to which drawing is restricted.

Remark:

- Clipping region should be given in logical coordinates.

- Calling this function can only make the clipping region smaller, never larger.

- You need to call `resetClip/1` first if you want to set the clipping region exactly to the region specified.

- If resulting clipping region is empty, then all drawing upon the context is clipped out (all changes made by drawing operations are masked out).

# clip(This, X, Y, W, H)

    -spec clip(This, X, Y, W, H) -> ok
                  when
                      This :: wxGraphicsContext(),
                      X :: number(),
                      Y :: number(),
                      W :: number(),
                      H :: number().

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

# concatTransform(This, Matrix)

    -spec concatTransform(This, Matrix) -> ok
                             when This :: wxGraphicsContext(), Matrix :: wxGraphicsMatrix:wxGraphicsMatrix().

Concatenates the passed in transform with the current transform of this context.

# create()

    -spec create() -> wxGraphicsContext().

Create a lightweight context that can be used only for measuring text.

# create(WindowDC)

    -spec create(WindowDC) -> wxGraphicsContext()
                    when
                        WindowDC ::
                            wxWindowDC:wxWindowDC() |
                            wxWindow:wxWindow() |
                            wxMemoryDC:wxMemoryDC() |
                            wxImage:wxImage().

Creates a `wxGraphicsContext` from a `wxWindowDC`.

See: `wxGraphicsRenderer:createContext/2`

# createBrush(This, Brush)

    -spec createBrush(This, Brush) -> wxGraphicsBrush:wxGraphicsBrush()
                         when This :: wxGraphicsContext(), Brush :: wxBrush:wxBrush().

Creates a native brush from a `wxBrush`.

# createFont(This, Font)

    -spec createFont(This, Font) -> wxGraphicsFont:wxGraphicsFont()
                        when This :: wxGraphicsContext(), Font :: wxFont:wxFont().

Equivalent to `createFont(This, Font, [])`.

# createFont/3

    -spec createFont(This, SizeInPixels, Facename) -> wxGraphicsFont:wxGraphicsFont()
                        when
                            This :: wxGraphicsContext(),
                            SizeInPixels :: number(),
                            Facename :: unicode:chardata();
                    (This, Font, [Option]) -> wxGraphicsFont:wxGraphicsFont()
                        when
                            This :: wxGraphicsContext(),
                            Font :: wxFont:wxFont(),
                            Option :: {col, wx:wx_colour()}.

Creates a native graphics font from a `wxFont` and a text colour.

Remark: For Direct2D graphics fonts can be created from TrueType fonts only.

# createFont/4

    -spec createFont(This, SizeInPixels, Facename, [Option]) -> wxGraphicsFont:wxGraphicsFont()
                        when
                            This :: wxGraphicsContext(),
                            SizeInPixels :: number(),
                            Facename :: unicode:chardata(),
                            Option :: {flags, integer()} | {col, wx:wx_colour()}.

Creates a font object with the specified attributes.

The use of overload taking `wxFont` is preferred, see `wxGraphicsRenderer:createFont/4` for more details.

Remark: For Direct2D graphics fonts can be created from TrueType fonts only.

Since: 2.9.3

# createLinearGradientBrush(This, X1, Y1, X2, Y2, Stops)

    -spec createLinearGradientBrush(This, X1, Y1, X2, Y2, Stops) -> wxGraphicsBrush:wxGraphicsBrush()
                                       when
                                           This :: wxGraphicsContext(),
                                           X1 :: number(),
                                           Y1 :: number(),
                                           X2 :: number(),
                                           Y2 :: number(),
                                           Stops :: wxGraphicsGradientStops:wxGraphicsGradientStops().

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

# createLinearGradientBrush(This, X1, Y1, X2, Y2, C1, C2)

    -spec createLinearGradientBrush(This, X1, Y1, X2, Y2, C1, C2) -> wxGraphicsBrush:wxGraphicsBrush()
                                       when
                                           This :: wxGraphicsContext(),
                                           X1 :: number(),
                                           Y1 :: number(),
                                           X2 :: number(),
                                           Y2 :: number(),
                                           C1 :: wx:wx_colour(),
                                           C2 :: wx:wx_colour().

`Creates a native brush with a linear gradient. The brush starts at (@a x1, @a y1) and ends at (@a x2, @a y2). Either just the start and end gradient colours (@a c1 and @a c2) or full set of gradient @a stops can be specified. The version taking wxGraphicsGradientStops is new in wxWidgets 2.9.1.` The `matrix` parameter was added in wxWidgets 3.1.3

# createMatrix(This)

    -spec createMatrix(This) -> wxGraphicsMatrix:wxGraphicsMatrix() when This :: wxGraphicsContext().

Equivalent to `createMatrix(This, [])`.

# createMatrix/2

    -spec createMatrix(This, [Option]) -> wxGraphicsMatrix:wxGraphicsMatrix()
                          when
                              This :: wxGraphicsContext(),
                              Option ::
                                  {a, number()} |
                                  {b, number()} |
                                  {c, number()} |
                                  {d, number()} |
                                  {tx, number()} |
                                  {ty, number()}.

Creates a native affine transformation matrix from the passed in values.

The default parameters result in an identity matrix.

# createPath(This)

    -spec createPath(This) -> wxGraphicsPath:wxGraphicsPath() when This :: wxGraphicsContext().

Creates a native graphics path which is initially empty.

# createPen(This, Pen)

    -spec createPen(This, Pen) -> wxGraphicsPen:wxGraphicsPen()
                       when This :: wxGraphicsContext(), Pen :: wxPen:wxPen().

Creates a native pen from a `wxPen`.

Prefer to use the overload taking `wxGraphicsPenInfo` (not implemented in wx) unless you already have a `wxPen` as constructing one only to pass it to this method is wasteful.

# createRadialGradientBrush(This, StartX, StartY, EndX, EndY, Radius, Stops)

    -spec createRadialGradientBrush(This, StartX, StartY, EndX, EndY, Radius, Stops) ->
                                       wxGraphicsBrush:wxGraphicsBrush()
                                       when
                                           This :: wxGraphicsContext(),
                                           StartX :: number(),
                                           StartY :: number(),
                                           EndX :: number(),
                                           EndY :: number(),
                                           Radius :: number(),
                                           Stops :: wxGraphicsGradientStops:wxGraphicsGradientStops().

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

# createRadialGradientBrush(This, StartX, StartY, EndX, EndY, Radius, OColor, CColor)

    -spec createRadialGradientBrush(This, StartX, StartY, EndX, EndY, Radius, OColor, CColor) ->
                                       wxGraphicsBrush:wxGraphicsBrush()
                                       when
                                           This :: wxGraphicsContext(),
                                           StartX :: number(),
                                           StartY :: number(),
                                           EndX :: number(),
                                           EndY :: number(),
                                           Radius :: number(),
                                           OColor :: wx:wx_colour(),
                                           CColor :: wx:wx_colour().

`Creates a native brush with a radial gradient. The brush originates at (@a startX, @a startY) and ends on a circle around (@a endX, @a endY) with the given @a radius. The gradient may be specified either by its start and end colours @a oColor and @a cColor or by a full set of gradient @a stops. The version taking wxGraphicsGradientStops is new in wxWidgets 2.9.1.` The ability to apply a transformation matrix to the gradient was added in 3.1.3

# destroy(This)

    -spec destroy(This :: wxGraphicsContext()) -> ok.

Destroys the object

# drawBitmap(This, Bmp, X, Y, W, H)

    -spec drawBitmap(This, Bmp, X, Y, W, H) -> ok
                        when
                            This :: wxGraphicsContext(),
                            Bmp :: wxBitmap:wxBitmap(),
                            X :: number(),
                            Y :: number(),
                            W :: number(),
                            H :: number().

Draws the bitmap.

In case of a mono bitmap, this is treated as a mask and the current brushed is used for filling.

# drawEllipse(This, X, Y, W, H)

    -spec drawEllipse(This, X, Y, W, H) -> ok
                         when
                             This :: wxGraphicsContext(),
                             X :: number(),
                             Y :: number(),
                             W :: number(),
                             H :: number().

Draws an ellipse.

# drawIcon(This, Icon, X, Y, W, H)

    -spec drawIcon(This, Icon, X, Y, W, H) -> ok
                      when
                          This :: wxGraphicsContext(),
                          Icon :: wxIcon:wxIcon(),
                          X :: number(),
                          Y :: number(),
                          W :: number(),
                          H :: number().

Draws the icon.

# drawLines(This, Points)

    -spec drawLines(This, Points) -> ok
                       when This :: wxGraphicsContext(), Points :: [{X :: float(), Y :: float()}].

Equivalent to `drawLines(This, Points, [])`.

# drawLines/3

    -spec drawLines(This, Points, [Option]) -> ok
                       when
                           This :: wxGraphicsContext(),
                           Points :: [{X :: float(), Y :: float()}],
                           Option :: {fillStyle, wx:wx_enum()}.

Draws a polygon.

# drawPath(This, Path)

    -spec drawPath(This, Path) -> ok
                      when This :: wxGraphicsContext(), Path :: wxGraphicsPath:wxGraphicsPath().

Equivalent to `drawPath(This, Path, [])`.

# drawPath/3

    -spec drawPath(This, Path, [Option]) -> ok
                      when
                          This :: wxGraphicsContext(),
                          Path :: wxGraphicsPath:wxGraphicsPath(),
                          Option :: {fillStyle, wx:wx_enum()}.

Draws the path by first filling and then stroking.

# drawRectangle(This, X, Y, W, H)

    -spec drawRectangle(This, X, Y, W, H) -> ok
                           when
                               This :: wxGraphicsContext(),
                               X :: number(),
                               Y :: number(),
                               W :: number(),
                               H :: number().

Draws a rectangle.

# drawRoundedRectangle(This, X, Y, W, H, Radius)

    -spec drawRoundedRectangle(This, X, Y, W, H, Radius) -> ok
                                  when
                                      This :: wxGraphicsContext(),
                                      X :: number(),
                                      Y :: number(),
                                      W :: number(),
                                      H :: number(),
                                      Radius :: number().

Draws a rounded rectangle.

# drawText(This, Str, X, Y)

    -spec drawText(This, Str, X, Y) -> ok
                      when
                          This :: wxGraphicsContext(),
                          Str :: unicode:chardata(),
                          X :: number(),
                          Y :: number().

Draws text at the defined position.

# drawText/5

    -spec drawText(This, Str, X, Y, Angle) -> ok
                      when
                          This :: wxGraphicsContext(),
                          Str :: unicode:chardata(),
                          X :: number(),
                          Y :: number(),
                          Angle :: number();
                  (This, Str, X, Y, BackgroundBrush) -> ok
                      when
                          This :: wxGraphicsContext(),
                          Str :: unicode:chardata(),
                          X :: number(),
                          Y :: number(),
                          BackgroundBrush :: wxGraphicsBrush:wxGraphicsBrush().

Draws text at the defined position.

# drawText(This, Str, X, Y, Angle, BackgroundBrush)

    -spec drawText(This, Str, X, Y, Angle, BackgroundBrush) -> ok
                      when
                          This :: wxGraphicsContext(),
                          Str :: unicode:chardata(),
                          X :: number(),
                          Y :: number(),
                          Angle :: number(),
                          BackgroundBrush :: wxGraphicsBrush:wxGraphicsBrush().

Draws text at the defined position.

# fillPath(This, Path)

    -spec fillPath(This, Path) -> ok
                      when This :: wxGraphicsContext(), Path :: wxGraphicsPath:wxGraphicsPath().

Equivalent to `fillPath(This, Path, [])`.

# fillPath/3

    -spec fillPath(This, Path, [Option]) -> ok
                      when
                          This :: wxGraphicsContext(),
                          Path :: wxGraphicsPath:wxGraphicsPath(),
                          Option :: {fillStyle, wx:wx_enum()}.

Fills the path with the current brush.

# getPartialTextExtents(This, Text)

    -spec getPartialTextExtents(This, Text) -> [number()]
                                   when This :: wxGraphicsContext(), Text :: unicode:chardata().

Fills the `widths` array with the widths from the beginning of `text` to the corresponding character of `text`.

# getTextExtent(This, Text)

    -spec getTextExtent(This, Text) -> Result
                           when
                               Result ::
                                   {Width :: number(),
                                    Height :: number(),
                                    Descent :: number(),
                                    ExternalLeading :: number()},
                               This :: wxGraphicsContext(),
                               Text :: unicode:chardata().

Gets the dimensions of the string using the currently selected font.

# getTransform(This)

    -spec getTransform(This) -> wxGraphicsMatrix:wxGraphicsMatrix() when This :: wxGraphicsContext().

Gets the current transformation matrix of this context.

# resetClip(This)

    -spec resetClip(This) -> ok when This :: wxGraphicsContext().

Resets the clipping to original shape.

# rotate(This, Angle)

    -spec rotate(This, Angle) -> ok when This :: wxGraphicsContext(), Angle :: number().

Rotates the current transformation matrix (in radians).

# scale(This, XScale, YScale)

    -spec scale(This, XScale, YScale) -> ok
                   when This :: wxGraphicsContext(), XScale :: number(), YScale :: number().

Scales the current transformation matrix.

# setBrush(This, Brush)

    -spec setBrush(This, Brush) -> ok
                      when
                          This :: wxGraphicsContext(),
                          Brush :: wxGraphicsBrush:wxGraphicsBrush() | wxBrush:wxBrush().

Sets the brush for filling paths.

# setFont(This, Font)

    -spec setFont(This, Font) -> ok
                     when This :: wxGraphicsContext(), Font :: wxGraphicsFont:wxGraphicsFont().

Sets the font for drawing text.

# setFont(This, Font, Colour)

    -spec setFont(This, Font, Colour) -> ok
                     when This :: wxGraphicsContext(), Font :: wxFont:wxFont(), Colour :: wx:wx_colour().

Sets the font for drawing text.

Remark: For Direct2D only TrueType fonts can be used.

# setPen(This, Pen)

    -spec setPen(This, Pen) -> ok
                    when This :: wxGraphicsContext(), Pen :: wxPen:wxPen() | wxGraphicsPen:wxGraphicsPen().

Sets the pen used for stroking.

# setTransform(This, Matrix)

    -spec setTransform(This, Matrix) -> ok
                          when This :: wxGraphicsContext(), Matrix :: wxGraphicsMatrix:wxGraphicsMatrix().

Sets the current transformation matrix of this context.

# strokeLine(This, X1, Y1, X2, Y2)

    -spec strokeLine(This, X1, Y1, X2, Y2) -> ok
                        when
                            This :: wxGraphicsContext(),
                            X1 :: number(),
                            Y1 :: number(),
                            X2 :: number(),
                            Y2 :: number().

Strokes a single line.

# strokeLines(This, Points)

    -spec strokeLines(This, Points) -> ok
                         when This :: wxGraphicsContext(), Points :: [{X :: float(), Y :: float()}].

Stroke lines connecting all the points.

Unlike the other overload of this function, this method draws a single polyline and not a number of disconnected lines.

# strokePath(This, Path)

    -spec strokePath(This, Path) -> ok
                        when This :: wxGraphicsContext(), Path :: wxGraphicsPath:wxGraphicsPath().

Strokes along a path with the current pen.

# translate(This, Dx, Dy)

    -spec translate(This, Dx, Dy) -> ok when This :: wxGraphicsContext(), Dx :: number(), Dy :: number().

Translates the current transformation matrix.