1use crate::{
6 NumberUpLayout, PageOrientation, PageRange, PageSet, PaperSize, PrintDuplex, PrintPages,
7 PrintQuality, Unit,
8};
9use glib::translate::*;
10use std::{fmt, mem, ptr};
11
12glib::wrapper! {
13 #[doc(alias = "GtkPrintSettings")]
14 pub struct PrintSettings(Object<ffi::GtkPrintSettings>);
15
16 match fn {
17 type_ => || ffi::gtk_print_settings_get_type(),
18 }
19}
20
21impl PrintSettings {
22 #[doc(alias = "gtk_print_settings_new")]
23 pub fn new() -> PrintSettings {
24 assert_initialized_main_thread!();
25 unsafe { from_glib_full(ffi::gtk_print_settings_new()) }
26 }
27
28 #[doc(alias = "gtk_print_settings_new_from_file")]
29 #[doc(alias = "new_from_file")]
30 pub fn from_file(file_name: impl AsRef<std::path::Path>) -> Result<PrintSettings, glib::Error> {
31 assert_initialized_main_thread!();
32 unsafe {
33 let mut error = ptr::null_mut();
34 let ret = ffi::gtk_print_settings_new_from_file(
35 file_name.as_ref().to_glib_none().0,
36 &mut error,
37 );
38 if error.is_null() {
39 Ok(from_glib_full(ret))
40 } else {
41 Err(from_glib_full(error))
42 }
43 }
44 }
45
46 #[doc(alias = "gtk_print_settings_new_from_gvariant")]
47 #[doc(alias = "new_from_gvariant")]
48 pub fn from_gvariant(variant: &glib::Variant) -> PrintSettings {
49 assert_initialized_main_thread!();
50 unsafe {
51 from_glib_full(ffi::gtk_print_settings_new_from_gvariant(
52 variant.to_glib_none().0,
53 ))
54 }
55 }
56
57 #[doc(alias = "gtk_print_settings_new_from_key_file")]
58 #[doc(alias = "new_from_key_file")]
59 pub fn from_key_file(
60 key_file: &glib::KeyFile,
61 group_name: Option<&str>,
62 ) -> Result<PrintSettings, glib::Error> {
63 assert_initialized_main_thread!();
64 unsafe {
65 let mut error = ptr::null_mut();
66 let ret = ffi::gtk_print_settings_new_from_key_file(
67 key_file.to_glib_none().0,
68 group_name.to_glib_none().0,
69 &mut error,
70 );
71 if error.is_null() {
72 Ok(from_glib_full(ret))
73 } else {
74 Err(from_glib_full(error))
75 }
76 }
77 }
78
79 #[doc(alias = "gtk_print_settings_copy")]
80 #[must_use]
81 pub fn copy(&self) -> Option<PrintSettings> {
82 unsafe { from_glib_full(ffi::gtk_print_settings_copy(self.to_glib_none().0)) }
83 }
84
85 #[doc(alias = "gtk_print_settings_foreach")]
86 pub fn foreach<P: FnMut(&str, &str)>(&self, func: P) {
87 let func_data: P = func;
88 unsafe extern "C" fn func_func<P: FnMut(&str, &str)>(
89 key: *const libc::c_char,
90 value: *const libc::c_char,
91 user_data: glib::ffi::gpointer,
92 ) {
93 let key: Borrowed<glib::GString> = from_glib_borrow(key);
94 let value: Borrowed<glib::GString> = from_glib_borrow(value);
95 let callback: *mut P = user_data as *const _ as usize as *mut P;
96 (*callback)(key.as_str(), value.as_str())
97 }
98 let func = Some(func_func::<P> as _);
99 let super_callback0: &P = &func_data;
100 unsafe {
101 ffi::gtk_print_settings_foreach(
102 self.to_glib_none().0,
103 func,
104 super_callback0 as *const _ as usize as *mut _,
105 );
106 }
107 }
108
109 #[doc(alias = "gtk_print_settings_get")]
110 pub fn get(&self, key: &str) -> Option<glib::GString> {
111 unsafe {
112 from_glib_none(ffi::gtk_print_settings_get(
113 self.to_glib_none().0,
114 key.to_glib_none().0,
115 ))
116 }
117 }
118
119 #[doc(alias = "gtk_print_settings_get_bool")]
120 #[doc(alias = "get_bool")]
121 pub fn bool(&self, key: &str) -> bool {
122 unsafe {
123 from_glib(ffi::gtk_print_settings_get_bool(
124 self.to_glib_none().0,
125 key.to_glib_none().0,
126 ))
127 }
128 }
129
130 #[doc(alias = "gtk_print_settings_get_collate")]
131 #[doc(alias = "get_collate")]
132 pub fn is_collate(&self) -> bool {
133 unsafe { from_glib(ffi::gtk_print_settings_get_collate(self.to_glib_none().0)) }
134 }
135
136 #[doc(alias = "gtk_print_settings_get_default_source")]
137 #[doc(alias = "get_default_source")]
138 pub fn default_source(&self) -> Option<glib::GString> {
139 unsafe {
140 from_glib_none(ffi::gtk_print_settings_get_default_source(
141 self.to_glib_none().0,
142 ))
143 }
144 }
145
146 #[doc(alias = "gtk_print_settings_get_dither")]
147 #[doc(alias = "get_dither")]
148 pub fn dither(&self) -> Option<glib::GString> {
149 unsafe { from_glib_none(ffi::gtk_print_settings_get_dither(self.to_glib_none().0)) }
150 }
151
152 #[doc(alias = "gtk_print_settings_get_double")]
153 #[doc(alias = "get_double")]
154 pub fn double(&self, key: &str) -> f64 {
155 unsafe { ffi::gtk_print_settings_get_double(self.to_glib_none().0, key.to_glib_none().0) }
156 }
157
158 #[doc(alias = "gtk_print_settings_get_double_with_default")]
159 #[doc(alias = "get_double_with_default")]
160 pub fn double_with_default(&self, key: &str, def: f64) -> f64 {
161 unsafe {
162 ffi::gtk_print_settings_get_double_with_default(
163 self.to_glib_none().0,
164 key.to_glib_none().0,
165 def,
166 )
167 }
168 }
169
170 #[doc(alias = "gtk_print_settings_get_duplex")]
171 #[doc(alias = "get_duplex")]
172 pub fn duplex(&self) -> PrintDuplex {
173 unsafe { from_glib(ffi::gtk_print_settings_get_duplex(self.to_glib_none().0)) }
174 }
175
176 #[doc(alias = "gtk_print_settings_get_finishings")]
177 #[doc(alias = "get_finishings")]
178 pub fn finishings(&self) -> Option<glib::GString> {
179 unsafe {
180 from_glib_none(ffi::gtk_print_settings_get_finishings(
181 self.to_glib_none().0,
182 ))
183 }
184 }
185
186 #[doc(alias = "gtk_print_settings_get_int")]
187 #[doc(alias = "get_int")]
188 pub fn int(&self, key: &str) -> i32 {
189 unsafe { ffi::gtk_print_settings_get_int(self.to_glib_none().0, key.to_glib_none().0) }
190 }
191
192 #[doc(alias = "gtk_print_settings_get_int_with_default")]
193 #[doc(alias = "get_int_with_default")]
194 pub fn int_with_default(&self, key: &str, def: i32) -> i32 {
195 unsafe {
196 ffi::gtk_print_settings_get_int_with_default(
197 self.to_glib_none().0,
198 key.to_glib_none().0,
199 def,
200 )
201 }
202 }
203
204 #[doc(alias = "gtk_print_settings_get_length")]
205 #[doc(alias = "get_length")]
206 pub fn length(&self, key: &str, unit: Unit) -> f64 {
207 unsafe {
208 ffi::gtk_print_settings_get_length(
209 self.to_glib_none().0,
210 key.to_glib_none().0,
211 unit.into_glib(),
212 )
213 }
214 }
215
216 #[doc(alias = "gtk_print_settings_get_media_type")]
217 #[doc(alias = "get_media_type")]
218 pub fn media_type(&self) -> Option<glib::GString> {
219 unsafe {
220 from_glib_none(ffi::gtk_print_settings_get_media_type(
221 self.to_glib_none().0,
222 ))
223 }
224 }
225
226 #[doc(alias = "gtk_print_settings_get_n_copies")]
227 #[doc(alias = "get_n_copies")]
228 pub fn n_copies(&self) -> i32 {
229 unsafe { ffi::gtk_print_settings_get_n_copies(self.to_glib_none().0) }
230 }
231
232 #[doc(alias = "gtk_print_settings_get_number_up")]
233 #[doc(alias = "get_number_up")]
234 pub fn number_up(&self) -> i32 {
235 unsafe { ffi::gtk_print_settings_get_number_up(self.to_glib_none().0) }
236 }
237
238 #[doc(alias = "gtk_print_settings_get_number_up_layout")]
239 #[doc(alias = "get_number_up_layout")]
240 pub fn number_up_layout(&self) -> NumberUpLayout {
241 unsafe {
242 from_glib(ffi::gtk_print_settings_get_number_up_layout(
243 self.to_glib_none().0,
244 ))
245 }
246 }
247
248 #[doc(alias = "gtk_print_settings_get_orientation")]
249 #[doc(alias = "get_orientation")]
250 pub fn orientation(&self) -> PageOrientation {
251 unsafe {
252 from_glib(ffi::gtk_print_settings_get_orientation(
253 self.to_glib_none().0,
254 ))
255 }
256 }
257
258 #[doc(alias = "gtk_print_settings_get_output_bin")]
259 #[doc(alias = "get_output_bin")]
260 pub fn output_bin(&self) -> Option<glib::GString> {
261 unsafe {
262 from_glib_none(ffi::gtk_print_settings_get_output_bin(
263 self.to_glib_none().0,
264 ))
265 }
266 }
267
268 #[doc(alias = "gtk_print_settings_get_page_ranges")]
269 #[doc(alias = "get_page_ranges")]
270 pub fn page_ranges(&self) -> Vec<PageRange> {
271 unsafe {
272 let mut num_ranges = mem::MaybeUninit::uninit();
273 let ret = FromGlibContainer::from_glib_full_num(
274 ffi::gtk_print_settings_get_page_ranges(
275 self.to_glib_none().0,
276 num_ranges.as_mut_ptr(),
277 ),
278 num_ranges.assume_init() as _,
279 );
280 ret
281 }
282 }
283
284 #[doc(alias = "gtk_print_settings_get_page_set")]
285 #[doc(alias = "get_page_set")]
286 pub fn page_set(&self) -> PageSet {
287 unsafe { from_glib(ffi::gtk_print_settings_get_page_set(self.to_glib_none().0)) }
288 }
289
290 #[doc(alias = "gtk_print_settings_get_paper_height")]
291 #[doc(alias = "get_paper_height")]
292 pub fn paper_height(&self, unit: Unit) -> f64 {
293 unsafe { ffi::gtk_print_settings_get_paper_height(self.to_glib_none().0, unit.into_glib()) }
294 }
295
296 #[doc(alias = "gtk_print_settings_get_paper_size")]
297 #[doc(alias = "get_paper_size")]
298 pub fn paper_size(&self) -> PaperSize {
299 unsafe {
300 from_glib_full(ffi::gtk_print_settings_get_paper_size(
301 self.to_glib_none().0,
302 ))
303 }
304 }
305
306 #[doc(alias = "gtk_print_settings_get_paper_width")]
307 #[doc(alias = "get_paper_width")]
308 pub fn paper_width(&self, unit: Unit) -> f64 {
309 unsafe { ffi::gtk_print_settings_get_paper_width(self.to_glib_none().0, unit.into_glib()) }
310 }
311
312 #[doc(alias = "gtk_print_settings_get_print_pages")]
313 #[doc(alias = "get_print_pages")]
314 pub fn print_pages(&self) -> PrintPages {
315 unsafe {
316 from_glib(ffi::gtk_print_settings_get_print_pages(
317 self.to_glib_none().0,
318 ))
319 }
320 }
321
322 #[doc(alias = "gtk_print_settings_get_printer")]
323 #[doc(alias = "get_printer")]
324 pub fn printer(&self) -> Option<glib::GString> {
325 unsafe { from_glib_none(ffi::gtk_print_settings_get_printer(self.to_glib_none().0)) }
326 }
327
328 #[doc(alias = "gtk_print_settings_get_printer_lpi")]
329 #[doc(alias = "get_printer_lpi")]
330 pub fn printer_lpi(&self) -> f64 {
331 unsafe { ffi::gtk_print_settings_get_printer_lpi(self.to_glib_none().0) }
332 }
333
334 #[doc(alias = "gtk_print_settings_get_quality")]
335 #[doc(alias = "get_quality")]
336 pub fn quality(&self) -> PrintQuality {
337 unsafe { from_glib(ffi::gtk_print_settings_get_quality(self.to_glib_none().0)) }
338 }
339
340 #[doc(alias = "gtk_print_settings_get_resolution")]
341 #[doc(alias = "get_resolution")]
342 pub fn resolution(&self) -> i32 {
343 unsafe { ffi::gtk_print_settings_get_resolution(self.to_glib_none().0) }
344 }
345
346 #[doc(alias = "gtk_print_settings_get_resolution_x")]
347 #[doc(alias = "get_resolution_x")]
348 pub fn resolution_x(&self) -> i32 {
349 unsafe { ffi::gtk_print_settings_get_resolution_x(self.to_glib_none().0) }
350 }
351
352 #[doc(alias = "gtk_print_settings_get_resolution_y")]
353 #[doc(alias = "get_resolution_y")]
354 pub fn resolution_y(&self) -> i32 {
355 unsafe { ffi::gtk_print_settings_get_resolution_y(self.to_glib_none().0) }
356 }
357
358 #[doc(alias = "gtk_print_settings_get_reverse")]
359 #[doc(alias = "get_reverse")]
360 pub fn is_reverse(&self) -> bool {
361 unsafe { from_glib(ffi::gtk_print_settings_get_reverse(self.to_glib_none().0)) }
362 }
363
364 #[doc(alias = "gtk_print_settings_get_scale")]
365 #[doc(alias = "get_scale")]
366 pub fn scale(&self) -> f64 {
367 unsafe { ffi::gtk_print_settings_get_scale(self.to_glib_none().0) }
368 }
369
370 #[doc(alias = "gtk_print_settings_get_use_color")]
371 #[doc(alias = "get_use_color")]
372 pub fn uses_color(&self) -> bool {
373 unsafe { from_glib(ffi::gtk_print_settings_get_use_color(self.to_glib_none().0)) }
374 }
375
376 #[doc(alias = "gtk_print_settings_has_key")]
377 pub fn has_key(&self, key: &str) -> bool {
378 unsafe {
379 from_glib(ffi::gtk_print_settings_has_key(
380 self.to_glib_none().0,
381 key.to_glib_none().0,
382 ))
383 }
384 }
385
386 #[doc(alias = "gtk_print_settings_load_file")]
387 pub fn load_file(&self, file_name: impl AsRef<std::path::Path>) -> Result<(), glib::Error> {
388 unsafe {
389 let mut error = ptr::null_mut();
390 let is_ok = ffi::gtk_print_settings_load_file(
391 self.to_glib_none().0,
392 file_name.as_ref().to_glib_none().0,
393 &mut error,
394 );
395 debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
396 if error.is_null() {
397 Ok(())
398 } else {
399 Err(from_glib_full(error))
400 }
401 }
402 }
403
404 #[doc(alias = "gtk_print_settings_load_key_file")]
405 pub fn load_key_file(
406 &self,
407 key_file: &glib::KeyFile,
408 group_name: Option<&str>,
409 ) -> Result<(), glib::Error> {
410 unsafe {
411 let mut error = ptr::null_mut();
412 let is_ok = ffi::gtk_print_settings_load_key_file(
413 self.to_glib_none().0,
414 key_file.to_glib_none().0,
415 group_name.to_glib_none().0,
416 &mut error,
417 );
418 debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
419 if error.is_null() {
420 Ok(())
421 } else {
422 Err(from_glib_full(error))
423 }
424 }
425 }
426
427 #[doc(alias = "gtk_print_settings_set")]
428 pub fn set(&self, key: &str, value: Option<&str>) {
429 unsafe {
430 ffi::gtk_print_settings_set(
431 self.to_glib_none().0,
432 key.to_glib_none().0,
433 value.to_glib_none().0,
434 );
435 }
436 }
437
438 #[doc(alias = "gtk_print_settings_set_bool")]
439 pub fn set_bool(&self, key: &str, value: bool) {
440 unsafe {
441 ffi::gtk_print_settings_set_bool(
442 self.to_glib_none().0,
443 key.to_glib_none().0,
444 value.into_glib(),
445 );
446 }
447 }
448
449 #[doc(alias = "gtk_print_settings_set_collate")]
450 pub fn set_collate(&self, collate: bool) {
451 unsafe {
452 ffi::gtk_print_settings_set_collate(self.to_glib_none().0, collate.into_glib());
453 }
454 }
455
456 #[doc(alias = "gtk_print_settings_set_default_source")]
457 pub fn set_default_source(&self, default_source: &str) {
458 unsafe {
459 ffi::gtk_print_settings_set_default_source(
460 self.to_glib_none().0,
461 default_source.to_glib_none().0,
462 );
463 }
464 }
465
466 #[doc(alias = "gtk_print_settings_set_dither")]
467 pub fn set_dither(&self, dither: &str) {
468 unsafe {
469 ffi::gtk_print_settings_set_dither(self.to_glib_none().0, dither.to_glib_none().0);
470 }
471 }
472
473 #[doc(alias = "gtk_print_settings_set_double")]
474 pub fn set_double(&self, key: &str, value: f64) {
475 unsafe {
476 ffi::gtk_print_settings_set_double(self.to_glib_none().0, key.to_glib_none().0, value);
477 }
478 }
479
480 #[doc(alias = "gtk_print_settings_set_duplex")]
481 pub fn set_duplex(&self, duplex: PrintDuplex) {
482 unsafe {
483 ffi::gtk_print_settings_set_duplex(self.to_glib_none().0, duplex.into_glib());
484 }
485 }
486
487 #[doc(alias = "gtk_print_settings_set_finishings")]
488 pub fn set_finishings(&self, finishings: &str) {
489 unsafe {
490 ffi::gtk_print_settings_set_finishings(
491 self.to_glib_none().0,
492 finishings.to_glib_none().0,
493 );
494 }
495 }
496
497 #[doc(alias = "gtk_print_settings_set_int")]
498 pub fn set_int(&self, key: &str, value: i32) {
499 unsafe {
500 ffi::gtk_print_settings_set_int(self.to_glib_none().0, key.to_glib_none().0, value);
501 }
502 }
503
504 #[doc(alias = "gtk_print_settings_set_length")]
505 pub fn set_length(&self, key: &str, value: f64, unit: Unit) {
506 unsafe {
507 ffi::gtk_print_settings_set_length(
508 self.to_glib_none().0,
509 key.to_glib_none().0,
510 value,
511 unit.into_glib(),
512 );
513 }
514 }
515
516 #[doc(alias = "gtk_print_settings_set_media_type")]
517 pub fn set_media_type(&self, media_type: &str) {
518 unsafe {
519 ffi::gtk_print_settings_set_media_type(
520 self.to_glib_none().0,
521 media_type.to_glib_none().0,
522 );
523 }
524 }
525
526 #[doc(alias = "gtk_print_settings_set_n_copies")]
527 pub fn set_n_copies(&self, num_copies: i32) {
528 unsafe {
529 ffi::gtk_print_settings_set_n_copies(self.to_glib_none().0, num_copies);
530 }
531 }
532
533 #[doc(alias = "gtk_print_settings_set_number_up")]
534 pub fn set_number_up(&self, number_up: i32) {
535 unsafe {
536 ffi::gtk_print_settings_set_number_up(self.to_glib_none().0, number_up);
537 }
538 }
539
540 #[doc(alias = "gtk_print_settings_set_number_up_layout")]
541 pub fn set_number_up_layout(&self, number_up_layout: NumberUpLayout) {
542 unsafe {
543 ffi::gtk_print_settings_set_number_up_layout(
544 self.to_glib_none().0,
545 number_up_layout.into_glib(),
546 );
547 }
548 }
549
550 #[doc(alias = "gtk_print_settings_set_orientation")]
551 pub fn set_orientation(&self, orientation: PageOrientation) {
552 unsafe {
553 ffi::gtk_print_settings_set_orientation(self.to_glib_none().0, orientation.into_glib());
554 }
555 }
556
557 #[doc(alias = "gtk_print_settings_set_output_bin")]
558 pub fn set_output_bin(&self, output_bin: &str) {
559 unsafe {
560 ffi::gtk_print_settings_set_output_bin(
561 self.to_glib_none().0,
562 output_bin.to_glib_none().0,
563 );
564 }
565 }
566
567 #[doc(alias = "gtk_print_settings_set_page_set")]
568 pub fn set_page_set(&self, page_set: PageSet) {
569 unsafe {
570 ffi::gtk_print_settings_set_page_set(self.to_glib_none().0, page_set.into_glib());
571 }
572 }
573
574 #[doc(alias = "gtk_print_settings_set_paper_height")]
575 pub fn set_paper_height(&self, height: f64, unit: Unit) {
576 unsafe {
577 ffi::gtk_print_settings_set_paper_height(
578 self.to_glib_none().0,
579 height,
580 unit.into_glib(),
581 );
582 }
583 }
584
585 #[doc(alias = "gtk_print_settings_set_paper_size")]
586 pub fn set_paper_size(&self, paper_size: &PaperSize) {
587 unsafe {
588 ffi::gtk_print_settings_set_paper_size(
589 self.to_glib_none().0,
590 mut_override(paper_size.to_glib_none().0),
591 );
592 }
593 }
594
595 #[doc(alias = "gtk_print_settings_set_paper_width")]
596 pub fn set_paper_width(&self, width: f64, unit: Unit) {
597 unsafe {
598 ffi::gtk_print_settings_set_paper_width(self.to_glib_none().0, width, unit.into_glib());
599 }
600 }
601
602 #[doc(alias = "gtk_print_settings_set_print_pages")]
603 pub fn set_print_pages(&self, pages: PrintPages) {
604 unsafe {
605 ffi::gtk_print_settings_set_print_pages(self.to_glib_none().0, pages.into_glib());
606 }
607 }
608
609 #[doc(alias = "gtk_print_settings_set_printer")]
610 pub fn set_printer(&self, printer: &str) {
611 unsafe {
612 ffi::gtk_print_settings_set_printer(self.to_glib_none().0, printer.to_glib_none().0);
613 }
614 }
615
616 #[doc(alias = "gtk_print_settings_set_printer_lpi")]
617 pub fn set_printer_lpi(&self, lpi: f64) {
618 unsafe {
619 ffi::gtk_print_settings_set_printer_lpi(self.to_glib_none().0, lpi);
620 }
621 }
622
623 #[doc(alias = "gtk_print_settings_set_quality")]
624 pub fn set_quality(&self, quality: PrintQuality) {
625 unsafe {
626 ffi::gtk_print_settings_set_quality(self.to_glib_none().0, quality.into_glib());
627 }
628 }
629
630 #[doc(alias = "gtk_print_settings_set_resolution")]
631 pub fn set_resolution(&self, resolution: i32) {
632 unsafe {
633 ffi::gtk_print_settings_set_resolution(self.to_glib_none().0, resolution);
634 }
635 }
636
637 #[doc(alias = "gtk_print_settings_set_resolution_xy")]
638 pub fn set_resolution_xy(&self, resolution_x: i32, resolution_y: i32) {
639 unsafe {
640 ffi::gtk_print_settings_set_resolution_xy(
641 self.to_glib_none().0,
642 resolution_x,
643 resolution_y,
644 );
645 }
646 }
647
648 #[doc(alias = "gtk_print_settings_set_reverse")]
649 pub fn set_reverse(&self, reverse: bool) {
650 unsafe {
651 ffi::gtk_print_settings_set_reverse(self.to_glib_none().0, reverse.into_glib());
652 }
653 }
654
655 #[doc(alias = "gtk_print_settings_set_scale")]
656 pub fn set_scale(&self, scale: f64) {
657 unsafe {
658 ffi::gtk_print_settings_set_scale(self.to_glib_none().0, scale);
659 }
660 }
661
662 #[doc(alias = "gtk_print_settings_set_use_color")]
663 pub fn set_use_color(&self, use_color: bool) {
664 unsafe {
665 ffi::gtk_print_settings_set_use_color(self.to_glib_none().0, use_color.into_glib());
666 }
667 }
668
669 #[doc(alias = "gtk_print_settings_to_file")]
670 pub fn to_file(&self, file_name: impl AsRef<std::path::Path>) -> Result<(), glib::Error> {
671 unsafe {
672 let mut error = ptr::null_mut();
673 let is_ok = ffi::gtk_print_settings_to_file(
674 self.to_glib_none().0,
675 file_name.as_ref().to_glib_none().0,
676 &mut error,
677 );
678 debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
679 if error.is_null() {
680 Ok(())
681 } else {
682 Err(from_glib_full(error))
683 }
684 }
685 }
686
687 #[doc(alias = "gtk_print_settings_to_gvariant")]
688 pub fn to_gvariant(&self) -> Option<glib::Variant> {
689 unsafe { from_glib_none(ffi::gtk_print_settings_to_gvariant(self.to_glib_none().0)) }
690 }
691
692 #[doc(alias = "gtk_print_settings_to_key_file")]
693 pub fn to_key_file(&self, key_file: &glib::KeyFile, group_name: Option<&str>) {
694 unsafe {
695 ffi::gtk_print_settings_to_key_file(
696 self.to_glib_none().0,
697 key_file.to_glib_none().0,
698 group_name.to_glib_none().0,
699 );
700 }
701 }
702
703 #[doc(alias = "gtk_print_settings_unset")]
704 pub fn unset(&self, key: &str) {
705 unsafe {
706 ffi::gtk_print_settings_unset(self.to_glib_none().0, key.to_glib_none().0);
707 }
708 }
709}
710
711impl Default for PrintSettings {
712 fn default() -> Self {
713 Self::new()
714 }
715}
716
717impl fmt::Display for PrintSettings {
718 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
719 f.write_str("PrintSettings")
720 }
721}