Public Types | Public Member Functions | Static Public Member Functions | Protected Member Functions | Protected Attributes

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< ScaledFontget_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< FontFaceget_font_face ()
RefPtr< const FontFaceget_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< Patternget_source ()
 Gets the current source pattern for the Context.
RefPtr< const Patternget_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< Surfaceget_target ()
 Gets the target surface associated with this Context.
RefPtr< const Surfaceget_target () const
 Gets the target surface associated with this Context.
Pathcopy_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.
Pathcopy_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< Patternpop_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< Surfaceget_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 Surfaceget_group_target () const
 Same as the non-const version but returns a reference to a const Surface.
cobjectcobj ()
 Gets a pointer to the base C type that is wrapped by the Context.
const cobjectcobj () const
 Gets a pointer to the base C type that is wrapped by the Context.

Static Public Member Functions

static RefPtr< Contextcreate (const RefPtr< Surface >& target)

Protected Member Functions

 Context (const RefPtr< Surface >& target)

Protected Attributes

cobjectm_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]
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


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