cairo_matrix_t

typedef struct _cairo_matrix cairo_matrix_t;

cairo_matrix_create ()

cairo_matrix_t* cairo_matrix_create         (void);

Creates a new identity matrix.

>

cairo_matrix_destroy ()

void        cairo_matrix_destroy            (cairo_matrix_t *matrix);

Frees a matrix created with cairo_matrix_create.

cairo_matrix_copy ()

cairo_status_t cairo_matrix_copy            (cairo_matrix_t *matrix,
                                             const cairo_matrix_t *other);

Modifies matrix to be identical to other.

cairo_matrix_set_identity ()

cairo_status_t cairo_matrix_set_identity    (cairo_matrix_t *matrix);

Modifies matrix to be an identity transformation.

cairo_matrix_set_affine ()

cairo_status_t cairo_matrix_set_affine      (cairo_matrix_t *matrix,
                                             double a,
                                             double b,
                                             double c,
                                             double d,
                                             double tx,
                                             double ty);

Sets matrix to be the affine transformation given by a, b, c, d, tx, ty. The transformation is given by:

 x_new = x * a + y * c + tx;
 y_new = x * b + y * d + ty;

cairo_matrix_get_affine ()

cairo_status_t cairo_matrix_get_affine      (cairo_matrix_t *matrix,
                                             double *a,
                                             double *b,
                                             double *c,
                                             double *d,
                                             double *tx,
                                             double *ty);

Gets the matrix values for the affine tranformation that matrix represents. See cairo_matrix_set_affine().

cairo_matrix_translate ()

cairo_status_t cairo_matrix_translate       (cairo_matrix_t *matrix,
                                             double tx,
                                             double ty);

Applies a translation by tx, ty to the transformation in matrix. The new transformation is given by first translating by tx, ty then applying the original transformation

cairo_matrix_scale ()

cairo_status_t cairo_matrix_scale           (cairo_matrix_t *matrix,
                                             double sx,
                                             double sy);

Applies scaling by tx, ty to the transformation in matrix. The new transformation is given by first scaling by sx and sy then applying the original transformation

cairo_matrix_rotate ()

cairo_status_t cairo_matrix_rotate          (cairo_matrix_t *matrix,
                                             double radians);

Applies rotation by radians to the transformation in matrix. The new transformation is given by first rotating by radians then applying the original transformation

cairo_matrix_invert ()

cairo_status_t cairo_matrix_invert          (cairo_matrix_t *matrix);

Changes matrix to be the inverse of it's original value. Not all transformation matrices have inverses; if the matrix collapses points together (it is degenerate), then it has no inverse and this function will fail.

Returns: If matrix has an inverse, modifies matrix to be the inverse matrix and returns CAIRO_STATUS_SUCCESS. Otherwise,

cairo_matrix_multiply ()

cairo_status_t cairo_matrix_multiply        (cairo_matrix_t *result,
                                             const cairo_matrix_t *a,
                                             const cairo_matrix_t *b);

Multiplies the affine transformations in a and b together and stores the result in result. The resulting transformation is given by first applying the transformation in b then applying the transformation in a.

cairo_matrix_transform_distance ()

cairo_status_t cairo_matrix_transform_distance
                                            (cairo_matrix_t *matrix,
                                             double *dx,
                                             double *dy);

Transforms the vector (dx,dy) by matrix. Translation is ignored. In terms of the components of the affine transformation:

dx2 = dx1 * a + dy1 * c;
dy2 = dx1 * b + dy1 * d;

Affine transformations are position invariant, so the same vector always transforms to the same vector. If (x1,y1) transforms to (x2,y2) then (x1+dx1,y1+dy1) will transform to (x1+dx2,y1+dy2) for all values of x1 and x2.

cairo_matrix_transform_point ()

cairo_status_t cairo_matrix_transform_point (cairo_matrix_t *matrix,
                                             double *x,
                                             double *y);

Transforms the point (x, y) by matrix.