Struct gsk4::Transform

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

Transform is an object to describe transform matrices.

Unlike graphene::Matrix, Transform retains the steps in how a transform was constructed, and allows inspecting them. It is modeled after the way CSS describes transforms.

Transform objects are immutable and cannot be changed after creation. This means code can safely expose them as properties of objects without having to worry about others changing them.

Implementations

impl Transform

pub fn as_ptr(&self) -> *mut GskTransform

Return the inner pointer to the underlying C value.

impl Transform

pub fn new() -> Transform

pub fn category(&self) -> TransformCategory

Returns the category this transform belongs to.

Returns

The category of the transform

pub fn matrix(&self, matrix: &Matrix) -> Transform

Multiplies @self with the given @matrix.

matrix

the matrix to multiply @self with

Returns

The new transform

pub fn perspective(&self, depth: f32) -> Transform

Applies a perspective projection transform.

This transform scales points in X and Y based on their Z value, scaling points with positive Z values away from the origin, and those with negative Z values towards the origin. Points on the z=0 plane are unchanged.

depth

distance of the z=0 plane. Lower values give a more flattened pyramid and therefore a more pronounced perspective effect.

Returns

The new transform

pub fn to_2d(&self) -> (f32, f32, f32, f32, f32, f32)

Converts a Transform to a 2D transformation matrix.

@self must be a 2D transformation. If you are not sure, use gsk_transform_get_category() >= TransformCategory::_2d to check.

The returned values have the following layout:

  | xx yx |   |  a  b  0 |
  | xy yy | = |  c  d  0 |
  | dx dy |   | tx ty  1 |

This function can be used to convert between a Transform and a matrix type from other 2D drawing libraries, in particular Cairo.

Returns

out_xx

return location for the xx member

out_yx

return location for the yx member

out_xy

return location for the xy member

out_yy

return location for the yy member

out_dx

return location for the x0 member

out_dy

return location for the y0 member

pub fn to_2d_components(&self) -> (f32, f32, f32, f32, f32, f32, f32)

Available on crate feature v4_6 only.

Converts a Transform to 2D transformation factors.

To recreate an equivalent transform from the factors returned by this function, use

gsk_transform_skew (
    gsk_transform_scale (
        gsk_transform_rotate (
            gsk_transform_translate (NULL, &GRAPHENE_POINT_T (dx, dy)),
            angle),
        scale_x, scale_y),
    skew_x, skew_y)

@self must be a 2D transformation. If you are not sure, use

gsk_transform_get_category() >= [`TransformCategory::_2d`][crate::TransformCategory::_2d]

to check.

Returns

out_skew_x

return location for the skew factor in the x direction

out_skew_y

return location for the skew factor in the y direction

out_scale_x

return location for the scale factor in the x direction

out_scale_y

return location for the scale factor in the y direction

out_angle

return location for the rotation angle

out_dx

return location for the translation in the x direction

out_dy

return location for the translation in the y direction

pub fn to_affine(&self) -> (f32, f32, f32, f32)

Converts a Transform to 2D affine transformation factors.

To recreate an equivalent transform from the factors returned by this function, use

gsk_transform_scale (gsk_transform_translate (NULL,
                                              &GRAPHENE_POINT_T (dx, dy)),
                     sx, sy)

@self must be a 2D affine transformation. If you are not sure, use

gsk_transform_get_category() >= [`TransformCategory::_2dAffine`][crate::TransformCategory::_2dAffine]

to check.

Returns

out_scale_x

return location for the scale factor in the x direction

out_scale_y

return location for the scale factor in the y direction

out_dx

return location for the translation in the x direction

out_dy

return location for the translation in the y direction

pub fn to_matrix(&self) -> Matrix

Computes the actual value of @self and stores it in @out_matrix.

The previous value of @out_matrix will be ignored.

Returns

out_matrix

The matrix to set

pub fn to_str(&self) -> GString

Converts a matrix into a string that is suitable for printing.

The resulting string can be parsed with parse().

This is a wrapper around Gsk::Transform::print().

Returns

A new string for @self

pub fn to_translate(&self) -> (f32, f32)

Converts a Transform to a translation operation.

@self must be a 2D transformation. If you are not sure, use

gsk_transform_get_category() >= [`TransformCategory::_2dTranslate`][crate::TransformCategory::_2dTranslate]

to check.

Returns

out_dx

return location for the translation in the x direction

out_dy

return location for the translation in the y direction

pub fn transform_bounds(&self, rect: &Rect) -> Rect

Transforms a graphene::Rect using the given transform @self.

The result is the bounding box containing the coplanar quad.

rect

a graphene::Rect

Returns

out_rect

return location for the bounds of the transformed rectangle

pub fn transform_point(&self, point: &Point) -> Point

Transforms a graphene::Point using the given transform @self.

point

a graphene::Point

Returns

out_point

return location for the transformed point

impl Transform

pub fn parse(string: &str) -> Result<Self, BoolError>

Parses the given @string into a transform and puts it in @out_transform.

Strings printed via to_str() can be read in again successfully using this function.

If @string does not describe a valid transform, false is returned and None is put in @out_transform.

string

the string to parse

Returns

true if @string described a valid transform.

out_transform

The location to put the transform in

pub fn invert(&self) -> Result<Self, BoolError>

Inverts the given transform.

If @self is not invertible, None is returned. Note that inverting None also returns None, which is the correct inverse of None. If you need to differentiate between those cases, you should check @self is not None before calling this function.

Returns

The inverted transform

pub fn rotate(&self, angle: f32) -> Self

Rotates @self @angle degrees in 2D - or in 3D-speak, around the z axis.

angle

the rotation angle, in degrees (clockwise)

Returns

The new transform

pub fn rotate_3d(&self, angle: f32, axis: &Vec3) -> Self

Rotates @self @angle degrees around @axis.

For a rotation in 2D space, use rotate()

angle

the rotation angle, in degrees (clockwise)

axis

The rotation axis

Returns

The new transform

pub fn scale(&self, factor_x: f32, factor_y: f32) -> Self

Scales @self in 2-dimensional space by the given factors.

Use scale_3d() to scale in all 3 dimensions.

factor_x

scaling factor on the X axis

factor_y

scaling factor on the Y axis

Returns

The new transform

pub fn scale_3d(&self, factor_x: f32, factor_y: f32, factor_z: f32) -> Self

Scales @self by the given factors.

factor_x

scaling factor on the X axis

factor_y

scaling factor on the Y axis

factor_z

scaling factor on the Z axis

Returns

The new transform

pub fn skew(&self, skew_x: f32, skew_y: f32) -> Self

Available on crate feature v4_6 only.

Applies a skew transform.

skew_x

skew factor, in degrees, on the X axis

skew_y

skew factor, in degrees, on the Y axis

Returns

The new transform

pub fn transform(&self, other: Option<&Self>) -> Self

Applies all the operations from @other to @self.

other

Transform to apply

Returns

The new transform

pub fn translate(&self, point: &Point) -> Self

Translates @self in 2-dimensional space by @point.

point

the point to translate the transform by

Returns

The new transform

pub fn translate_3d(&self, point: &Point3D) -> Self

Translates @self by @point.

point

the point to translate the transform by

Returns

The new transform

Trait Implementations

impl Clone for Transform

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 Transform

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

Formats the value using the given formatter.

impl Default for Transform

fn default() -> Self

Returns the “default value” for a type.

impl Display for Transform

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

Formats the value using the given formatter.

impl FromStr for Transform

type Err = BoolError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl Hash for Transform

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)where
    H: Hasher,
    Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for Transform

fn cmp(&self, other: &Transform) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Selfwhere
    Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Selfwhere
    Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Selfwhere
    Self: Sized + PartialOrd<Self>,

Restrict a value to a certain interval.

impl PartialEq<Transform> for Transform

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd<Transform> for Transform

fn partial_cmp(&self, other: &Transform) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl StaticType for Transform

fn static_type() -> Type

Returns the type identifier of Self.

impl Eq for Transform