1use crate::{ffi, Unit};
6use glib::translate::*;
7
8glib::wrapper! {
9 #[derive(Debug, PartialOrd, Ord, Hash)]
10 pub struct PaperSize(Boxed<ffi::GtkPaperSize>);
11
12 match fn {
13 copy => |ptr| ffi::gtk_paper_size_copy(mut_override(ptr)),
14 free => |ptr| ffi::gtk_paper_size_free(ptr),
15 type_ => || ffi::gtk_paper_size_get_type(),
16 }
17}
18
19impl PaperSize {
20 #[doc(alias = "gtk_paper_size_new")]
21 pub fn new(name: Option<&str>) -> PaperSize {
22 assert_initialized_main_thread!();
23 unsafe { from_glib_full(ffi::gtk_paper_size_new(name.to_glib_none().0)) }
24 }
25
26 #[doc(alias = "gtk_paper_size_new_custom")]
27 pub fn new_custom(
28 name: &str,
29 display_name: &str,
30 width: f64,
31 height: f64,
32 unit: Unit,
33 ) -> PaperSize {
34 assert_initialized_main_thread!();
35 unsafe {
36 from_glib_full(ffi::gtk_paper_size_new_custom(
37 name.to_glib_none().0,
38 display_name.to_glib_none().0,
39 width,
40 height,
41 unit.into_glib(),
42 ))
43 }
44 }
45
46 #[doc(alias = "gtk_paper_size_new_from_gvariant")]
47 #[doc(alias = "new_from_gvariant")]
48 pub fn from_gvariant(variant: &glib::Variant) -> PaperSize {
49 assert_initialized_main_thread!();
50 unsafe {
51 from_glib_full(ffi::gtk_paper_size_new_from_gvariant(
52 variant.to_glib_none().0,
53 ))
54 }
55 }
56
57 #[doc(alias = "gtk_paper_size_new_from_ipp")]
58 #[doc(alias = "new_from_ipp")]
59 pub fn from_ipp(ipp_name: &str, width: f64, height: f64) -> PaperSize {
60 assert_initialized_main_thread!();
61 unsafe {
62 from_glib_full(ffi::gtk_paper_size_new_from_ipp(
63 ipp_name.to_glib_none().0,
64 width,
65 height,
66 ))
67 }
68 }
69
70 #[doc(alias = "gtk_paper_size_new_from_key_file")]
71 #[doc(alias = "new_from_key_file")]
72 pub fn from_key_file(
73 key_file: &glib::KeyFile,
74 group_name: Option<&str>,
75 ) -> Result<PaperSize, glib::Error> {
76 assert_initialized_main_thread!();
77 unsafe {
78 let mut error = std::ptr::null_mut();
79 let ret = ffi::gtk_paper_size_new_from_key_file(
80 key_file.to_glib_none().0,
81 group_name.to_glib_none().0,
82 &mut error,
83 );
84 if error.is_null() {
85 Ok(from_glib_full(ret))
86 } else {
87 Err(from_glib_full(error))
88 }
89 }
90 }
91
92 #[doc(alias = "gtk_paper_size_new_from_ppd")]
93 #[doc(alias = "new_from_ppd")]
94 pub fn from_ppd(ppd_name: &str, ppd_display_name: &str, width: f64, height: f64) -> PaperSize {
95 assert_initialized_main_thread!();
96 unsafe {
97 from_glib_full(ffi::gtk_paper_size_new_from_ppd(
98 ppd_name.to_glib_none().0,
99 ppd_display_name.to_glib_none().0,
100 width,
101 height,
102 ))
103 }
104 }
105
106 #[doc(alias = "gtk_paper_size_get_default_bottom_margin")]
107 #[doc(alias = "get_default_bottom_margin")]
108 pub fn default_bottom_margin(&self, unit: Unit) -> f64 {
109 unsafe {
110 ffi::gtk_paper_size_get_default_bottom_margin(
111 mut_override(self.to_glib_none().0),
112 unit.into_glib(),
113 )
114 }
115 }
116
117 #[doc(alias = "gtk_paper_size_get_default_left_margin")]
118 #[doc(alias = "get_default_left_margin")]
119 pub fn default_left_margin(&self, unit: Unit) -> f64 {
120 unsafe {
121 ffi::gtk_paper_size_get_default_left_margin(
122 mut_override(self.to_glib_none().0),
123 unit.into_glib(),
124 )
125 }
126 }
127
128 #[doc(alias = "gtk_paper_size_get_default_right_margin")]
129 #[doc(alias = "get_default_right_margin")]
130 pub fn default_right_margin(&self, unit: Unit) -> f64 {
131 unsafe {
132 ffi::gtk_paper_size_get_default_right_margin(
133 mut_override(self.to_glib_none().0),
134 unit.into_glib(),
135 )
136 }
137 }
138
139 #[doc(alias = "gtk_paper_size_get_default_top_margin")]
140 #[doc(alias = "get_default_top_margin")]
141 pub fn default_top_margin(&self, unit: Unit) -> f64 {
142 unsafe {
143 ffi::gtk_paper_size_get_default_top_margin(
144 mut_override(self.to_glib_none().0),
145 unit.into_glib(),
146 )
147 }
148 }
149
150 #[doc(alias = "gtk_paper_size_get_display_name")]
151 #[doc(alias = "get_display_name")]
152 pub fn display_name(&self) -> glib::GString {
153 unsafe {
154 from_glib_none(ffi::gtk_paper_size_get_display_name(mut_override(
155 self.to_glib_none().0,
156 )))
157 }
158 }
159
160 #[doc(alias = "gtk_paper_size_get_height")]
161 #[doc(alias = "get_height")]
162 pub fn height(&self, unit: Unit) -> f64 {
163 unsafe {
164 ffi::gtk_paper_size_get_height(mut_override(self.to_glib_none().0), unit.into_glib())
165 }
166 }
167
168 #[doc(alias = "gtk_paper_size_get_name")]
169 #[doc(alias = "get_name")]
170 pub fn name(&self) -> glib::GString {
171 unsafe {
172 from_glib_none(ffi::gtk_paper_size_get_name(mut_override(
173 self.to_glib_none().0,
174 )))
175 }
176 }
177
178 #[doc(alias = "gtk_paper_size_get_ppd_name")]
179 #[doc(alias = "get_ppd_name")]
180 pub fn ppd_name(&self) -> glib::GString {
181 unsafe {
182 from_glib_none(ffi::gtk_paper_size_get_ppd_name(mut_override(
183 self.to_glib_none().0,
184 )))
185 }
186 }
187
188 #[doc(alias = "gtk_paper_size_get_width")]
189 #[doc(alias = "get_width")]
190 pub fn width(&self, unit: Unit) -> f64 {
191 unsafe {
192 ffi::gtk_paper_size_get_width(mut_override(self.to_glib_none().0), unit.into_glib())
193 }
194 }
195
196 #[doc(alias = "gtk_paper_size_is_custom")]
197 pub fn is_custom(&self) -> bool {
198 unsafe {
199 from_glib(ffi::gtk_paper_size_is_custom(mut_override(
200 self.to_glib_none().0,
201 )))
202 }
203 }
204
205 #[doc(alias = "gtk_paper_size_is_equal")]
206 fn is_equal(&self, size2: &PaperSize) -> bool {
207 unsafe {
208 from_glib(ffi::gtk_paper_size_is_equal(
209 mut_override(self.to_glib_none().0),
210 mut_override(size2.to_glib_none().0),
211 ))
212 }
213 }
214
215 #[doc(alias = "gtk_paper_size_is_ipp")]
216 pub fn is_ipp(&self) -> bool {
217 unsafe {
218 from_glib(ffi::gtk_paper_size_is_ipp(mut_override(
219 self.to_glib_none().0,
220 )))
221 }
222 }
223
224 #[doc(alias = "gtk_paper_size_set_size")]
225 pub fn set_size(&mut self, width: f64, height: f64, unit: Unit) {
226 unsafe {
227 ffi::gtk_paper_size_set_size(
228 self.to_glib_none_mut().0,
229 width,
230 height,
231 unit.into_glib(),
232 );
233 }
234 }
235
236 #[doc(alias = "gtk_paper_size_to_gvariant")]
237 pub fn to_gvariant(&mut self) -> glib::Variant {
238 unsafe { from_glib_none(ffi::gtk_paper_size_to_gvariant(self.to_glib_none_mut().0)) }
239 }
240
241 #[doc(alias = "gtk_paper_size_to_key_file")]
242 pub fn to_key_file(&mut self, key_file: &glib::KeyFile, group_name: &str) {
243 unsafe {
244 ffi::gtk_paper_size_to_key_file(
245 self.to_glib_none_mut().0,
246 key_file.to_glib_none().0,
247 group_name.to_glib_none().0,
248 );
249 }
250 }
251
252 #[doc(alias = "gtk_paper_size_get_default")]
253 #[doc(alias = "get_default")]
254 #[allow(clippy::should_implement_trait)]
255 pub fn default() -> glib::GString {
256 assert_initialized_main_thread!();
257 unsafe { from_glib_none(ffi::gtk_paper_size_get_default()) }
258 }
259
260 #[doc(alias = "gtk_paper_size_get_paper_sizes")]
261 #[doc(alias = "get_paper_sizes")]
262 pub fn paper_sizes(include_custom: bool) -> Vec<PaperSize> {
263 assert_initialized_main_thread!();
264 unsafe {
265 FromGlibPtrContainer::from_glib_full(ffi::gtk_paper_size_get_paper_sizes(
266 include_custom.into_glib(),
267 ))
268 }
269 }
270}
271
272impl PartialEq for PaperSize {
273 #[inline]
274 fn eq(&self, other: &Self) -> bool {
275 self.is_equal(other)
276 }
277}
278
279impl Eq for PaperSize {}
280
281impl std::fmt::Display for PaperSize {
282 #[inline]
283 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
284 f.write_str(&self.name())
285 }
286}