1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185

// This file was generated by gir (https://github.com/gtk-rs/gir)
// from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT

use glib::translate::*;
use std::mem;

glib::wrapper! {
    /// A [`Matrix`][crate::Matrix] specifies a transformation between user-space
    /// and device coordinates.
    ///
    /// The transformation is given by
    ///
    /// ```text
    /// x_device = x_user * matrix->xx + y_user * matrix->xy + matrix->x0;
    /// y_device = x_user * matrix->yx + y_user * matrix->yy + matrix->y0;
    /// ```
    pub struct Matrix(BoxedInline<ffi::PangoMatrix>);

    match fn {
        copy => |ptr| ffi::pango_matrix_copy(ptr),
        free => |ptr| ffi::pango_matrix_free(ptr),
        type_ => || ffi::pango_matrix_get_type(),
    }
}

impl 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`][crate::Matrix]
    #[doc(alias = "pango_matrix_concat")]
    pub fn concat(&mut self, new_matrix: &Matrix) {
        unsafe {
            ffi::pango_matrix_concat(self.to_glib_none_mut().0, new_matrix.to_glib_none().0);
        }
    }

    /// 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()`][Self::font_scale_factors()].
    ///
    /// # Returns
    ///
    /// the scale factor of @self on the height of the font,
    ///   or 1.0 if @self is [`None`].
    #[doc(alias = "pango_matrix_get_font_scale_factor")]
    #[doc(alias = "get_font_scale_factor")]
    pub fn font_scale_factor(&self) -> f64 {
        unsafe { ffi::pango_matrix_get_font_scale_factor(self.to_glib_none().0) }
    }

    /// 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
    #[doc(alias = "pango_matrix_get_font_scale_factors")]
    #[doc(alias = "get_font_scale_factors")]
    pub fn font_scale_factors(&self) -> (f64, f64) {
        unsafe {
            let mut xscale = mem::MaybeUninit::uninit();
            let mut yscale = mem::MaybeUninit::uninit();
            ffi::pango_matrix_get_font_scale_factors(
                self.to_glib_none().0,
                xscale.as_mut_ptr(),
                yscale.as_mut_ptr(),
            );
            (xscale.assume_init(), yscale.assume_init())
        }
    }

    /// 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
    #[cfg(feature = "v1_50")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_50")))]
    #[doc(alias = "pango_matrix_get_slant_ratio")]
    #[doc(alias = "get_slant_ratio")]
    pub fn slant_ratio(&self) -> f64 {
        unsafe { ffi::pango_matrix_get_slant_ratio(self.to_glib_none().0) }
    }

    /// 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
    #[doc(alias = "pango_matrix_rotate")]
    pub fn rotate(&mut self, degrees: f64) {
        unsafe {
            ffi::pango_matrix_rotate(self.to_glib_none_mut().0, degrees);
        }
    }

    /// 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
    #[doc(alias = "pango_matrix_scale")]
    pub fn scale(&mut self, scale_x: f64, scale_y: f64) {
        unsafe {
            ffi::pango_matrix_scale(self.to_glib_none_mut().0, scale_x, scale_y);
        }
    }

    /// Transforms the distance vector (@dx,@dy) by @self.
    ///
    /// This is similar to [`transform_point()`][Self::transform_point()],
    /// except that the translation components of the transformation
    /// are ignored. The calculation of the returned vector is as follows:
    ///
    /// ```text
    /// 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
    #[doc(alias = "pango_matrix_transform_distance")]
    pub fn transform_distance(&self, dx: &mut f64, dy: &mut f64) {
        unsafe {
            ffi::pango_matrix_transform_distance(self.to_glib_none().0, dx, dy);
        }
    }

    /// Transforms the point (@x, @y) by @self.
    /// ## `x`
    /// in/out X position
    /// ## `y`
    /// in/out Y position
    #[doc(alias = "pango_matrix_transform_point")]
    pub fn transform_point(&self, x: &mut f64, y: &mut f64) {
        unsafe {
            ffi::pango_matrix_transform_point(self.to_glib_none().0, x, y);
        }
    }

    /// 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
    #[doc(alias = "pango_matrix_translate")]
    pub fn translate(&mut self, tx: f64, ty: f64) {
        unsafe {
            ffi::pango_matrix_translate(self.to_glib_none_mut().0, tx, ty);
        }
    }
}