cairo_t

typedef struct _cairo cairo_t;

A cairo_matrix holds an affine transformation, such as a scale, rotation, or shear, or a combination of those.

cairo_create ()

cairo_t*    cairo_create                    (void);

cairo_reference ()

void        cairo_reference                 (cairo_t *cr);

cairo_destroy ()

void        cairo_destroy                   (cairo_t *cr);

cairo_save ()

void        cairo_save                      (cairo_t *cr);

cairo_restore ()

void        cairo_restore                   (cairo_t *cr);

cairo_copy ()

void        cairo_copy                      (cairo_t *dest,
                                             cairo_t *src);

cairo_set_target_surface ()

void        cairo_set_target_surface        (cairo_t *cr,
                                             cairo_surface_t *surface);

enum cairo_format_t

typedef enum cairo_format {
    CAIRO_FORMAT_ARGB32,
    CAIRO_FORMAT_RGB24,
    CAIRO_FORMAT_A8,
    CAIRO_FORMAT_A1
} cairo_format_t;

cairo_set_target_image ()

void        cairo_set_target_image          (cairo_t *cr,
                                             char *data,
                                             cairo_format_t format,
                                             int width,
                                             int height,
                                             int stride);

enum cairo_operator_t

typedef enum cairo_operator { 
    CAIRO_OPERATOR_CLEAR,
    CAIRO_OPERATOR_SRC,
    CAIRO_OPERATOR_DST,
    CAIRO_OPERATOR_OVER,
    CAIRO_OPERATOR_OVER_REVERSE,
    CAIRO_OPERATOR_IN,
    CAIRO_OPERATOR_IN_REVERSE,
    CAIRO_OPERATOR_OUT,
    CAIRO_OPERATOR_OUT_REVERSE,
    CAIRO_OPERATOR_ATOP,
    CAIRO_OPERATOR_ATOP_REVERSE,
    CAIRO_OPERATOR_XOR,
    CAIRO_OPERATOR_ADD,
    CAIRO_OPERATOR_SATURATE
} cairo_operator_t;

cairo_set_operator ()

void        cairo_set_operator              (cairo_t *cr,
                                             cairo_operator_t op);

cairo_set_rgb_color ()

void        cairo_set_rgb_color             (cairo_t *cr,
                                             double red,
                                             double green,
                                             double blue);

cairo_set_pattern ()

void        cairo_set_pattern               (cairo_t *cr,
                                             cairo_pattern_t *pattern);

cairo_set_alpha ()

void        cairo_set_alpha                 (cairo_t *cr,
                                             double alpha);

cairo_set_tolerance ()

void        cairo_set_tolerance             (cairo_t *cr,
                                             double tolerance);

enum cairo_fill_rule_t

typedef enum cairo_fill_rule {
    CAIRO_FILL_RULE_WINDING,
    CAIRO_FILL_RULE_EVEN_ODD
} cairo_fill_rule_t;

cairo_set_fill_rule ()

void        cairo_set_fill_rule             (cairo_t *cr,
                                             cairo_fill_rule_t fill_rule);

cairo_set_line_width ()

void        cairo_set_line_width            (cairo_t *cr,
                                             double width);

enum cairo_line_cap_t

typedef enum cairo_line_cap {
    CAIRO_LINE_CAP_BUTT,
    CAIRO_LINE_CAP_ROUND,
    CAIRO_LINE_CAP_SQUARE
} cairo_line_cap_t;

enumeration for style of line-endings

cairo_set_line_cap ()

void        cairo_set_line_cap              (cairo_t *cr,
                                             cairo_line_cap_t line_cap);

enum cairo_line_join_t

typedef enum cairo_line_join {
    CAIRO_LINE_JOIN_MITER,
    CAIRO_LINE_JOIN_ROUND,
    CAIRO_LINE_JOIN_BEVEL
} cairo_line_join_t;

cairo_set_line_join ()

void        cairo_set_line_join             (cairo_t *cr,
                                             cairo_line_join_t line_join);

cairo_set_dash ()

void        cairo_set_dash                  (cairo_t *cr,
                                             double *dashes,
                                             int ndash,
                                             double offset);

cairo_set_miter_limit ()

void        cairo_set_miter_limit           (cairo_t *cr,
                                             double limit);

cairo_translate ()

void        cairo_translate                 (cairo_t *cr,
                                             double tx,
                                             double ty);

cairo_scale ()

void        cairo_scale                     (cairo_t *cr,
                                             double sx,
                                             double sy);

cairo_rotate ()

void        cairo_rotate                    (cairo_t *cr,
                                             double angle);

cairo_concat_matrix ()

void        cairo_concat_matrix             (cairo_t *cr,
                                             cairo_matrix_t *matrix);

cairo_set_matrix ()

void        cairo_set_matrix                (cairo_t *cr,
                                             cairo_matrix_t *matrix);

cairo_default_matrix ()

void        cairo_default_matrix            (cairo_t *cr);

cairo_identity_matrix ()

void        cairo_identity_matrix           (cairo_t *cr);

cairo_transform_point ()

void        cairo_transform_point           (cairo_t *cr,
                                             double *x,
                                             double *y);

cairo_transform_distance ()

void        cairo_transform_distance        (cairo_t *cr,
                                             double *dx,
                                             double *dy);

cairo_inverse_transform_point ()

void        cairo_inverse_transform_point   (cairo_t *cr,
                                             double *x,
                                             double *y);

cairo_inverse_transform_distance ()

void        cairo_inverse_transform_distance
                                            (cairo_t *cr,
                                             double *dx,
                                             double *dy);

cairo_new_path ()

void        cairo_new_path                  (cairo_t *cr);

cairo_move_to ()

void        cairo_move_to                   (cairo_t *cr,
                                             double x,
                                             double y);

cairo_line_to ()

void        cairo_line_to                   (cairo_t *cr,
                                             double x,
                                             double y);

cairo_curve_to ()

void        cairo_curve_to                  (cairo_t *cr,
                                             double x1,
                                             double y1,
                                             double x2,
                                             double y2,
                                             double x3,
                                             double y3);

cairo_arc ()

void        cairo_arc                       (cairo_t *cr,
                                             double xc,
                                             double yc,
                                             double radius,
                                             double angle1,
                                             double angle2);

Adds an arc from angle1 to angle2 to the current path. If there is a current point, that point is connected to the start of the arc by a straight line segment. Angles are measured with an angle of 0 along the X axis and an angle of 90 degrees (M_PI radians) along the Y axis, so with the default transformation matrix, positive angles are clockwise. This function gives the arc in the direction of increasing angle; see cairo_arc_negative() to get the arc in the direction of decreasing angle.

A full arc is drawn as a circle. To make an oval arc, you can scale the current transformation matrix by different amounts in the X and Y directions. For example, to draw a full oval in the box given by x, y, width, height:

cairo_save (cr);
cairo_translate (x + width / 2., y + height / 2.);
cairo_scale (1. / (height / 2.), 1. / (width / 2.));
cairo_arc (cr, 0., 0., 1., 0., 2 * M_PI);

cairo_arc_negative ()

void        cairo_arc_negative              (cairo_t *cr,
                                             double xc,
                                             double yc,
                                             double radius,
                                             double angle1,
                                             double angle2);

Adds an arc from angle1 to angle2 to the current path. The function behaves identically to cairo_arc() except that instead of giving the arc in the direction of increasing angle, it gives the arc in the direction of decreasing angle.

cairo_rel_move_to ()

void        cairo_rel_move_to               (cairo_t *cr,
                                             double dx,
                                             double dy);

cairo_rel_line_to ()

void        cairo_rel_line_to               (cairo_t *cr,
                                             double dx,
                                             double dy);

cairo_rel_curve_to ()

void        cairo_rel_curve_to              (cairo_t *cr,
                                             double dx1,
                                             double dy1,
                                             double dx2,
                                             double dy2,
                                             double dx3,
                                             double dy3);

cairo_rectangle ()

void        cairo_rectangle                 (cairo_t *cr,
                                             double x,
                                             double y,
                                             double width,
                                             double height);

cairo_close_path ()

void        cairo_close_path                (cairo_t *cr);

cairo_stroke ()

void        cairo_stroke                    (cairo_t *cr);

cairo_fill ()

void        cairo_fill                      (cairo_t *cr);

cairo_copy_page ()

void        cairo_copy_page                 (cairo_t *cr);

cairo_show_page ()

void        cairo_show_page                 (cairo_t *cr);

cairo_in_stroke ()

int         cairo_in_stroke                 (cairo_t *cr,
                                             double x,
                                             double y);

cairo_in_fill ()

int         cairo_in_fill                   (cairo_t *cr,
                                             double x,
                                             double y);

cairo_stroke_extents ()

void        cairo_stroke_extents            (cairo_t *cr,
                                             double *x1,
                                             double *y1,
                                             double *x2,
                                             double *y2);

cairo_fill_extents ()

void        cairo_fill_extents              (cairo_t *cr,
                                             double *x1,
                                             double *y1,
                                             double *x2,
                                             double *y2);

cairo_init_clip ()

void        cairo_init_clip                 (cairo_t *cr);

cairo_clip ()

void        cairo_clip                      (cairo_t *cr);

cairo_font_t

typedef struct _cairo_font cairo_font_t;

cairo_glyph_t

typedef struct {
  unsigned long        index;
  double               x;
  double               y;
} cairo_glyph_t;

cairo_text_extents_t

typedef struct {
    double x_bearing;
    double y_bearing;
    double width;
    double height;
    double x_advance;
    double y_advance;
} cairo_text_extents_t;

cairo_font_extents_t

typedef struct {
    double ascent;
    double descent;
    double height;
    double max_x_advance;
    double max_y_advance;
} cairo_font_extents_t;

enum cairo_font_slant_t

typedef enum cairo_font_slant {
  CAIRO_FONT_SLANT_NORMAL,
  CAIRO_FONT_SLANT_ITALIC,
  CAIRO_FONT_SLANT_OBLIQUE
} cairo_font_slant_t;

enum cairo_font_weight_t

typedef enum cairo_font_weight {
  CAIRO_FONT_WEIGHT_NORMAL,
  CAIRO_FONT_WEIGHT_BOLD
} cairo_font_weight_t;

cairo_select_font ()

void        cairo_select_font               (cairo_t *cr,
                                             const char *family,
                                             cairo_font_slant_t slant,
                                             cairo_font_weight_t weight);

cairo_scale_font ()

void        cairo_scale_font                (cairo_t *cr,
                                             double scale);

cairo_transform_font ()

void        cairo_transform_font            (cairo_t *cr,
                                             cairo_matrix_t *matrix);

cairo_show_text ()

void        cairo_show_text                 (cairo_t *cr,
                                             unsigned char *utf8);

cairo_show_glyphs ()

void        cairo_show_glyphs               (cairo_t *cr,
                                             cairo_glyph_t *glyphs,
                                             int num_glyphs);

cairo_current_font ()

cairo_font_t* cairo_current_font            (cairo_t *cr);

cairo_current_font_extents ()

void        cairo_current_font_extents      (cairo_t *cr,
                                             cairo_font_extents_t *extents);

cairo_set_font ()

void        cairo_set_font                  (cairo_t *cr,
                                             cairo_font_t *font);

cairo_text_extents ()

void        cairo_text_extents              (cairo_t *cr,
                                             unsigned char *utf8,
                                             cairo_text_extents_t *extents);

cairo_glyph_extents ()

void        cairo_glyph_extents             (cairo_t *cr,
                                             cairo_glyph_t *glyphs,
                                             int num_glyphs,
                                             cairo_text_extents_t *extents);

cairo_text_path ()

void        cairo_text_path                 (cairo_t *cr,
                                             unsigned char *utf8);

cairo_glyph_path ()

void        cairo_glyph_path                (cairo_t *cr,
                                             cairo_glyph_t *glyphs,
                                             int num_glyphs);

cairo_font_reference ()

void        cairo_font_reference            (cairo_font_t *font);

cairo_font_destroy ()

void        cairo_font_destroy              (cairo_font_t *font);

cairo_font_glyph_extents ()

void        cairo_font_glyph_extents        (cairo_font_t *font,
                                             cairo_matrix_t *font_matrix,
                                             cairo_glyph_t *glyphs,
                                             int num_glyphs,
                                             cairo_text_extents_t *extents);

cairo_show_surface ()

void        cairo_show_surface              (cairo_t *cr,
                                             cairo_surface_t *surface,
                                             int width,
                                             int height);

cairo_current_operator ()

cairo_operator_t cairo_current_operator     (cairo_t *cr);

cairo_current_rgb_color ()

void        cairo_current_rgb_color         (cairo_t *cr,
                                             double *red,
                                             double *green,
                                             double *blue);

cairo_current_pattern ()

cairo_pattern_t* cairo_current_pattern      (cairo_t *cr);

cairo_current_alpha ()

double      cairo_current_alpha             (cairo_t *cr);

cairo_current_tolerance ()

double      cairo_current_tolerance         (cairo_t *cr);

cairo_current_point ()

void        cairo_current_point             (cairo_t *cr,
                                             double *x,
                                             double *y);

cairo_current_fill_rule ()

cairo_fill_rule_t cairo_current_fill_rule   (cairo_t *cr);

cairo_current_line_width ()

double      cairo_current_line_width        (cairo_t *cr);

cairo_current_line_cap ()

cairo_line_cap_t cairo_current_line_cap     (cairo_t *cr);

cairo_current_line_join ()

cairo_line_join_t cairo_current_line_join   (cairo_t *cr);

cairo_current_miter_limit ()

double      cairo_current_miter_limit       (cairo_t *cr);

cairo_current_matrix ()

void        cairo_current_matrix            (cairo_t *cr,
                                             cairo_matrix_t *matrix);

cairo_current_target_surface ()

cairo_surface_t* cairo_current_target_surface
                                            (cairo_t *cr);

cairo_current_path ()

void        cairo_current_path              (cairo_t *cr,
                                             cairo_move_to_func_t *move_to,
                                             cairo_line_to_func_t *line_to,
                                             cairo_curve_to_func_t *curve_to,
                                             cairo_close_path_func_t *close_path,
                                             void *closure);

cairo_current_path_flat ()

void        cairo_current_path_flat         (cairo_t *cr,
                                             cairo_move_to_func_t *move_to,
                                             cairo_line_to_func_t *line_to,
                                             cairo_close_path_func_t *close_path,
                                             void *closure);

enum cairo_status_t

typedef enum cairo_status {
    CAIRO_STATUS_SUCCESS = 0,
    CAIRO_STATUS_NO_MEMORY,
    CAIRO_STATUS_INVALID_RESTORE,
    CAIRO_STATUS_INVALID_POP_GROUP,
    CAIRO_STATUS_NO_CURRENT_POINT,
    CAIRO_STATUS_INVALID_MATRIX,
    CAIRO_STATUS_NO_TARGET_SURFACE,
    CAIRO_STATUS_NULL_POINTER
} cairo_status_t;

cairo_status ()

cairo_status_t cairo_status                 (cairo_t *cr);

cairo_status_string ()

const char* cairo_status_string             (cairo_t *cr);

enum cairo_filter_t

typedef enum {
    CAIRO_FILTER_FAST,
    CAIRO_FILTER_GOOD,
    CAIRO_FILTER_BEST,
    CAIRO_FILTER_NEAREST,
    CAIRO_FILTER_BILINEAR,
    CAIRO_FILTER_GAUSSIAN
} cairo_filter_t;

cairo_image_surface_create ()

cairo_surface_t* cairo_image_surface_create (cairo_format_t format,
                                             int width,
                                             int height);

cairo_image_surface_create_for_data ()

cairo_surface_t* cairo_image_surface_create_for_data
                                            (char *data,
                                             cairo_format_t format,
                                             int width,
                                             int height,
                                             int stride);