---
name: "wxGraphicsContext"
section: "3erl"
platform: "linux"
package: "erlang-manpages"
version: "1:25.2.3+dfsg-1+deb12u4"
release: "Debian 12 (Bookworm)"
platforms: ["linux"]
url: "https://new.carta.tech/wxGraphicsContext"
---

# wxGraphicsContext(3erl)

Functions for wxGraphicsContext class

## NAME

wxGraphicsContext - Functions for wxGraphicsContext class

## DESCRIPTION

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

## DATA TYPES

```
wxGraphicsContext() = wx:wx_object()
```

## EXPORTS

```
destroy(This :: wxGraphicsContext()) -> ok
```

Creates a *wxGraphicsContext* from a *wxWindow*.

See: *wxGraphicsRenderer:createContext/2*

```
create() -> wxGraphicsContext()
```

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

```
create(WindowDC) -> wxGraphicsContext()
```

Types:

WindowDC = \
\
     wxWindowDC:wxWindowDC() \|\
\
     wxWindow:wxWindow() \|\
\
     wxMemoryDC:wxMemoryDC() \|\
\
     wxImage:wxImage()\

Creates a *wxGraphicsContext* from a *wxWindowDC*.

See: *wxGraphicsRenderer:createContext/2*

```
createPen(This, Pen) -> wxGraphicsPen:wxGraphicsPen()
```

Types:

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.

```
createBrush(This, Brush) -> wxGraphicsBrush:wxGraphicsBrush()
```

Types:

This = wxGraphicsContext()\
 Brush = wxBrush:wxBrush()\

Creates a native brush from a *wxBrush*.

```
createRadialGradientBrush(This, StartX, StartY, EndX, EndY,
                          Radius, Stops) ->
                             wxGraphicsBrush:wxGraphicsBrush()
```

Types:

This = wxGraphicsContext()\
 StartX = StartY = EndX = EndY = 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) ->
                             wxGraphicsBrush:wxGraphicsBrush()
```

Types:

This = wxGraphicsContext()\
 StartX = StartY = EndX = EndY = Radius = number()\
 OColor = 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

```
createLinearGradientBrush(This, X1, Y1, X2, Y2, Stops) ->
                             wxGraphicsBrush:wxGraphicsBrush()
```

Types:

This = wxGraphicsContext()\
 X1 = Y1 = X2 = 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) ->
                             wxGraphicsBrush:wxGraphicsBrush()
```

Types:

This = wxGraphicsContext()\
 X1 = Y1 = X2 = Y2 = number()\
 C1 = 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

```
createFont(This, Font) -> wxGraphicsFont:wxGraphicsFont()
```

Types:

This = wxGraphicsContext()\
 Font = wxFont:wxFont()\

```
createFont(This, SizeInPixels, Facename) ->
              wxGraphicsFont:wxGraphicsFont()
```

```
createFont(This, Font, Facename :: [Option]) ->
              wxGraphicsFont:wxGraphicsFont()
```

Types:

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(This, SizeInPixels, Facename, Options :: [Option]) ->
              wxGraphicsFont:wxGraphicsFont()
```

Types:

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

```
createMatrix(This) -> wxGraphicsMatrix:wxGraphicsMatrix()
```

Types:

This = wxGraphicsContext()\

```
createMatrix(This, Options :: [Option]) ->
                wxGraphicsMatrix:wxGraphicsMatrix()
```

Types:

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) -> wxGraphicsPath:wxGraphicsPath()
```

Types:

This = wxGraphicsContext()\

Creates a native graphics path which is initially empty.

```
clip(This, Region) -> ok
```

Types:

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:

```
clip(This, X, Y, W, H) -> ok
```

Types:

This = wxGraphicsContext()\
 X = Y = W = H = number()\

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

```
resetClip(This) -> ok
```

Types:

This = wxGraphicsContext()\

Resets the clipping to original shape.

```
drawBitmap(This, Bmp, X, Y, W, H) -> ok
```

Types:

This = wxGraphicsContext()\
 Bmp = wxBitmap:wxBitmap()\
 X = Y = W = 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) -> ok
```

Types:

This = wxGraphicsContext()\
 X = Y = W = H = number()\

Draws an ellipse.

```
drawIcon(This, Icon, X, Y, W, H) -> ok
```

Types:

This = wxGraphicsContext()\
 Icon = wxIcon:wxIcon()\
 X = Y = W = H = number()\

Draws the icon.

```
drawLines(This, Points) -> ok
```

Types:

This = wxGraphicsContext()\
 Points = \[{X :: float(), Y :: float()}\]\

```
drawLines(This, Points, Options :: [Option]) -> ok
```

Types:

This = wxGraphicsContext()\
 Points = \[{X :: float(), Y :: float()}\]\
 Option = {fillStyle, wx:wx\_enum()}\

Draws a polygon.

```
drawPath(This, Path) -> ok
```

Types:

This = wxGraphicsContext()\
 Path = wxGraphicsPath:wxGraphicsPath()\

```
drawPath(This, Path, Options :: [Option]) -> ok
```

Types:

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) -> ok
```

Types:

This = wxGraphicsContext()\
 X = Y = W = H = number()\

Draws a rectangle.

```
drawRoundedRectangle(This, X, Y, W, H, Radius) -> ok
```

Types:

This = wxGraphicsContext()\
 X = Y = W = H = Radius = number()\

Draws a rounded rectangle.

```
drawText(This, Str, X, Y) -> ok
```

Types:

This = wxGraphicsContext()\
 Str = unicode:chardata()\
 X = Y = number()\

Draws text at the defined position.

```
drawText(This, Str, X, Y, Angle) -> ok
```

```
drawText(This, Str, X, Y, BackgroundBrush) -> ok
```

Types:

This = wxGraphicsContext()\
 Str = unicode:chardata()\
 X = Y = number()\
 BackgroundBrush = wxGraphicsBrush:wxGraphicsBrush()\

Draws text at the defined position.

```
drawText(This, Str, X, Y, Angle, BackgroundBrush) -> ok
```

Types:

This = wxGraphicsContext()\
 Str = unicode:chardata()\
 X = Y = Angle = number()\
 BackgroundBrush = wxGraphicsBrush:wxGraphicsBrush()\

Draws text at the defined position.

```
fillPath(This, Path) -> ok
```

Types:

This = wxGraphicsContext()\
 Path = wxGraphicsPath:wxGraphicsPath()\

```
fillPath(This, Path, Options :: [Option]) -> ok
```

Types:

This = wxGraphicsContext()\
 Path = wxGraphicsPath:wxGraphicsPath()\
 Option = {fillStyle, wx:wx\_enum()}\

Fills the path with the current brush.

```
strokePath(This, Path) -> ok
```

Types:

This = wxGraphicsContext()\
 Path = wxGraphicsPath:wxGraphicsPath()\

Strokes along a path with the current pen.

```
getPartialTextExtents(This, Text) -> [number()]
```

Types:

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) -> Result
```

Types:

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.

```
rotate(This, Angle) -> ok
```

Types:

This = wxGraphicsContext()\
 Angle = number()\

Rotates the current transformation matrix (in radians).

```
scale(This, XScale, YScale) -> ok
```

Types:

This = wxGraphicsContext()\
 XScale = YScale = number()\

Scales the current transformation matrix.

```
translate(This, Dx, Dy) -> ok
```

Types:

This = wxGraphicsContext()\
 Dx = Dy = number()\

Translates the current transformation matrix.

```
getTransform(This) -> wxGraphicsMatrix:wxGraphicsMatrix()
```

Types:

This = wxGraphicsContext()\

Gets the current transformation matrix of this context.

```
setTransform(This, Matrix) -> ok
```

Types:

This = wxGraphicsContext()\
 Matrix = wxGraphicsMatrix:wxGraphicsMatrix()\

Sets the current transformation matrix of this context.

```
concatTransform(This, Matrix) -> ok
```

Types:

This = wxGraphicsContext()\
 Matrix = wxGraphicsMatrix:wxGraphicsMatrix()\

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

```
setBrush(This, Brush) -> ok
```

Types:

This = wxGraphicsContext()\
 Brush = wxGraphicsBrush:wxGraphicsBrush() \| wxBrush:wxBrush()\

Sets the brush for filling paths.

```
setFont(This, Font) -> ok
```

Types:

This = wxGraphicsContext()\
 Font = wxGraphicsFont:wxGraphicsFont()\

Sets the font for drawing text.

```
setFont(This, Font, Colour) -> ok
```

Types:

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) -> ok
```

Types:

This = wxGraphicsContext()\
 Pen = wxPen:wxPen() \| wxGraphicsPen:wxGraphicsPen()\

Sets the pen used for stroking.

```
strokeLine(This, X1, Y1, X2, Y2) -> ok
```

Types:

This = wxGraphicsContext()\
 X1 = Y1 = X2 = Y2 = number()\

Strokes a single line.

```
strokeLines(This, Points) -> ok
```

Types:

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.
