Struct pango::Matrix

#[repr(transparent)]
pub struct Matrix { /* private fields */ }

A Matrix specifies a transformation between user-space and device coordinates.

The transformation is given by

x_device = x_user * matrix->xx + y_user * matrix->xy + matrix->x0;
y_device = x_user * matrix->yx + y_user * matrix->yy + matrix->y0;

Implementations

impl Matrix

pub fn concat(&mut self, new_matrix: &Matrix)

Changes the transformation represented by @self to be the transformation given by first applying transformation given by @new_matrix then applying the original transformation.

new_matrix

a Matrix

pub fn font_scale_factor(&self) -> f64

Returns the scale factor of a matrix on the height of the font.

That is, the scale factor in the direction perpendicular to the vector that the X coordinate is mapped to. If the scale in the X coordinate is needed as well, use font_scale_factors().

Returns

the scale factor of @self on the height of the font, or 1.0 if @self is None.

pub fn font_scale_factors(&self) -> (f64, f64)

Calculates the scale factor of a matrix on the width and height of the font.

That is, @xscale is the scale factor in the direction of the X coordinate, and @yscale is the scale factor in the direction perpendicular to the vector that the X coordinate is mapped to.

Note that output numbers will always be non-negative.

Returns

xscale

output scale factor in the x direction

yscale

output scale factor perpendicular to the x direction

pub fn slant_ratio(&self) -> f64

Available on crate feature v1_50 only.

Gets the slant ratio of a matrix.

For a simple shear matrix in the form:

1 λ
0 1

this is simply λ.

Returns

the slant ratio of @self

pub fn rotate(&mut self, degrees: f64)

Changes the transformation represented by @self to be the transformation given by first rotating by @degrees degrees counter-clockwise then applying the original transformation.

degrees

degrees to rotate counter-clockwise

pub fn scale(&mut self, scale_x: f64, scale_y: f64)

Changes the transformation represented by @self to be the transformation given by first scaling by @sx in the X direction and @sy in the Y direction then applying the original transformation.

scale_x

amount to scale by in X direction

scale_y

amount to scale by in Y direction

pub fn transform_distance(&self, dx: &mut f64, dy: &mut f64)

Transforms the distance vector (@dx,@dy) by @self.

This is similar to transform_point(), except that the translation components of the transformation are ignored. The calculation of the returned vector is as follows:

dx2 = dx1 * xx + dy1 * xy;
dy2 = dx1 * yx + dy1 * yy;

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.

dx

in/out X component of a distance vector

dy

in/out Y component of a distance vector

pub fn transform_point(&self, x: &mut f64, y: &mut f64)

Transforms the point (@x, @y) by @self.

x

in/out X position

y

in/out Y position

pub fn translate(&mut self, tx: f64, ty: f64)

Changes the transformation represented by @self to be the transformation given by first translating by (@tx, @ty) then applying the original transformation.

tx

amount to translate in the X direction

ty

amount to translate in the Y direction

impl Matrix

pub fn new(xx: f64, xy: f64, yx: f64, yy: f64, x0: f64, y0: f64) -> Self

pub fn transform_pixel_rectangle(&self, rect: &mut Rectangle)

First transforms the @rect using @self, then calculates the bounding box of the transformed rectangle.

This function is useful for example when you want to draw a rotated @PangoLayout to an image buffer, and want to know how large the image should be and how much you should shift the layout when rendering.

For better accuracy, you should use transform_rectangle() on original rectangle in Pango units and convert to pixels afterward using extents_to_pixels()’s first argument.

rect

in/out bounding box in device units

pub fn transform_rectangle(&self, rect: &mut Rectangle)

First transforms @rect using @self, then calculates the bounding box of the transformed rectangle.

This function is useful for example when you want to draw a rotated @PangoLayout to an image buffer, and want to know how large the image should be and how much you should shift the layout when rendering.

If you have a rectangle in device units (pixels), use transform_pixel_rectangle().

If you have the rectangle in Pango units and want to convert to transformed pixel bounding box, it is more accurate to transform it first (using this function) and pass the result to pango_extents_to_pixels(), first argument, for an inclusive rounded rectangle. However, there are valid reasons that you may want to convert to pixels first and then transform, for example when the transformed coordinates may overflow in Pango units (large matrix translation for example).

rect

in/out bounding box in Pango units

pub fn xx(&self) -> f64

pub fn xy(&self) -> f64

pub fn yx(&self) -> f64

pub fn yy(&self) -> f64

pub fn x0(&self) -> f64

pub fn y0(&self) -> f64

Trait Implementations

impl Clone for Matrix

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Matrix

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl StaticType for Matrix

fn static_type() -> Type

Returns the type identifier of Self.

impl Copy for Matrix