package cairo2

Error status: raised by functions of this module to indicate a cause of failure.

Provides a human-readable description of a status.

Exception raised by functions of backend modules when they are not available in the installed Cairo library.

The cairo drawing context. This is the main object used when drawing with cairo. To draw with cairo, you create a Surface.t, create a context from it and create shapes with functions such as Cairo.move_to and Cairo.line_to, and then actually draw them with Cairo.stroke or Cairo.fill.

Holds an affine transformation, such as a scale, rotation, shear, or a combination of those. The transformation of a point (x, y) is given by:

x_new = xx *. x +. xy *. y +. x0;
y_new = yx *. x +. yy *. y +. y0;

This is used throughout cairo to convert between different coordinate spaces.

The Cairo.text_extents structure stores the extents of a single glyph or a string of glyphs in user-space coordinates. Because text extents are in user-space coordinates, they are mostly, but not entirely, independent of the current transformation matrix. If you call Cairo.scalecr 2.0 2.0, text will be drawn twice as big, but the reported text extents will not be doubled. They will change slightly due to hinting (so you can't assume that metrics are independent of the transformation matrix), but otherwise will remain unchanged.

This is Cairo low-level text API. The low-level API relies on the user to convert text to a set of glyph indexes and positions. This is a very hard problem and is best handled by external libraries, like the pangocairo that is part of the Pango text layout and rendering library. Pango is available from http://www.pango.org/

Specifies the type of antialiasing to do when rendering text or shapes.

The subpixel order specifies the order of color elements within each pixel on the display device when rendering with an antialiasing mode of ANTIALIAS_SUBPIXEL (see Cairo.antialias).

Specifies the type of hinting to do on font outlines. Hinting is the process of fitting outlines to the pixel grid in order to improve the appearance of the result. Since hinting outlines involves distorting them, it also reduces the faithfulness to the original outline shapes. Not all of the outline hinting styles are supported by all font backends.

Specifies whether to hint font metrics; hinting font metrics means quantizing them so that they are integer values in device space. Doing this improves the consistency of letter and line spacing, however it also means that text will be laid out differently at different zoom factors.

The font options specify how fonts should be rendered. Most of the time the font options implied by a surface are just right and do not need any changes, but for pixel-based targets tweaking font options may result in superior output on a particular display.

Specifies variants of a font face based on their slant.

Specifies variants of a font face based on their weight.

Cairo.font_type is used to describe the type of a given font face or scaled font. The font types are also known as "font backends" within cairo.

The type of a font face is determined by the function used to create it, which will generally be of the form Cairo.*.font_face_create. The font face type can be queried with Cairo.Font_face.get_type

The various Cairo.Font_face functions can be used with a font face of any type.

The type of a scaled font is determined by the type of the font face passed to Cairo.Scaled_font.create. The scaled font type can be queried with Cairo.Scaled_font.get_type.

The various Cairo.Scaled_font functions can be used with scaled fonts of any type, but some font backends also provide type-specific functions (such as Cairo.Ft.scaled_font_lock_face) that must only be called with a scaled font of the appropriate type.

FIXME: The behavior of calling a type-specific function with a scaled font of the wrong type is undefined.

Cairo.Font_face.t represents a particular font at a particular weight, slant, and other characteristic but no size, transformation, or size.

The Cairo.font_extents structure stores metric information for a font. Values are given in the current user-space coordinate system.

Because font metrics are in user-space coordinates, they are mostly, but not entirely, independent of the current transformation matrix. If you call Cairo.scalecr 2.0 2.0, text will be drawn twice as big, but the reported text extents will not be doubled. They will change slightly due to hinting (so you can't assume that metrics are independent of the transformation matrix), but otherwise will remain unchanged.

Cairo.Scaled_font.t represents a realization of a font face at a particular size and transformation and a certain set of font options.

select_font_face cr family ?slant ?weight selects a family and style of font from a simplified description as a family name, slant and weight. Cairo provides no operation to list available family names on the system (this is a "toy", remember), but the standard CSS2 generic family names, ("serif", "sans-serif", "cursive", "fantasy", "monospace"), are likely to work as expected.

• parameter slant

  default Upright.

• parameter weight

  default Normal.

  For "real" font selection, see the font-backend-specific font_face_create functions for the font backend you are using. (For example, if you are using the freetype-based cairo-ft font backend, see Cairo.Ft.font_face_create_for_ft_face or Cairo.Ft.font_face_create_for_pattern.) The resulting font face could then be used with Cairo.Scaled_font.create and Cairo.Scaled_font.set.

  Similarly, when using the "real" font support, you can call directly into the underlying font system (such as fontconfig or freetype), for operations such as listing available fonts, etc.

  It is expected that most applications will need to use a more comprehensive font handling and text layout library (for example, pango) in conjunction with cairo.

  If text is drawn without a call to Cairo.select_font_face, (nor Cairo.Font_face.set nor Cairo.Scaled_font.set), the default family is platform-specific, but is essentially "sans-serif". Default slant is Upright, and default weight is Normal.

set_font_size cr size sets the current font matrix to a scale by a factor of size, replacing any font matrix previously set with set_font_size or Cairo.set_font_matrix. This results in a font size of size user space units. (More precisely, this matrix will result in the font's em-square being a size by size square in user space.)

If text is drawn without a call to set_font_size (nor Cairo.set_font_matrix, nor Cairo.Scaled_font.set), the default font size is 10.0.

set_font_matrix cr matrix sets the current font matrix to matrix. The font matrix gives a transformation from the design space of the font (in this space, the em-square is 1 unit by 1 unit) to user space. Normally, a simple scale is used (see Cairo.set_font_size), but a more complex font matrix can be used to shear the font or stretch it unequally along the two axes.

Returns the current font matrix. See Cairo.set_font_matrix.

A drawing operator that generates the shape from a string of UTF-8 characters, rendered according to the current font_face, font_size (font_matrix), and font_options.

This function first computes a set of glyphs for the string of text. The first glyph is placed so that its origin is at the current point. The origin of each subsequent glyph is offset from that of the previous glyph by the advance values of the previous glyph.

After this call the current point is moved to the origin of where the next glyph would be placed in this same progression. That is, the current point will be at the origin of the final glyph offset by its advance values. This allows for easy display of a single logical string with multiple calls to show_text.

Gets the font extents for the currently selected font.

text_extents cr utf8 gets the extents for a string of text. The extents describe a user-space rectangle that encloses the "inked" portion of the text (as it would be drawn by Cairo.show_text). Additionally, the x_advance and y_advance values indicate the amount by which the current point would be advanced by Cairo.show_text.

Note that whitespace characters do not directly contribute to the size of the rectangle (extents.width and extents.height). They do contribute indirectly by changing the position of non-whitespace characters. In particular, trailing whitespace characters are likely to not affect the size of the rectangle, though they will affect the x_advance and y_advance values.

A data structure for holding a rectangle.

This is used to describe the content that a surface will contain, whether color information, alpha information (translucence vs. opacity), or both.

Abstract representation of all different drawing targets that cairo can render to; the actual drawings are performed using a cairo context.

Image surfaces provide the ability to render to memory buffers either allocated by cairo or by the calling code. The supported image formats are those defined in Cairo.Image.format.

The PDF surface is used to render cairo graphics to Adobe PDF files and is a multi-page vector surface backend.

The PNG functions allow reading PNG images into image surfaces, and writing any surface to a PNG file.

The PostScript surface is used to render cairo graphics to Adobe PostScript files and is a multi-page vector surface backend.

The SVG surface is used to render cairo graphics to SVG files and is a multi-page vector surface backend.

The recording surface is a surface that records all drawing operations at the highest level of the surface backend interface. The surface can then be "replayed" against any target surface by using it as a source surface.

Paint (and also mask and brush) with which cairo draws and associated function.

create target creates a new context with all graphics state parameters set to default values and with target as a target surface. The target surface should be constructed with a backend-specific function such as Cairo.Image.create (or any other Backend.create variant). For many backends, you should not forget to call Cairo.Surface.finish for the data to be completely outputted.

• raises Out_of_memory

  if the context could not be allocated.

save cr makes a copy of the current state of cr and saves it on an internal stack of saved states for cr. When restore is called, cr will be restored to the saved state. Multiple calls to save and restore can be nested; each call to restore restores the state from the matching paired save.

save cr makes a copy of the current state of cr and saves it on an internal stack of saved states for cr. When restore is called, cr will be restored to the saved state. Multiple calls to save and restore can be nested; each call to restore restores the state from the matching paired save.

restore cr restores cr to the state saved by a preceding call to save and removes that state from the stack of saved states.

Gets the target surface for the cairo context as passed to create.

Temporary redirection of drawing commands to intermediate surfaces.

set_source_rgb cr r g b sets the source pattern within cr to an opaque color. This opaque color will then be used for any subsequent drawing operation until a new source pattern is set.

The color components are floating point numbers in the range 0 to 1. If the values passed in are outside that range, they will be clamped.

The default source pattern is opaque black (that is, it is equivalent to set_source_rgb cr 0. 0. 0.).

set_source_rgba cr r g b a sets the source pattern within cr to a translucent color. This color will then be used for any subsequent drawing operation until a new source pattern is set.

The color and alpha components are floating point numbers in the range 0 to 1. If the values passed in are outside that range, they will be clamped.

The default source pattern is opaque black (that is, it is equivalent to set_source_rgba cr 0. 0. 0. 1.0).

set_source cr source sets the source pattern within cr to source. This pattern will then be used for any subsequent drawing operation until a new source pattern is set.

Note: The pattern's transformation matrix will be locked to the user space in effect at the time of set_source. This means that further modifications of the current transformation matrix will not affect the source pattern. See Pattern.set_matrix.

The default source pattern is a solid pattern that is opaque black (that is, it is equivalent to set_source_rgb cr 0. 0. 0.).

set_source_surface cr surface x y is a convenience for creating a pattern from surface and setting it as the source in cr with set_source.

The x and y parameters give the user-space coordinate at which the surface origin should appear. (The surface origin is its upper-left corner before any transformation has been applied.) The x and y patterns are negated and then set as translation values in the pattern matrix.

Other than the initial translation pattern matrix, as described above, all other pattern attributes (such as its extend mode) are set to the default values as in Pattern.create_for_surface. The resulting pattern can be queried with Cairo.get_source so that these attributes can be modified if desired (e.g. to create a repeating pattern with Cairo.Pattern.set_extend).

get_source cr gets the current source pattern for cr.

Set the antialiasing mode of the rasterizer used for drawing shapes. This value is a hint, and a particular backend may or may not support a particular value. At the current time, no backend supports ANTIALIAS_SUBPIXEL when drawing shapes.

Note that this option does not affect text rendering, instead see Cairo.Font_options.set_antialias.

Gets the current shape antialiasing mode, as set by Cairo.set_antialias.

set_dash cr dashes sets the dash pattern to be used by Cairo.stroke. A dash pattern is specified by dashes, an array of positive values. Each value provides the length of alternate "on" and "off" portions of the stroke. The offset ofs specifies an offset into the pattern at which the stroke begins (default: 0.).

set_dash [| |] disable dashing. set_dash [|l|] sets a symmetric pattern with alternating on and off portions of the size l.

Each "on" segment will have caps applied as if the segment were a separate sub-path. In particular, it is valid to use an "on" length of 0.0 with Cairo.line_cap being ROUND or SQUARE in order to distributed dots or squares along a path.

Note: The length values are in user-space units as evaluated at the time of stroking. This is not necessarily the same as the user space at the time of set_dash.

Gets the current dash array (( [| |], 0.) if dashing is not currently in effect).

Used to select how paths are filled. For both fill rules, whether or not a point is included in the fill is determined by taking a ray from that point to infinity and looking at intersections with the path. The ray can be in any direction, as long as it doesn't pass through the end point of a segment or have a tricky intersection such as intersecting tangent to the path. (Note that filling is not actually implemented in this way. This is just a description of the rule that is applied.)

The default fill rule is WINDING.

set_fill_rule cr fill_rule sets the current fill rule within the cairo context cr. The fill rule is used to determine which regions are inside or outside a complex (potentially self-intersecting) path. The current fill rule affects both Cairo.fill and Cairo.clip. See Cairo.fill_rule for details on the semantics of each available fill rule.

Gets the current fill rule, as set by set_fill_rule.

Specifies how to render the endpoints of the path when stroking. The default line cap style is BUTT.

set_line_cap cr line_cap sets the current line cap style within the cairo context cr. See Cairo.line_cap for details about how the available line cap styles are drawn.

As with the other stroke parameters, the current line cap style is examined by Cairo.stroke, Cairo.stroke_extents, and Cairo.stroke_to_path, but does not have any effect during path construction.

The default line cap style is BUTT.

Gets the current line cap style, as set by Cairo.set_line_cap.

Specifies how to render the junction of two lines when stroking. The default line join style is MITER.

Sets the current line join style within the cairo context. See Cairo.line_join for details about how the available line join styles are drawn.

As with the other stroke parameters, the current line join style is examined by Cairo.stroke, Cairo.stroke_extents, and Cairo.stroke_to_path, but does not have any effect during path construction.

The default line join style is MITER.

Sets the current line join style within the cairo context. See Cairo.line_join for details about how the available line join styles are drawn.

As with the other stroke parameters, the current line join style is examined by Cairo.stroke, Cairo.stroke_extents, and Cairo.stroke_to_path, but does not have any effect during path construction.

The default line join style is MITER.

Gets the current line join style, as set by Cairo.set_line_join.

Sets the current line width within the cairo context. The line width value specifies the diameter of a pen that is circular in user space (though device-space pen may be an ellipse in general due to scaling/shear/rotation of the CTM).

Note: When the description above refers to user space and CTM it refers to the user space and CTM in effect at the time of the stroking operation, not the user space and CTM in effect at the time of the call to set_line_width. The simplest usage makes both of these spaces identical. That is, if there is no change to the CTM between a call to set_line_with and the stroking operation, then one can just pass user-space values to set_line_width and ignore this note.

As with the other stroke parameters, the current line width is examined by Cairo.stroke, Cairo.stroke_extents, and Cairo.stroke_to_path, but does not have any effect during path construction.

The default line width value is 2.0.

This function returns the current line width value exactly as set by Cairo.set_line_width. Note that the value is unchanged even if the CTM has changed between the calls to set_line_width and get_line_width.

Sets the current miter limit within the cairo context.

If the current line join style is set to MITER (see Cairo.set_line_join), the miter limit is used to determine whether the lines should be joined with a bevel instead of a miter. Cairo divides the length of the miter by the line width. If the result is greater than the miter limit, the style is converted to a bevel.

As with the other stroke parameters, the current line miter limit is examined by Cairo.stroke, Cairo.stroke_extents, and Cairo.stroke_to_path, but does not have any effect during path construction.

The default miter limit value is 10.0, which will convert joins with interior angles less than 11 degrees to bevels instead of miters. For reference, a miter limit of 2.0 makes the miter cutoff at 60 degrees, and a miter limit of 1.414 makes the cutoff at 90 degrees.

A miter limit for a desired angle can be computed as: miter limit = 1/sin(angle/2).

Gets the current miter limit, as set by Cairo.set_miter_limit.

Compositing operator for all cairo drawing operations.

The default operator is Cairo.Operator.OVER.

The operators marked as unbounded modify their destination even outside of the mask layer (that is, their effect is not bound by the mask layer). However, their effect can still be limited by way of clipping.

To keep things simple, the operator descriptions here document the behavior for when both source and destination are either fully transparent or fully opaque. The actual implementation works for translucent layers too. For a more detailed explanation of the effects of each operator, including the mathematical definitions, see http://cairographics.org/operators/

Sets the compositing operator to be used for all drawing operations. See Cairo.operator for details on the semantics of each available compositing operator.

The default operator is OVER.

Gets the current compositing operator for a cairo context.

Sets the tolerance used when converting paths into trapezoids. Curved segments of the path will be subdivided until the maximum deviation between the original path and the polygonal approximation is less than tolerance. The default value is 0.1. A larger value will give better performance, a smaller value, better appearance. (Reducing the value from the default value of 0.1 is unlikely to improve appearance significantly.)

Sets the tolerance used when converting paths into trapezoids. Curved segments of the path will be subdivided until the maximum deviation between the original path and the polygonal approximation is less than tolerance. The default value is 0.1. A larger value will give better performance, a smaller value, better appearance. (Reducing the value from the default value of 0.1 is unlikely to improve appearance significantly.)

Gets the current tolerance value, as set by Cairo.set_tolerance.

Establishes a new clip region by intersecting the current clip region with the current path as it would be filled by Cairo.fill and according to the current fill rule (see Cairo.set_fill_rule).

After clip, the current path will be cleared from the cairo context.

Calling Cairo.clip can only make the clip region smaller, never larger. But the current clip is part of the graphics state, so a temporary restriction of the clip region can be achieved by calling Cairo.clip within a Cairo.save / Cairo.restore pair. The only other means of increasing the size of the clip region is Cairo.clip_reset.

Establishes a new clip region by intersecting the current clip region with the current path as it would be filled by Cairo.fill and according to the current fill rule (see Cairo.set_fill_rule).

Unlike Cairo.clip, preserves the path within the cairo context.

Calling Cairo.clip_preserve can only make the clip region smaller, never larger. But the current clip is part of the graphics state, so a temporary restriction of the clip region can be achieved by calling Cairo.clip_preserve within a Cairo.save / Cairo.restore pair. The only other means of increasing the size of the clip region is Cairo.clip_reset.

Computes a bounding box in user coordinates covering the area inside the current clip.

Reset the current clip region to its original, unrestricted state. That is, set the clip region to an infinitely large shape containing the target surface. Equivalently, if infinity is too hard to grasp, one can imagine the clip region being reset to the exact bounds of the target surface.

Note that code meant to be reusable should not call clip_reset as it will cause results unexpected by higher-level code which calls Cairo.clip. Consider using Cairo.save and Cairo.restore around Cairo.clip as a more robust means of temporarily restricting the clip region.

(This function binds Cairo cairo_reset_clip.)

Gets the current clip region as a list of rectangles in user coordinates.

Raises Error(CLIP_NOT_REPRESENTABLE) to indicate that the clip region cannot be represented as a list of user-space rectangles.

A drawing operator that fills the current path according to the current fill rule (each sub-path is implicitly closed before being filled). After fill, the current path will be cleared from the cairo context.

See also Cairo.set_fill_rule.

A drawing operator that fills the current path according to the current fill rule (each sub-path is implicitly closed before being filled). Unlike Cairo.fill, fill_preserve preserves the path within the cairo context.

See also Cairo.set_fill_rule.

Computes a bounding box in user coordinates covering the area that would be affected (the "inked" area) by a fill operation given the current path and fill parameters. If the current path is empty, returns an empty rectangle { x=0.; y=0.; w=0.; h=0. }. Surface dimensions and clipping are not taken into account.

Contrast with Cairo.Path.extents, which is similar, but returns non-zero extents for some paths with no inked area, (such as a simple line segment).

Note that fill_extents must necessarily do more work to compute the precise inked areas in light of the fill rule, so Cairo.Path.extents may be more desirable for sake of performance if the non-inked path extents are desired.

See Cairo.fill and Cairo.set_fill_rule.

Tests whether the given point is inside the area that would be affected by a fill operation given the current path and filling parameters. Surface dimensions and clipping are not taken into account.

See also Cairo.fill and Cairo.set_fill_rule.

mask cr pattern: a drawing operator that paints the current source using the alpha channel of pattern as a mask. (Opaque areas of pattern are painted with the source, transparent areas are not painted.)

mask cr pattern: a drawing operator that paints the current source using the alpha channel of pattern as a mask. (Opaque areas of pattern are painted with the source, transparent areas are not painted.)

mask_surface cr surface x y: a drawing operator that paints the current source using the alpha channel of surface as a mask. (Opaque areas of surface are painted with the source, transparent areas are not painted.)

• parameter x

  X coordinate at which to place the origin of surface.

• parameter y

  Y coordinate at which to place the origin of surface.

A drawing operator that paints the current source everywhere within the current clip region. If alpha is set, the drawing is faded out using the alpha value.

• parameter alpha

  alpha value, between 0 (transparent) and 1 (opaque).

A drawing operator that strokes the current path according to the current line width, line join, line cap, and dash settings. After stroke, the current path will be cleared from the cairo context. See Cairo.set_line_width, Cairo.set_line_join, Cairo.set_line_cap, and Cairo.set_dash.

Note: Degenerate segments and sub-paths are treated specially and provide a useful result. These can result in two different situations:

1. Zero-length "on" segments set in Cairo.set_dash. If the cap style is ROUND or SQUARE then these segments will be drawn as circular dots or squares respectively. In the case of SQUARE, the orientation of the squares is determined by the direction of the underlying path.

2. A sub-path created by Cairo.move_to followed by either a Cairo.Path.close or one or more calls to Cairo.line_to to the same coordinate as the Cairo.move_to. If the cap style is ROUND then these sub-paths will be drawn as circular dots. Note that in the case of SQUARE line cap, a degenerate sub-path will not be drawn at all (since the correct orientation is indeterminate).

In no case will a cap style of BUTT cause anything to be drawn in the case of either degenerate segments or sub-paths.

Like Cairo.stroke except that it preserves the path within the cairo context.

Computes a bounding box in user coordinates covering the area that would be affected (the "inked" area) by a Cairo.stroke operation operation given the current path and stroke parameters. If the current path is empty, returns an empty rectangle { x=0.; y=0.; w=0.; h=0. }. Surface dimensions and clipping are not taken into account.

Note that if the line width is set to exactly zero, then stroke_extents will return an empty rectangle. Contrast with Cairo.Path.extents which can be used to compute the non-empty bounds as the line width approaches zero.

Note that stroke_extents must necessarily do more work to compute the precise inked areas in light of the stroke parameters, so Cairo.Path.extents may be more desirable for sake of performance if non-inked path extents are desired.

See Cairo.stroke, Cairo.set_line_width, Cairo.set_line_join, Cairo.set_line_cap, and Cairo.set_dash.

Tests whether the given point is inside the area that would be affected by a Cairo.stroke operation given the current path and stroking parameters. Surface dimensions and clipping are not taken into account.

copy_page cr emits the current page for backends that support multiple pages, but doesn't clear it, so, the contents of the current page will be retained for the next page too. Use Cairo.show_page if you want to get an empty page after the emission.

This is a convenience function that simply calls Cairo.Surface.copy_page on cr's target.

copy_page cr emits the current page for backends that support multiple pages, but doesn't clear it, so, the contents of the current page will be retained for the next page too. Use Cairo.show_page if you want to get an empty page after the emission.

This is a convenience function that simply calls Cairo.Surface.copy_page on cr's target.

show_page cr emits and clears the current page for backends that support multiple pages. Use Cairo.copy_page if you don't want to clear the page.

This is a convenience function that simply calls Cairo.Surface.show_page on cr's target.

arc xc yc radius angle1 angle2 adds a circular arc of the given radius to the current path. The arc is centered at (xc, yc), begins at angle1 and proceeds in the direction of increasing angles to end at angle2. If angle2 is less than angle1 it will be progressively increased by 2*PI until it is greater than angle1.

If there is a current point, an initial line segment will be added to the path to connect the current point to the beginning of the arc. If this initial line is undesired, it can be avoided by calling Cairo.Path.sub before calling arc.

Angles are measured in radians. An angle of 0.0 is in the direction of the positive X axis (in user space). An angle of PI/2.0 radians (90 degrees) is in the direction of the positive Y axis (in user space). Angles increase in the direction from the positive X axis toward the positive Y axis. So with the default transformation matrix, angles increase in a clockwise direction.

(To convert from degrees to radians, use degrees * (PI / 180.).)

This function gives the arc in the direction of increasing angles; see Cairo.arc_negative to get the arc in the direction of decreasing angles.

The arc is circular in user space. To achieve an elliptical arc, you can scale the current transformation matrix by different amounts in the X and Y directions. For example, to draw an ellipse in the box given by x, y, width, height (we suppose pi holds the value of PI):

open Cairo

save cr;
translate cr (x +. width /. 2.) (y +. height /. 2.);
scale cr (width /. 2.) (height /. 2.);
arc cr 0. 0. 1. 0. (2 * pi);
restore cr;

arc_negative xc yc radius angle1 angle2 adds a circular arc of the given radius to the current path. The arc is centered at (xc, yc), begins at angle1 and proceeds in the direction of decreasing angles to end at angle2. If angle2 is greater than angle1 it will be progressively decreased by 2*PI until it is less than angle1.

See Cairo.arc for more details. This function differs only in the direction of the arc between the two angles.

Adds a cubic Bézier spline to the path from the current point to position (x3, y3) in user-space coordinates, using (x1, y1) and (x2, y2) as the control points. After this call the current point will be (x3, y3).

If there is no current point before the call to curve_to this function will behave as if preceded by a call to Cairo.move_to cr x1 y1.

Adds a line to the path from the current point to position (x, y) in user-space coordinates. After this call the current point will be (x, y).

If there is no current point before the call to Cairo.line_to, this function will behave as Cairo.move_to cr x y.

Begin a new sub-path. After this call the current point will be (x, y).

Adds a closed sub-path rectangle of the given size to the current path at position (x, y) in user-space coordinates.

This function is logically equivalent to:

move_to cr x y;
rel_line_to cr width 0;
rel_line_to cr 0 height;
rel_line_to cr (-. width) 0;
Path.close cr;

Relative-coordinate version of Cairo.curve_to. All offsets are relative to the current point. Adds a cubic Bézier spline to the path from the current point to a point offset from the current point by (dx3, dy3), using points offset by (dx1, dy1) and (dx2, dy2) as the control points. After this call the current point will be offset by (dx3, dy3).

Given a current point of (x, y), rel_curve_to cr dx1 dy1 dx2 dy2 dx3 dy3 is logically equivalent to curve_to cr (x+.dx1) (y+.dy1) (x+.dx2) (y+.dy2) (x+.dx3) (y+.dy3).

It is an error to call this function with no current point. Doing so will cause Error NO_CURRENT_POINT to be raised.

Relative-coordinate version of Cairo.line_to. Adds a line to the path from the current point to a point that is offset from the current point by (dx, dy) in user space. After this call the current point will be offset by (dx, dy).

Given a current point of (x, y), rel_line_to cr dx dy is logically equivalent to line_to cr (x +. dx) (y +. dy).

It is an error to call this function with no current point. Doing so will cause Error NO_CURRENT_POINT to be raised.

Begin a new sub-path. After this call the current point will offset by (x, y).

Given a current point of (x, y), rel_move_to cr dx dy is logically equivalent to move_to cr (x +. dx) (y +. dy).

It is an error to call this function with no current point. Doing so will cause Error NO_CURRENT_POINT to be raised.

translate cr tx ty modifies the current transformation matrix (CTM) by translating the user-space origin by (tx, ty). This offset is interpreted as a user-space coordinate according to the CTM in place before the new call to translate. In other words, the translation of the user-space origin takes place after any existing transformation.

scale sx sy modifies the current transformation matrix (CTM) by scaling the X and Y user-space axes by sx and sy respectively. The scaling of the axes takes place after any existing transformation of user space.

Modifies the current transformation matrix (CTM) by rotating the user-space axes by angle radians. The rotation of the axes takes places after any existing transformation of user space. The rotation direction for positive angles is from the positive X axis toward the positive Y axis.

transform cr matrix modifies the current transformation matrix (CTM) by applying matrix as an additional transformation. The new transformation of user space takes place after any existing transformation.

set_matrix cr matrix Modifies the current transformation matrix (CTM) by setting it equal to matrix.

Return the current transformation matrix (CTM).

Resets the current transformation matrix (CTM) by setting it equal to the identity matrix. That is, the user-space and device-space axes will be aligned and one user-space unit will transform to one device-space unit.

user_to_device cr x y transform a coordinate from user space to device space by multiplying the given point by the current transformation matrix (CTM).

user_to_device_distance cr dx dy transform a distance vector from user space to device space. This function is similar to Cairo.user_to_device except that the translation components of the CTM will be ignored when transforming (dx,dy).

Transform a coordinate from device space to user space by multiplying the given point by the inverse of the current transformation matrix (CTM).

device_to_user_distance cr dx dy transform a distance vector from device space to user space. This function is similar to Cairo.device_to_user except that the translation components of the inverse CTM will be ignored when transforming (dx,dy).