# Cairo::Context Class Reference

Context is the main class used to draw in cairomm. More...

List of all members.

## Public Types

typedef cairo_t | cobject
| The base cairo C type that is wrapped by Cairo::Context.

## Public Member Functions

| Context (cairo_t*cobject, bool has_reference=false)
| Create a C++ wrapper for the C instance.
virtual | ~Context ()
void | save ()
| Makes a copy of the current state of the Context and saves it on an internal stack of saved states.
void | restore ()
| Restores cr to the state saved by a preceding call to save() and removes that state from the stack of saved states.
void | set_operator (Operator op)
| Sets the compositing operator to be used for all drawing operations.
void | set_source (const RefPtr< const Pattern >& source)
| Sets the source pattern within the Context to source.
void | set_source_rgb (double red, double green, double blue)
| Sets the source pattern within the Context to an opaque color.
void | set_source_rgba (double red, double green, double blue, double alpha)
| Sets the source pattern within the Context to a translucent color.
void | set_source (const RefPtr< Surface >& surface, double x, double y)
| This is a convenience function for creating a pattern from a Surface and setting it as the source.
void | set_tolerance (double tolerance)
| Sets the tolerance used when converting paths into trapezoids.
void | set_antialias (Antialias antialias)
| Set the antialiasing mode of the rasterizer used for drawing shapes.
void | set_fill_rule (FillRule fill_rule)
| Set the current fill rule within the cairo Context.
void | set_line_width (double width)
| Sets the current line width within the cairo Context.
void | set_line_cap (LineCap line_cap)
| Sets the current line cap style within the cairo Context.
void | set_line_join (LineJoin line_join)
| Sets the current line join style within the cairo Context.
void | set_dash (std::valarray< double >& dashes, double offset)
| Alternate version of set_dash().
void | set_dash (std::vector< double >& dashes, double offset)
| Sets the dash pattern to be used by stroke().
void | set_dash (const std::valarray< double >& dashes, double offset)
| Alternate version of set_dash().
void | set_dash (const std::vector< double >& dashes, double offset)
| Sets the dash pattern to be used by stroke().
void | unset_dash ()
| This function disables a dash pattern that was set with set_dash()
void | set_miter_limit (double limit)
void | translate (double tx, double ty)
| Modifies the current transformation matrix (CTM) by translating the user-space origin by (tx, ty).
void | scale (double sx, double sy)
| Modifies the current transformation matrix (CTM) by scaling the X and Y user-space axes by sx and sy respectively.
void | rotate (double angle_radians)
| Modifies the current transformation matrix (CTM) by rotating the user-space axes by angle radians.
void | rotate_degrees (double angle_degres)
| A convenience wrapper around rotate() that accepts angles in degrees.
void | transform (const Matrix& matrix)
| Modifies the current transformation matrix (CTM) by applying matrix as an additional transformation.
void | transform (const cairo_matrix_t& matrix)
void | set_matrix (const Matrix& matrix)
| Modifies the current transformation matrix (CTM) by setting it equal to matrix.
void | set_matrix (const cairo_matrix_t& matrix)
void | set_identity_matrix ()
| Resets the current transformation matrix (CTM) by setting it equal to the identity matrix.
void | user_to_device (double& x, double& y)
| Transform a coordinate from user space to device space by multiplying the given point by the current transformation matrix (CTM).
void | user_to_device_distance (double& dx, double& dy)
| Transform a distance vector from user space to device space.
void | device_to_user (double& x, double& y)
| Transform a coordinate from device space to user space by multiplying the given point by the inverse of the current transformation matrix (CTM).
void | device_to_user_distance (double& dx, double& dy)
| Transform a distance vector from device space to user space.
void | user_to_device (double& x, double& y) const
| Transform a coordinate from user space to device space by multiplying the given point by the current transformation matrix (CTM).
void | user_to_device_distance (double& dx, double& dy) const
| Transform a distance vector from user space to device space.
void | device_to_user (double& x, double& y) const
| Transform a coordinate from device space to user space by multiplying the given point by the inverse of the current transformation matrix (CTM).
void | device_to_user_distance (double& dx, double& dy) const
| Transform a distance vector from device space to user space.
void | begin_new_path ()
| Clears the current path.
void | begin_new_sub_path ()
| Begin a new subpath.
void | move_to (double x, double y)
| If the current subpath is not empty, begin a new subpath.
void | line_to (double x, double y)
| Adds a line to the path from the current point to position (x, y) in user-space coordinates.
void | curve_to (double x1, double y1, double x2, double y2, double x3, double y3)
| Adds a cubic Bezier 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.
void | arc (double xc, double yc, double radius, double angle1, double angle2)
| Adds a circular arc of the given radius to the current path.
void | arc_negative (double xc, double yc, double radius, double angle1, double angle2)
| Adds a circular arc of the given radius to the current path.
void | rel_move_to (double dx, double dy)
| If the current subpath is not empty, begin a new subpath.
void | rel_line_to (double dx, double dy)
| Relative-coordinate version of line_to().
void | rel_curve_to (double dx1, double dy1, double dx2, double dy2, double dx3, double dy3)
| Relative-coordinate version of curve_to().
void | rectangle (double x, double y, double width, double height)
| Adds a closed-subpath rectangle of the given size to the current path at position (x, y) in user-space coordinates.
void | close_path ()
| Adds a line segment to the path from the current point to the beginning of the current subpath, (the most recent point passed to move_to()), and closes this subpath.
void | paint ()
| A drawing operator that paints the current source everywhere within the current clip region.
void | paint_with_alpha (double alpha)
| A drawing operator that paints the current source everywhere within the current clip region using a mask of constant alpha value alpha.
void | mask (const RefPtr< const Pattern >& pattern)
| A drawing operator that paints the current source using the alpha channel of pattern as a mask.
void | mask (const RefPtr< const Surface >& surface, double surface_x, double surface_y)
| A drawing operator that paints the current source using the alpha channel of surface as a mask.
void | stroke ()
| A drawing operator that strokes the current Path according to the current line width, line join, line cap, and dash settings.
void | stroke_preserve ()
| A drawing operator that strokes the current Path according to the current line width, line join, line cap, and dash settings.
void | fill ()
| A drawing operator that fills the current path according to the current fill rule, (each sub-path is implicitly closed before being filled).
void | fill_preserve ()
| A drawing operator that fills the current path according to the current fill rule, (each sub-path is implicitly closed before being filled).
void | copy_page ()
void | show_page ()
bool | in_stroke (double x, double y) const
bool | in_fill (double x, double y) const
bool | in_clip (double x, double y) const
void | get_stroke_extents (double& x1, double& y1, double& x2, double& y2) const
void | get_fill_extents (double& x1, double& y1, double& x2, double& y2) const
void | reset_clip ()
| Reset the current clip region to its original, unrestricted state.
void | clip ()
| Establishes a new clip region by intersecting the current clip region with the current Path as it would be filled by fill() and according to the current fill rule.
void | clip_preserve ()
| Establishes a new clip region by intersecting the current clip region with the current path as it would be filled by fill() and according to the current fill rule.
void | get_clip_extents (double& x1, double& y1, double& x2, double& y2) const
| Computes a bounding box in user coordinates covering the area inside the current clip.
void | copy_clip_rectangle_list (std::vector< Rectangle >& rectangles) const
| Returns the current clip region as a list of rectangles in user coordinates.
void | select_font_face (const std::string& family, FontSlant slant, FontWeight weight)
void | set_font_size (double size)
void | set_font_matrix (const Matrix& matrix)
void | get_font_matrix (Matrix& matrix) const
void | set_font_options (const FontOptions& options)
void | set_font_matrix (const cairo_matrix_t& matrix)
void | get_font_matrix (cairo_matrix_t& matrix) const
void | get_font_options (FontOptions& options) const
void | set_scaled_font (const RefPtr< const ScaledFont >& scaled_font)
RefPtr< ScaledFont > | get_scaled_font ()
void | show_text (const std::string& utf8)
void | show_glyphs (const std::vector< Glyph >& glyphs)
void | show_text_glyphs (const std::string& utf8, const std::vector< Glyph >& glyphs, const std::vector< TextCluster >& clusters, TextClusterFlags cluster_flags)
RefPtr< FontFace > | get_font_face ()
RefPtr< const FontFace > | get_font_face () const
void | get_font_extents (FontExtents& extents) const
void | set_font_face (const RefPtr< const FontFace >& font_face)
void | get_text_extents (const std::string& utf8, TextExtents& extents) const
void | get_glyph_extents (const std::vector< Glyph >& glyphs, TextExtents& extents) const
void | text_path (const std::string& utf8)
void | glyph_path (const std::vector< Glyph >& glyphs)
Operator | get_operator () const
| Gets the current compositing operator for a cairo Context.
RefPtr< Pattern > | get_source ()
| Gets the current source pattern for the Context.
RefPtr< const Pattern > | get_source () const
double | get_tolerance () const
| Gets the current tolerance value, as set by set_tolerance()
Antialias | get_antialias () const
| Gets the current shape antialiasing mode, as set by set_antialias()
void | get_current_point (double& x, double& y) const
| Gets the current point of the current path, which is conceptually the final point reached by the path so far.
bool | has_current_point () const
| Checks if there is a current point defined.
FillRule | get_fill_rule () const
| Gets the current fill rule, as set by set_fill_rule().
double | get_line_width () const
| Gets the current line width, as set by set_line_width()
LineCap | get_line_cap () const
| Gets the current line cap style, as set by set_line_cap()
LineJoin | get_line_join () const
| Gets the current line join style, as set by set_line_join()
double | get_miter_limit () const
| Gets the current miter limit, as set by set_miter_limit()
void | get_dash (std::vector< double >& dashes, double& offset) const
| Gets the current dash array and offset.
void | get_matrix (Matrix& matrix)
| Stores the current transformation matrix (CTM) into matrix.
void | get_matrix (cairo_matrix_t& matrix)
Matrix | get_matrix () const
RefPtr< Surface > | get_target ()
| Gets the target surface associated with this Context.
RefPtr< const Surface > | get_target () const
| Gets the target surface associated with this Context.
Path* | copy_path () const
| Creates a copy of the current path and returns it to the user.
void | get_path_extents (double& x1, double& y1, double& x2, double& y2) const
| Computes a bounding box in user-space coordinates covering the points on the current path.
Path* | copy_path_flat () const
| Gets a flattened copy of the current path and returns it to the user.
void | append_path (const Path& path)
| Append the path onto the current path.
void | push_group ()
| Temporarily redirects drawing to an intermediate surface known as a group.
void | push_group_with_content (Content content)
| Temporarily redirects drawing to an intermediate surface known as a group.
RefPtr< Pattern > | pop_group ()
| Terminates the redirection begun by a call to push_group() or push_group_with_content() and returns a new pattern containing the results of all drawing operations performed to the group.
void | pop_group_to_source ()
| Terminates the redirection begun by a call to push_group() or push_group_with_content() and installs the resulting pattern as the source pattern in the given cairo Context.
RefPtr< Surface > | get_group_target ()
| Gets the target surface for the current group as started by the most recent call to push_group() or push_group_with_content().
RefPtr< const Surface > | get_group_target () const
| Same as the non-const version but returns a reference to a const Surface.
cobject* | cobj ()
| Gets a pointer to the base C type that is wrapped by the Context.
const cobject* | cobj () const
| Gets a pointer to the base C type that is wrapped by the Context.

## Static Public Member Functions

static RefPtr< Context > | create (const RefPtr< Surface >& target)

## Protected Member Functions

| Context (const RefPtr< Surface >& target)

## Protected Attributes

cobject* | m_cobject

## Detailed Description

Context is the main class used to draw in cairomm.

In the simplest case, create a Context with its target Surface, set its drawing options (line width, color, etc), create shapes with methods like move_to() and line_to(), and then draw the shapes to the Surface using methods such as stroke() or fill().

Context is a reference-counted object that should be used via Cairo::RefPtr.

## Member Typedef Documentation

typedef cairo_t Cairo::Context::cobject

The base cairo C type that is wrapped by Cairo::Context.

## Constructor & Destructor Documentation

Cairo::Context::Context | ( | const RefPtr< Surface >& | target | ) | `[explicit, protected]`

Cairo::Context::Context | ( | cairo_t * | cobject,
|  | bool | has_reference = `false`
| ) |  | `[explicit]`

Create a C++ wrapper for the C instance.

This C++ instance should then be given to a RefPtr.

Parameters:

  cobject | The C instance.
  has_reference | Whether we already have a reference. Otherwise, the constructor will take an extra reference.

virtual Cairo::Context::~Context | ( |  | ) | `[virtual]`

## Member Function Documentation

void Cairo::Context::append_path | ( | const Path& | path | ) |

Append the path onto the current path.

The path may be either the return value from one of copy_path() or copy_path_flat() or it may be constructed manually.

Parameters:

  path | path to be appended

void Cairo::Context::arc | ( | double | xc,
|  | double | yc,
|  | double | radius,
|  | double | angle1,
|  | double | 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*M_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 begin_new_sub_path() before calling arc().

Angles are measured in radians. An angle of 0 is in the direction of the positive X axis (in user-space). An angle of M_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 * (M_PI / 180.0). )

This function gives the arc in the direction of increasing angles; see 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:

     context->save();
     context->translate(x, y);
     context->scale(width / 2.0, height / 2.0);
     context->arc(0.0, 0.0, 1.0, 0.0, 2 * M_PI);
     context->restore();

Parameters:

  xc | X position of the center of the arc
  yc | Y position of the center of the arc
  radius | the radius of the arc
  angle1 | the start angle, in radians
  angle2 | the end angle, in radians

void Cairo::Context::arc_negative | ( | double | xc,
|  | double | yc,
|  | double | radius,
|  | double | angle1,
|  | double | 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*M_PI until it is greater than angle1.

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

Parameters:

  xc | X position of the center of the arc
  yc | Y position of the center of the arc
  radius | the radius of the arc
  angle1 | the start angle, in radians
  angle2 | the end angle, in radians

void Cairo::Context::begin_new_path | ( |  | ) |

Clears the current path.

After this call there will be no current point.

void Cairo::Context::begin_new_sub_path | ( |  | ) |

Begin a new subpath.

Note that the existing path is not affected. After this call there will be no current point.

In many cases, this call is not needed since new subpaths are frequently started with move_to().

A call to begin_new_sub_path() is particularly useful when beginning a new subpath with one of the arc() calls. This makes things easier as it is no longer necessary to manually compute the arc's initial coordinates for a call to move_to().

void Cairo::Context::clip | ( |  | ) |

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

After clip(), the current path will be cleared from the cairo Context.

The current clip region affects all drawing operations by effectively masking out any changes to the surface that are outside the current clip region.

Calling 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 save()/restore() pair. The only other means of increasing the size of the clip region is reset_clip().

See also:
  set_fill_rule()

void Cairo::Context::clip_preserve | ( |  | ) |

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

Unlike clip(), cairo_clip_preserve preserves the path within the cairo Context.

See also:
  clip()
  set_fill_rule()

void Cairo::Context::close_path | ( |  | ) |

Adds a line segment to the path from the current point to the beginning of the current subpath, (the most recent point passed to move_to()), and closes this subpath.

The behavior of close_path() is distinct from simply calling line_to() with the equivalent coordinate in the case of stroking. When a closed subpath is stroked, there are no caps on the ends of the subpath. Instead, there is a line join connecting the final and initial segments of the subpath.

cobject* Cairo::Context::cobj | ( |  | ) | `[inline]`

Gets a pointer to the base C type that is wrapped by the Context.

const cobject* Cairo::Context::cobj | ( |  | ) | const`[inline]`

Gets a pointer to the base C type that is wrapped by the Context.

void Cairo::Context::copy_clip_rectangle_list | ( | std::vector< Rectangle >& | rectangles | ) | const

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

This function will throw an exception if the clip region cannot be represented as a list of user-space rectangles.

1.4

void Cairo::Context::copy_page | ( |  | ) |

Path* Cairo::Context::copy_path | ( |  | ) | const

Creates a copy of the current path and returns it to the user.

Note:
  The caller owns the Path object returned from this function. The Path object must be freed when you are finished with it.

Path* Cairo::Context::copy_path_flat | ( |  | ) | const

Gets a flattened copy of the current path and returns it to the user.

This function is like copy_path() except that any curves in the path will be approximated with piecewise-linear approximations, (accurate to within the current tolerance value). That is, the result is guaranteed to not have any elements of type CAIRO_PATH_CURVE_TO which will instead be replaced by a series of CAIRO_PATH_LINE_TO elements.

Note:
  The caller owns the Path object returned from this function. The Path object must be freed when you are finished with it.

static RefPtr<Context> Cairo::Context::create | ( | const RefPtr< Surface >& | target | ) | `[static]`

Examples:
  image-surface.cc, pdf-surface.cc, ps-surface.cc, svg-surface.cc, toy-text.cc, and user-font.cc.

void Cairo::Context::curve_to | ( | double | x1,
|  | double | y1,
|  | double | x2,
|  | double | y2,
|  | double | x3,
|  | double | y3
| ) |  |

Adds a cubic Bezier 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).

Parameters:

  x1 | the X coordinate of the first control point
  y1 | the Y coordinate of the first control point
  x2 | the X coordinate of the second control point
  y2 | the Y coordinate of the second control point
  x3 | the X coordinate of the end of the curve
  y3 | the Y coordinate of the end of the curve

void Cairo::Context::device_to_user | ( | double & | x,
|  | double & | y
| ) |  |

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

Parameters:

  x | X value of coordinate (in/out parameter)
  y | Y value of coordinate (in/out parameter)

Deprecated:
  Use the const version.

void Cairo::Context::device_to_user | ( | double & | x,
|  | double & | y
| ) |  | const

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

Parameters:

  x | X value of coordinate (in/out parameter)
  y | Y value of coordinate (in/out parameter)

void Cairo::Context::device_to_user_distance | ( | double & | dx,
|  | double & | dy
| ) |  | const

Transform a distance vector from device space to user space.

This function is similar to device_to_user() except that the translation components of the inverse CTM will be ignored when transforming (dx,dy).

Parameters:

  dx | X component of a distance vector (in/out parameter)
  dy | Y component of a distance vector (in/out parameter)

void Cairo::Context::device_to_user_distance | ( | double & | dx,
|  | double & | dy
| ) |  |

Transform a distance vector from device space to user space.

This function is similar to device_to_user() except that the translation components of the inverse CTM will be ignored when transforming (dx,dy).

Parameters:

  dx | X component of a distance vector (in/out parameter)
  dy | Y component of a distance vector (in/out parameter)

Deprecated:
  Use the const version.

void Cairo::Context::fill | ( |  | ) |

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:
  set_fill_rule()
  fill_preserve()

void Cairo::Context::fill_preserve | ( |  | ) |

A drawing operator that fills the current path according to the current fill rule, (each sub-path is implicitly closed before being filled).

Unlike fill(), fill_preserve() preserves the path within the cairo Context.

See also:
  set_fill_rule()
  fill().

Antialias Cairo::Context::get_antialias | ( |  | ) | const

Gets the current shape antialiasing mode, as set by set_antialias()

void Cairo::Context::get_clip_extents | ( | double & | x1,
|  | double & | y1,
|  | double & | x2,
|  | double & | y2
| ) |  | const

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

Parameters:

  x1 | left of the resulting extents
  y1 | top of the resulting extents
  x2 | right of the resulting extents
  y2 | bottom of the resulting extents

Since:
  1.4

void Cairo::Context::get_current_point | ( | double & | x,
|  | double & | y
| ) |  | const

Gets the current point of the current path, which is conceptually the final point reached by the path so far.

The current point is returned in the user-space coordinate system. If there is no defined current point then x and y will both be set to 0.0.

Most path construction functions alter the current point. See the following for details on how they affect the current point: clear_path(), move_to(), line_to(), curve_to(), arc(), rel_move_to(), rel_line_to(), rel_curve_to(), arc(), and text_path()

Parameters:

  x | return value for X coordinate of the current point
  y | return value for Y coordinate of the current point

See also:
  has_current_point

void Cairo::Context::get_dash | ( | std::vector< double > & | dashes,
|  | double & | offset
| ) |  | const

Gets the current dash array and offset.

Parameters:

  dashes | return value for the dash array.
  offset | return value for the current dash offset.

Since: 1.4

void Cairo::Context::get_fill_extents | ( | double & | x1,
|  | double & | y1,
|  | double & | x2,
|  | double & | y2
| ) |  | const

FillRule Cairo::Context::get_fill_rule | ( |  | ) | const

Gets the current fill rule, as set by set_fill_rule().

void Cairo::Context::get_font_extents | ( | FontExtents& | extents | ) | const

RefPtr<FontFace> Cairo::Context::get_font_face | ( |  | ) |

RefPtr<const FontFace> Cairo::Context::get_font_face | ( |  | ) | const

void Cairo::Context::get_font_matrix | ( | Matrix& | matrix | ) | const

void Cairo::Context::get_font_matrix | ( | cairo_matrix_t& | matrix | ) | const

void Cairo::Context::get_font_options | ( | FontOptions& | options | ) | const

Since:
  1.8

void Cairo::Context::get_glyph_extents | ( | const std::vector< Glyph >& | glyphs,
|  | TextExtents& | extents
| ) |  | const

RefPtr<Surface> Cairo::Context::get_group_target | ( |  | ) |

Gets the target surface for the current group as started by the most recent call to push_group() or push_group_with_content().

This function will return NULL if called "outside" of any group rendering blocks, (that is, after the last balancing call to pop_group() or pop_group_to_source()).

Exceptions:

RefPtr<const Surface> Cairo::Context::get_group_target | ( |  | ) | const

Same as the non-const version but returns a reference to a const Surface.

LineCap Cairo::Context::get_line_cap | ( |  | ) | const

Gets the current line cap style, as set by set_line_cap()

LineJoin Cairo::Context::get_line_join | ( |  | ) | const

Gets the current line join style, as set by set_line_join()

double Cairo::Context::get_line_width | ( |  | ) | const

Gets the current line width, as set by set_line_width()

void Cairo::Context::get_matrix | ( | cairo_matrix_t& | matrix | ) |

Matrix Cairo::Context::get_matrix | ( |  | ) | const

Since:
  1.8

void Cairo::Context::get_matrix | ( | Matrix& | matrix | ) |

Stores the current transformation matrix (CTM) into matrix.

Parameters:

  matrix | return value for the matrix

double Cairo::Context::get_miter_limit | ( |  | ) | const

Gets the current miter limit, as set by set_miter_limit()

Operator Cairo::Context::get_operator | ( |  | ) | const

Gets the current compositing operator for a cairo Context.

void Cairo::Context::get_path_extents | ( | double & | x1,
|  | double & | y1,
|  | double & | x2,
|  | double & | y2
| ) |  | const

Computes a bounding box in user-space coordinates covering the points on the current path.

If the current path is empty, returns an empty rectangle ((0,0), (0,0)). Stroke parameters, fill rule, surface dimensions and clipping are not taken into account.

Contrast with fill_extents() and stroke_extents() which return the extents of only the area that would be "inked" by the corresponding drawing operations.

The result of path_extents() is defined as equivalent to the limit of stroke_extents() with Cairo::LINE_CAP_ROUND as the line width approaches 0.0, (but never reaching the empty-rectangle returned by stroke_extents() for a line width of 0.0).

Specifically, this means that zero-area sub-paths such as move_to();line_to() segments, (even degenerate cases where the coordinates to both calls are identical), will be considered as contributing to the extents. However, a lone move_to() will not contribute to the results of path_extents().

Parameters:

  x1 | left of the resulting extents
  y1 | top of the resulting extents
  x2 | right of the resulting extents
  y2 | bottom of the resulting extents

Since:
  1.6

RefPtr<ScaledFont> Cairo::Context::get_scaled_font | ( |  | ) |

Since:
  1.8

RefPtr<const Pattern> Cairo::Context::get_source | ( |  | ) | const

RefPtr<Pattern> Cairo::Context::get_source | ( |  | ) |

Gets the current source pattern for the Context.

void Cairo::Context::get_stroke_extents | ( | double & | x1,
|  | double & | y1,
|  | double & | x2,
|  | double & | y2
| ) |  | const

RefPtr<Surface> Cairo::Context::get_target | ( |  | ) |

Gets the target surface associated with this Context.

Exceptions:

RefPtr<const Surface> Cairo::Context::get_target | ( |  | ) | const

Gets the target surface associated with this Context.

Exceptions:

void Cairo::Context::get_text_extents | ( | const std::string & | utf8,
|  | TextExtents& | extents
| ) |  | const

double Cairo::Context::get_tolerance | ( |  | ) | const

Gets the current tolerance value, as set by set_tolerance()

void Cairo::Context::glyph_path | ( | const std::vector< Glyph >& | glyphs | ) |

bool Cairo::Context::has_current_point | ( |  | ) | const

Checks if there is a current point defined.

bool Cairo::Context::in_clip | ( | double | x,
|  | double | y
| ) |  | const

bool Cairo::Context::in_fill | ( | double | x,
|  | double | y
| ) |  | const

bool Cairo::Context::in_stroke | ( | double | x,
|  | double | y
| ) |  | const

void Cairo::Context::line_to | ( | double | x,
|  | double | y
| ) |  |

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

Parameters:

  x | the X coordinate of the end of the new line
  y | the Y coordinate of the end of the new line

void Cairo::Context::mask | ( | const RefPtr< const Pattern >& | pattern | ) |

A drawing operator that paints the current source using the alpha channel of pattern as a mask.

(Opaque areas of mask are painted with the source, transparent areas are not painted.)

Parameters:

  pattern | a Pattern

void Cairo::Context::mask | ( | const RefPtr< const Surface >& | surface,
|  | double | surface_x,
|  | double | surface_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.)

Parameters:

  surface | a Surface
  surface_x | X coordinate at which to place the origin of surface
  surface_y | Y coordinate at which to place the origin of surface

void Cairo::Context::move_to | ( | double | x,
|  | double | y
| ) |  |

If the current subpath is not empty, begin a new subpath.

After this call the current point will be (x, y).

Parameters:

  x | the X coordinate of the new position
  y | the Y coordinate of the new position

void Cairo::Context::paint | ( |  | ) |

A drawing operator that paints the current source everywhere within the current clip region.

void Cairo::Context::paint_with_alpha | ( | double | alpha | ) |

A drawing operator that paints the current source everywhere within the current clip region using a mask of constant alpha value alpha.

The effect is similar to paint(), but the drawing is faded out using the alpha value.

Parameters:

  alpha | an alpha value, between 0 (transparent) and 1 (opaque)

RefPtr<Pattern> Cairo::Context::pop_group | ( |  | ) |

Terminates the redirection begun by a call to push_group() or push_group_with_content() and returns a new pattern containing the results of all drawing operations performed to the group.

The pop_group() function calls restore(), (balancing a call to save() by the push_group function), so that any changes to the graphics state will not be visible outside the group.

Returns:
  a (surface) pattern containing the results of all drawing operations performed to the group.

void Cairo::Context::pop_group_to_source | ( |  | ) |

Terminates the redirection begun by a call to push_group() or push_group_with_content() and installs the resulting pattern as the source pattern in the given cairo Context.

The behavior of this function is equivalent to the sequence of operations:

     RefPtr<Pattern> group = cr->pop_group();
     cr->set_source(group);

but is more convenient as their is no need for a variable to store the short-lived pointer to the pattern.

The pop_group() function calls restore(), (balancing a call to save() by the push_group function), so that any changes to the graphics state will not be visible outside the group.

void Cairo::Context::push_group | ( |  | ) |

Temporarily redirects drawing to an intermediate surface known as a group.

The redirection lasts until the group is completed by a call to pop_group() or pop_group_to_source(). These calls provide the result of any drawing to the group as a pattern, (either as an explicit object, or set as the source pattern).

This group functionality can be convenient for performing intermediate compositing. One common use of a group is to render objects as opaque within the group, (so that they occlude each other), and then blend the result with translucence onto the destination.

Groups can be nested arbitrarily deep by making balanced calls to push_group()/pop_group(). Each call pushes/pops the new target group onto/from a stack.

The push_group() function calls save() so that any changes to the graphics state will not be visible outside the group, (the pop_group functions call restore()).

By default the intermediate group will have a content type of CONTENT_COLOR_ALPHA. Other content types can be chosen for the group by using push_group_with_content() instead.

As an example, here is how one might fill and stroke a path with translucence, but without any portion of the fill being visible under the stroke:

     cr->push_group();
     cr->set_source(fill_pattern);
     cr->fill_preserve();
     cr->set_source(stroke_pattern);
     cr->stroke();
     cr->pop_group_to_source();
     cr->paint_with_alpha(alpha);

void Cairo::Context::push_group_with_content | ( | Content | content | ) |

Temporarily redirects drawing to an intermediate surface known as a group.

The redirection lasts until the group is completed by a call to pop_group() or pop_group_to_source(). These calls provide the result of any drawing to the group as a pattern, (either as an explicit object, or set as the source pattern).

The group will have a content type of . The ability to control this content type is the only distinction between this function and push_group() which you should see for a more detailed description of group rendering.

Parameters:

  content | indicates the type of group that will be created

void Cairo::Context::rectangle | ( | double | x,
|  | double | y,
|  | double | width,
|  | double | height
| ) |  |

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

This function is logically equivalent to:

     context->move_to(x, y);
     context->rel_line_to(width, 0);
     context->rel_line_to(0, height);
     context->rel_line_to(-width, 0);
     context->close_path();

Parameters:

  x | the X coordinate of the top left corner of the rectangle
  y | the Y coordinate to the top left corner of the rectangle
  width | the width of the rectangle
  height | the height of the rectangle

void Cairo::Context::rel_curve_to | ( | double | dx1,
|  | double | dy1,
|  | double | dx2,
|  | double | dy2,
|  | double | dx3,
|  | double | dy3
| ) |  |

Relative-coordinate version of curve_to().

All offsets are relative to the current point. Adds a cubic Bezier 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(dx1, dy1, dx2, dy2, dx3, dy3)

is logically equivalent to

     curve_to(x + dx1, y + dy1, x + dx2, y + dy2, x + dx3, y + dy3).

Parameters:

  dx1 | the X offset to the first control point
  dy1 | the Y offset to the first control point
  dx2 | the X offset to the second control point
  dy2 | the Y offset to the second control point
  dx3 | the X offset to the end of the curve
  dy3 | the Y offset to the end of the curve

It is an error to call this function with no current point. Doing so will cause this to shutdown with a status of CAIRO_STATUS_NO_CURRENT_POINT. Cairomm will then throw an exception.

void Cairo::Context::rel_line_to | ( | double | dx,
|  | double | dy
| ) |  |

Relative-coordinate version of 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(dx, dy)

is logically equivalent to

     line_to(x + dx, y + dy).

Parameters:

  dx | the X offset to the end of the new line
  dy | the Y offset to the end of the new line

It is an error to call this function with no current point. Doing so will cause this to shutdown with a status of CAIRO_STATUS_NO_CURRENT_POINT. Cairomm will then throw an exception.

void Cairo::Context::rel_move_to | ( | double | dx,
|  | double | dy
| ) |  |

If the current subpath is not empty, begin a new subpath.

After this call the current point will offset by (x, y).

Given a current point of (x, y),

     rel_move_to(dx, dy)

is logically equivalent to

     move_to(x + dx, y + dy)

Parameters:

  dx | the X offset
  dy | the Y offset

It is an error to call this function with no current point. Doing so will cause this to shutdown with a status of CAIRO_STATUS_NO_CURRENT_POINT. Cairomm will then throw an exception.

void Cairo::Context::reset_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 reset_clip() as it will cause results unexpected by higher-level code which calls clip(). Consider using save() and restore() around clip() as a more robust means of temporarily restricting the clip region.

void Cairo::Context::restore | ( |  | ) |

Restores cr to the state saved by a preceding call to save() and removes that state from the stack of saved states.

See also:
  save()

void Cairo::Context::rotate | ( | double | angle_radians | ) |

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.

Parameters:

  angle | angle (in radians) by which the user-space axes will be rotated

void Cairo::Context::rotate_degrees | ( | double | angle_degres | ) |

A convenience wrapper around rotate() that accepts angles in degrees.

Parameters:

  angle_degrees | angle (in degrees) by which the user-space axes should be rotated

void Cairo::Context::save | ( |  | ) |

Makes a copy of the current state of the Context and saves it on an internal stack of saved states.

When restore() is called, it 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().

It isn't necessary to clear all saved states before a cairo_t is freed. Any saved states will be freed when the Context is destroyed.

See also:
  restore()

void Cairo::Context::scale | ( | double | sx,
|  | double | 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.

Parameters:

  sx | scale factor for the X dimension
  sy | scale factor for the Y dimension

void Cairo::Context::select_font_face | ( | const std::string & | family,
|  | FontSlant | slant,
|  | FontWeight | weight
| ) |  |

void Cairo::Context::set_antialias | ( | Antialias | antialias | ) |

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 CAIRO_ANTIALIAS_SUBPIXEL when drawing shapes.

Note that this option does not affect text rendering, instead see FontOptions::set_antialias().

Parameters:

  antialias | the new antialiasing mode

void Cairo::Context::set_dash | ( | const std::valarray< double > & | dashes,
|  | double | offset
| ) |  |

Alternate version of set_dash().

You'll probably want to use the one that takes a std::vector argument instead.

void Cairo::Context::set_dash | ( | const std::vector< double > & | dashes,
|  | double | offset
| ) |  |

Sets the dash pattern to be used by stroke().

A dash pattern is specified by dashes, an array of positive values. Each value provides the user-space length of altenate "on" and "off" portions of the stroke. The offset specifies an offset into the pattern at which the stroke begins.

If dashes is empty dashing is disabled. If the size of dashes is 1, a symmetric pattern is assumed with alternating on and off portions of the size specified by the single value in dashes.

It is invalid for any value in dashes to be negative, or for all values to be 0. If this is the case, an exception will be thrown

Parameters:

  dashes | an array specifying alternate lengths of on and off portions
  offset | an offset into the dash pattern at which the stroke should start

Exceptions:

void Cairo::Context::set_dash | ( | std::valarray< double > & | dashes,
|  | double | offset
| ) |  |

Alternate version of set_dash().

You'll probably want to use the one that takes a std::vector argument instead.

Deprecated:
  Instead use the version that takes a const dashes parameter.

void Cairo::Context::set_dash | ( | std::vector< double > & | dashes,
|  | double | offset
| ) |  |

Sets the dash pattern to be used by stroke().

A dash pattern is specified by dashes, an array of positive values. Each value provides the user-space length of altenate "on" and "off" portions of the stroke. The offset specifies an offset into the pattern at which the stroke begins.

If dashes is empty dashing is disabled. If the size of dashes is 1, a symmetric pattern is assumed with alternating on and off portions of the size specified by the single value in dashes.

It is invalid for any value in dashes to be negative, or for all values to be 0. If this is the case, an exception will be thrown

Parameters:

  dashes | an array specifying alternate lengths of on and off portions
  offset | an offset into the dash pattern at which the stroke should start

Exceptions:

  \xrefitem | deprecated 2.

void Cairo::Context::set_fill_rule | ( | FillRule | fill_rule | ) |

Set the current fill rule within the cairo Context.

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 fill() and clip(). See FillRule for details on the semantics of each available fill rule.

Parameters:

  fill_rule | a fill rule, specified as a FillRule

void Cairo::Context::set_font_face | ( | const RefPtr< const FontFace >& | font_face | ) |

void Cairo::Context::set_font_matrix | ( | const Matrix& | matrix | ) |

void Cairo::Context::set_font_matrix | ( | const cairo_matrix_t& | matrix | ) |

void Cairo::Context::set_font_options | ( | const FontOptions& | options | ) |

void Cairo::Context::set_font_size | ( | double | size | ) |

void Cairo::Context::set_identity_matrix | ( |  | ) |

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.

void Cairo::Context::set_line_cap | ( | LineCap | line_cap | ) |

Sets the current line cap style within the cairo Context.

See LineCap 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 stroke(), stroke_extents(), and stroke_to_path(), but does not have any effect during path construction.

Parameters:

  line_cap | a line cap style, as a LineCap

void Cairo::Context::set_line_join | ( | LineJoin | line_join | ) |

Sets the current line join style within the cairo Context.

See LineJoin 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 stroke(), stroke_extents(), and stroke_to_path(), but does not have any effect during path construction.

Parameters:

  line_join | a line joint style, as a LineJoin

void Cairo::Context::set_line_width | ( | double | width | ) |

Sets the current line width within the cairo Context.

The line width specifies the diameter of a pen that is circular in user-space.

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

Parameters:

  width | a line width, as a user-space value

void Cairo::Context::set_matrix | ( | const cairo_matrix_t& | matrix | ) |

void Cairo::Context::set_matrix | ( | const Matrix& | matrix | ) |

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

Parameters:

  matrix | a transformation matrix from user space to device space

void Cairo::Context::set_miter_limit | ( | double | limit | ) |

void Cairo::Context::set_operator | ( | Operator | op | ) |

Sets the compositing operator to be used for all drawing operations.

See Operator for details on the semantics of each available compositing operator.

Parameters:

  op | a compositing operator, specified as a Operator

void Cairo::Context::set_scaled_font | ( | const RefPtr< const ScaledFont >& | scaled_font | ) |

Since:
  1.8

void Cairo::Context::set_source | ( | const RefPtr< const Pattern >& | source | ) |

Sets the source pattern within the Context 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.

Parameters:

  source | a Pattern to be used as the source for subsequent drawing operations.

See also:
  Pattern::set_matrix()
  set_source_rgb()
  set_source_rgba()
  set_source(const RefPtr<Surface>& surface, double x, double y)

void Cairo::Context::set_source | ( | const RefPtr< Surface >& | surface,
|  | double | x,
|  | double | y
| ) |  |

This is a convenience function for creating a pattern from a Surface and setting it as the 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 Context::create(const RefPtr<Surface>& target). The resulting pattern can be queried with get_source() so that these attributes can be modified if desired, (eg. to create a repeating pattern with Pattern::set_extend()).

Parameters:

  surface | a Surface to be used to set the source pattern
  x | User-space X coordinate for surface origin
  y | User-space Y coordinate for surface origin

void Cairo::Context::set_source_rgb | ( | double | red,
|  | double | green,
|  | double | blue
| ) |  |

Sets the source pattern within the Context 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.

Parameters:

  red | red component of color
  green | green component of color
  blue | blue component of color

See also:
  set_source_rgba()
  set_source()

void Cairo::Context::set_source_rgba | ( | double | red,
|  | double | green,
|  | double | blue,
|  | double | alpha
| ) |  |

Sets the source pattern within the Context 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.

Parameters:

  red | red component of color
  green | green component of color
  blue | blue component of color
  alpha | alpha component of color

See also:
  set_source_rgb()
  set_source()

void Cairo::Context::set_tolerance | ( | double | tolerance | ) |

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

Parameters:

  tolerance | the tolerance, in device units (typically pixels)

void Cairo::Context::show_glyphs | ( | const std::vector< Glyph >& | glyphs | ) |

void Cairo::Context::show_page | ( |  | ) |

void Cairo::Context::show_text | ( | const std::string & | utf8 | ) |

void Cairo::Context::show_text_glyphs | ( | const std::string & | utf8,
|  | const std::vector< Glyph >& | glyphs,
|  | const std::vector< TextCluster >& | clusters,
|  | TextClusterFlags | cluster_flags
| ) |  |

Since:
  1.8

void Cairo::Context::stroke | ( |  | ) |

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 also:
  set_line_width()
  set_line_join()
  set_line_cap()
  set_dash()
  stroke_preserve().

void Cairo::Context::stroke_preserve | ( |  | ) |

A drawing operator that strokes the current Path according to the current line width, line join, line cap, and dash settings.

Unlike stroke(), stroke_preserve() preserves the Path within the cairo Context.

See also:
  set_line_width()
  set_line_join()
  set_line_cap()
  set_dash()
  stroke_preserve().

void Cairo::Context::text_path | ( | const std::string & | utf8 | ) |

void Cairo::Context::transform | ( | const cairo_matrix_t& | matrix | ) |

void Cairo::Context::transform | ( | const Matrix& | 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.

Parameters:

  matrix | a transformation to be applied to the user-space axes

void Cairo::Context::translate | ( | double | tx,
|  | double | 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 cairo_translate. In other words, the translation of the user-space origin takes place after any existing transformation.

Parameters:

  tx | amount to translate in the X direction
  ty | amount to translate in the Y direction

void Cairo::Context::unset_dash | ( |  | ) |

This function disables a dash pattern that was set with set_dash()

void Cairo::Context::user_to_device | ( | double & | x,
|  | double & | y
| ) |  | const

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

Parameters:

  x | X value of coordinate (in/out parameter)
  y | Y value of coordinate (in/out parameter)

void Cairo::Context::user_to_device | ( | double & | x,
|  | double & | y
| ) |  |

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

Parameters:

  x | X value of coordinate (in/out parameter)
  y | Y value of coordinate (in/out parameter)

Deprecated:
  Use the const version.

void Cairo::Context::user_to_device_distance | ( | double & | dx,
|  | double & | dy
| ) |  |

Transform a distance vector from user space to device space.

This function is similar to user_to_device() except that the translation components of the CTM will be ignored when transforming (dx,dy).

Parameters:

  dx | X component of a distance vector (in/out parameter)
  dy | Y component of a distance vector (in/out parameter)

Deprecated:
  Use the const version.

void Cairo::Context::user_to_device_distance | ( | double & | dx,
|  | double & | dy
| ) |  | const

Transform a distance vector from user space to device space.

This function is similar to user_to_device() except that the translation components of the CTM will be ignored when transforming (dx,dy).

Parameters:

  dx | X component of a distance vector (in/out parameter)
  dy | Y component of a distance vector (in/out parameter)

## Member Data Documentation

cobject* Cairo::Context::m_cobject `[protected]`

The documentation for this class was generated from the following file:

- cairomm/context.h