1use crate::{ffi, TransformCategory};
6use glib::translate::*;
7
8glib::wrapper! {
9 #[derive(Debug, PartialOrd, Ord, Hash)]
10 pub struct Transform(Shared<ffi::GskTransform>);
11
12 match fn {
13 ref => |ptr| ffi::gsk_transform_ref(ptr),
14 unref => |ptr| ffi::gsk_transform_unref(ptr),
15 type_ => || ffi::gsk_transform_get_type(),
16 }
17}
18
19impl Transform {
20 #[doc(alias = "gsk_transform_new")]
21 pub fn new() -> Transform {
22 assert_initialized_main_thread!();
23 unsafe { from_glib_full(ffi::gsk_transform_new()) }
24 }
25
26 #[doc(alias = "gsk_transform_equal")]
27 fn equal(&self, second: &Transform) -> bool {
28 unsafe {
29 from_glib(ffi::gsk_transform_equal(
30 self.to_glib_none().0,
31 second.to_glib_none().0,
32 ))
33 }
34 }
35
36 #[doc(alias = "gsk_transform_get_category")]
37 #[doc(alias = "get_category")]
38 pub fn category(&self) -> TransformCategory {
39 unsafe { from_glib(ffi::gsk_transform_get_category(self.to_glib_none().0)) }
40 }
41
42 #[doc(alias = "gsk_transform_matrix")]
43 #[must_use]
44 pub fn matrix(self, matrix: &graphene::Matrix) -> Transform {
45 unsafe {
46 from_glib_full(ffi::gsk_transform_matrix(
47 self.into_glib_ptr(),
48 matrix.to_glib_none().0,
49 ))
50 }
51 }
52
53 #[doc(alias = "gsk_transform_perspective")]
54 #[must_use]
55 pub fn perspective(self, depth: f32) -> Transform {
56 unsafe { from_glib_full(ffi::gsk_transform_perspective(self.into_glib_ptr(), depth)) }
57 }
58
59 #[doc(alias = "gsk_transform_to_2d")]
60 pub fn to_2d(&self) -> (f32, f32, f32, f32, f32, f32) {
61 unsafe {
62 let mut out_xx = std::mem::MaybeUninit::uninit();
63 let mut out_yx = std::mem::MaybeUninit::uninit();
64 let mut out_xy = std::mem::MaybeUninit::uninit();
65 let mut out_yy = std::mem::MaybeUninit::uninit();
66 let mut out_dx = std::mem::MaybeUninit::uninit();
67 let mut out_dy = std::mem::MaybeUninit::uninit();
68 ffi::gsk_transform_to_2d(
69 self.to_glib_none().0,
70 out_xx.as_mut_ptr(),
71 out_yx.as_mut_ptr(),
72 out_xy.as_mut_ptr(),
73 out_yy.as_mut_ptr(),
74 out_dx.as_mut_ptr(),
75 out_dy.as_mut_ptr(),
76 );
77 (
78 out_xx.assume_init(),
79 out_yx.assume_init(),
80 out_xy.assume_init(),
81 out_yy.assume_init(),
82 out_dx.assume_init(),
83 out_dy.assume_init(),
84 )
85 }
86 }
87
88 #[cfg(feature = "v4_6")]
89 #[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
90 #[doc(alias = "gsk_transform_to_2d_components")]
91 pub fn to_2d_components(&self) -> (f32, f32, f32, f32, f32, f32, f32) {
92 unsafe {
93 let mut out_skew_x = std::mem::MaybeUninit::uninit();
94 let mut out_skew_y = std::mem::MaybeUninit::uninit();
95 let mut out_scale_x = std::mem::MaybeUninit::uninit();
96 let mut out_scale_y = std::mem::MaybeUninit::uninit();
97 let mut out_angle = std::mem::MaybeUninit::uninit();
98 let mut out_dx = std::mem::MaybeUninit::uninit();
99 let mut out_dy = std::mem::MaybeUninit::uninit();
100 ffi::gsk_transform_to_2d_components(
101 self.to_glib_none().0,
102 out_skew_x.as_mut_ptr(),
103 out_skew_y.as_mut_ptr(),
104 out_scale_x.as_mut_ptr(),
105 out_scale_y.as_mut_ptr(),
106 out_angle.as_mut_ptr(),
107 out_dx.as_mut_ptr(),
108 out_dy.as_mut_ptr(),
109 );
110 (
111 out_skew_x.assume_init(),
112 out_skew_y.assume_init(),
113 out_scale_x.assume_init(),
114 out_scale_y.assume_init(),
115 out_angle.assume_init(),
116 out_dx.assume_init(),
117 out_dy.assume_init(),
118 )
119 }
120 }
121
122 #[doc(alias = "gsk_transform_to_affine")]
123 pub fn to_affine(&self) -> (f32, f32, f32, f32) {
124 unsafe {
125 let mut out_scale_x = std::mem::MaybeUninit::uninit();
126 let mut out_scale_y = std::mem::MaybeUninit::uninit();
127 let mut out_dx = std::mem::MaybeUninit::uninit();
128 let mut out_dy = std::mem::MaybeUninit::uninit();
129 ffi::gsk_transform_to_affine(
130 self.to_glib_none().0,
131 out_scale_x.as_mut_ptr(),
132 out_scale_y.as_mut_ptr(),
133 out_dx.as_mut_ptr(),
134 out_dy.as_mut_ptr(),
135 );
136 (
137 out_scale_x.assume_init(),
138 out_scale_y.assume_init(),
139 out_dx.assume_init(),
140 out_dy.assume_init(),
141 )
142 }
143 }
144
145 #[doc(alias = "gsk_transform_to_matrix")]
146 pub fn to_matrix(&self) -> graphene::Matrix {
147 unsafe {
148 let mut out_matrix = graphene::Matrix::uninitialized();
149 ffi::gsk_transform_to_matrix(self.to_glib_none().0, out_matrix.to_glib_none_mut().0);
150 out_matrix
151 }
152 }
153
154 #[doc(alias = "gsk_transform_to_string")]
155 #[doc(alias = "to_string")]
156 pub fn to_str(&self) -> glib::GString {
157 unsafe { from_glib_full(ffi::gsk_transform_to_string(self.to_glib_none().0)) }
158 }
159
160 #[doc(alias = "gsk_transform_to_translate")]
161 pub fn to_translate(&self) -> (f32, f32) {
162 unsafe {
163 let mut out_dx = std::mem::MaybeUninit::uninit();
164 let mut out_dy = std::mem::MaybeUninit::uninit();
165 ffi::gsk_transform_to_translate(
166 self.to_glib_none().0,
167 out_dx.as_mut_ptr(),
168 out_dy.as_mut_ptr(),
169 );
170 (out_dx.assume_init(), out_dy.assume_init())
171 }
172 }
173
174 #[doc(alias = "gsk_transform_transform_bounds")]
175 pub fn transform_bounds(&self, rect: &graphene::Rect) -> graphene::Rect {
176 unsafe {
177 let mut out_rect = graphene::Rect::uninitialized();
178 ffi::gsk_transform_transform_bounds(
179 self.to_glib_none().0,
180 rect.to_glib_none().0,
181 out_rect.to_glib_none_mut().0,
182 );
183 out_rect
184 }
185 }
186
187 #[doc(alias = "gsk_transform_transform_point")]
188 pub fn transform_point(&self, point: &graphene::Point) -> graphene::Point {
189 unsafe {
190 let mut out_point = graphene::Point::uninitialized();
191 ffi::gsk_transform_transform_point(
192 self.to_glib_none().0,
193 point.to_glib_none().0,
194 out_point.to_glib_none_mut().0,
195 );
196 out_point
197 }
198 }
199}
200
201impl Default for Transform {
202 fn default() -> Self {
203 Self::new()
204 }
205}
206
207impl PartialEq for Transform {
208 #[inline]
209 fn eq(&self, other: &Self) -> bool {
210 self.equal(other)
211 }
212}
213
214impl Eq for Transform {}
215
216impl std::fmt::Display for Transform {
217 #[inline]
218 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
219 f.write_str(&self.to_str())
220 }
221}