1use crate::{
6 ffi, NumberUpLayout, PageRange, PageSet, PageSetup, PrintPages, PrintSettings, PrintStatus,
7 Printer,
8};
9use glib::{
10 object::ObjectType as _,
11 prelude::*,
12 signal::{connect_raw, SignalHandlerId},
13 translate::*,
14};
15use std::boxed::Box as Box_;
16
17glib::wrapper! {
18 #[doc(alias = "GtkPrintJob")]
19 pub struct PrintJob(Object<ffi::GtkPrintJob>);
20
21 match fn {
22 type_ => || ffi::gtk_print_job_get_type(),
23 }
24}
25
26impl PrintJob {
27 #[doc(alias = "gtk_print_job_new")]
28 pub fn new(
29 title: &str,
30 printer: &Printer,
31 settings: &PrintSettings,
32 page_setup: &PageSetup,
33 ) -> PrintJob {
34 skip_assert_initialized!();
35 unsafe {
36 from_glib_full(ffi::gtk_print_job_new(
37 title.to_glib_none().0,
38 printer.to_glib_none().0,
39 settings.to_glib_none().0,
40 page_setup.to_glib_none().0,
41 ))
42 }
43 }
44
45 #[doc(alias = "gtk_print_job_get_collate")]
46 #[doc(alias = "get_collate")]
47 pub fn is_collate(&self) -> bool {
48 unsafe { from_glib(ffi::gtk_print_job_get_collate(self.to_glib_none().0)) }
49 }
50
51 #[doc(alias = "gtk_print_job_get_n_up")]
52 #[doc(alias = "get_n_up")]
53 pub fn n_up(&self) -> u32 {
54 unsafe { ffi::gtk_print_job_get_n_up(self.to_glib_none().0) }
55 }
56
57 #[doc(alias = "gtk_print_job_get_n_up_layout")]
58 #[doc(alias = "get_n_up_layout")]
59 pub fn n_up_layout(&self) -> NumberUpLayout {
60 unsafe { from_glib(ffi::gtk_print_job_get_n_up_layout(self.to_glib_none().0)) }
61 }
62
63 #[doc(alias = "gtk_print_job_get_num_copies")]
64 #[doc(alias = "get_num_copies")]
65 pub fn num_copies(&self) -> i32 {
66 unsafe { ffi::gtk_print_job_get_num_copies(self.to_glib_none().0) }
67 }
68
69 #[doc(alias = "gtk_print_job_get_page_ranges")]
70 #[doc(alias = "get_page_ranges")]
71 pub fn page_ranges(&self) -> Vec<PageRange> {
72 unsafe {
73 let mut n_ranges = std::mem::MaybeUninit::uninit();
74 let ret = FromGlibContainer::from_glib_none_num(
75 ffi::gtk_print_job_get_page_ranges(self.to_glib_none().0, n_ranges.as_mut_ptr()),
76 n_ranges.assume_init() as _,
77 );
78 ret
79 }
80 }
81
82 #[doc(alias = "gtk_print_job_get_page_set")]
83 #[doc(alias = "get_page_set")]
84 pub fn page_set(&self) -> PageSet {
85 unsafe { from_glib(ffi::gtk_print_job_get_page_set(self.to_glib_none().0)) }
86 }
87
88 #[doc(alias = "gtk_print_job_get_pages")]
89 #[doc(alias = "get_pages")]
90 pub fn pages(&self) -> PrintPages {
91 unsafe { from_glib(ffi::gtk_print_job_get_pages(self.to_glib_none().0)) }
92 }
93
94 #[doc(alias = "gtk_print_job_get_printer")]
95 #[doc(alias = "get_printer")]
96 pub fn printer(&self) -> Printer {
97 unsafe { from_glib_none(ffi::gtk_print_job_get_printer(self.to_glib_none().0)) }
98 }
99
100 #[doc(alias = "gtk_print_job_get_reverse")]
101 #[doc(alias = "get_reverse")]
102 pub fn is_reverse(&self) -> bool {
103 unsafe { from_glib(ffi::gtk_print_job_get_reverse(self.to_glib_none().0)) }
104 }
105
106 #[doc(alias = "gtk_print_job_get_rotate")]
107 #[doc(alias = "get_rotate")]
108 pub fn is_rotate(&self) -> bool {
109 unsafe { from_glib(ffi::gtk_print_job_get_rotate(self.to_glib_none().0)) }
110 }
111
112 #[doc(alias = "gtk_print_job_get_scale")]
113 #[doc(alias = "get_scale")]
114 pub fn scale(&self) -> f64 {
115 unsafe { ffi::gtk_print_job_get_scale(self.to_glib_none().0) }
116 }
117
118 #[doc(alias = "gtk_print_job_get_settings")]
119 #[doc(alias = "get_settings")]
120 pub fn settings(&self) -> PrintSettings {
121 unsafe { from_glib_none(ffi::gtk_print_job_get_settings(self.to_glib_none().0)) }
122 }
123
124 #[doc(alias = "gtk_print_job_get_status")]
125 #[doc(alias = "get_status")]
126 pub fn status(&self) -> PrintStatus {
127 unsafe { from_glib(ffi::gtk_print_job_get_status(self.to_glib_none().0)) }
128 }
129
130 #[doc(alias = "gtk_print_job_get_surface")]
131 #[doc(alias = "get_surface")]
132 pub fn surface(&self) -> Result<cairo::Surface, glib::Error> {
133 unsafe {
134 let mut error = std::ptr::null_mut();
135 let ret = ffi::gtk_print_job_get_surface(self.to_glib_none().0, &mut error);
136 if error.is_null() {
137 Ok(from_glib_none(ret))
138 } else {
139 Err(from_glib_full(error))
140 }
141 }
142 }
143
144 #[doc(alias = "gtk_print_job_get_title")]
145 #[doc(alias = "get_title")]
146 pub fn title(&self) -> glib::GString {
147 unsafe { from_glib_none(ffi::gtk_print_job_get_title(self.to_glib_none().0)) }
148 }
149
150 #[doc(alias = "gtk_print_job_get_track_print_status")]
151 #[doc(alias = "get_track_print_status")]
152 #[doc(alias = "track-print-status")]
153 pub fn tracks_print_status(&self) -> bool {
154 unsafe {
155 from_glib(ffi::gtk_print_job_get_track_print_status(
156 self.to_glib_none().0,
157 ))
158 }
159 }
160
161 #[doc(alias = "gtk_print_job_set_collate")]
162 pub fn set_collate(&self, collate: bool) {
163 unsafe {
164 ffi::gtk_print_job_set_collate(self.to_glib_none().0, collate.into_glib());
165 }
166 }
167
168 #[doc(alias = "gtk_print_job_set_n_up")]
169 pub fn set_n_up(&self, n_up: u32) {
170 unsafe {
171 ffi::gtk_print_job_set_n_up(self.to_glib_none().0, n_up);
172 }
173 }
174
175 #[doc(alias = "gtk_print_job_set_n_up_layout")]
176 pub fn set_n_up_layout(&self, layout: NumberUpLayout) {
177 unsafe {
178 ffi::gtk_print_job_set_n_up_layout(self.to_glib_none().0, layout.into_glib());
179 }
180 }
181
182 #[doc(alias = "gtk_print_job_set_num_copies")]
183 pub fn set_num_copies(&self, num_copies: i32) {
184 unsafe {
185 ffi::gtk_print_job_set_num_copies(self.to_glib_none().0, num_copies);
186 }
187 }
188
189 #[doc(alias = "gtk_print_job_set_page_ranges")]
190 pub fn set_page_ranges(&self, ranges: &[PageRange]) {
191 let n_ranges = ranges.len() as _;
192 unsafe {
193 ffi::gtk_print_job_set_page_ranges(
194 self.to_glib_none().0,
195 ranges.to_glib_full(),
196 n_ranges,
197 );
198 }
199 }
200
201 #[doc(alias = "gtk_print_job_set_page_set")]
202 pub fn set_page_set(&self, page_set: PageSet) {
203 unsafe {
204 ffi::gtk_print_job_set_page_set(self.to_glib_none().0, page_set.into_glib());
205 }
206 }
207
208 #[doc(alias = "gtk_print_job_set_pages")]
209 pub fn set_pages(&self, pages: PrintPages) {
210 unsafe {
211 ffi::gtk_print_job_set_pages(self.to_glib_none().0, pages.into_glib());
212 }
213 }
214
215 #[doc(alias = "gtk_print_job_set_reverse")]
216 pub fn set_reverse(&self, reverse: bool) {
217 unsafe {
218 ffi::gtk_print_job_set_reverse(self.to_glib_none().0, reverse.into_glib());
219 }
220 }
221
222 #[doc(alias = "gtk_print_job_set_rotate")]
223 pub fn set_rotate(&self, rotate: bool) {
224 unsafe {
225 ffi::gtk_print_job_set_rotate(self.to_glib_none().0, rotate.into_glib());
226 }
227 }
228
229 #[doc(alias = "gtk_print_job_set_scale")]
230 pub fn set_scale(&self, scale: f64) {
231 unsafe {
232 ffi::gtk_print_job_set_scale(self.to_glib_none().0, scale);
233 }
234 }
235
236 #[doc(alias = "gtk_print_job_set_source_fd")]
237 pub fn set_source_fd(&self, fd: i32) -> Result<(), glib::Error> {
238 unsafe {
239 let mut error = std::ptr::null_mut();
240 let is_ok = ffi::gtk_print_job_set_source_fd(self.to_glib_none().0, fd, &mut error);
241 debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
242 if error.is_null() {
243 Ok(())
244 } else {
245 Err(from_glib_full(error))
246 }
247 }
248 }
249
250 #[doc(alias = "gtk_print_job_set_source_file")]
251 pub fn set_source_file(
252 &self,
253 filename: impl AsRef<std::path::Path>,
254 ) -> Result<(), glib::Error> {
255 unsafe {
256 let mut error = std::ptr::null_mut();
257 let is_ok = ffi::gtk_print_job_set_source_file(
258 self.to_glib_none().0,
259 filename.as_ref().to_glib_none().0,
260 &mut error,
261 );
262 debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
263 if error.is_null() {
264 Ok(())
265 } else {
266 Err(from_glib_full(error))
267 }
268 }
269 }
270
271 #[doc(alias = "gtk_print_job_set_track_print_status")]
272 #[doc(alias = "track-print-status")]
273 pub fn set_track_print_status(&self, track_status: bool) {
274 unsafe {
275 ffi::gtk_print_job_set_track_print_status(
276 self.to_glib_none().0,
277 track_status.into_glib(),
278 );
279 }
280 }
281
282 #[doc(alias = "page-setup")]
283 pub fn page_setup(&self) -> Option<PageSetup> {
284 ObjectExt::property(self, "page-setup")
285 }
286
287 #[doc(alias = "status-changed")]
288 pub fn connect_status_changed<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
289 unsafe extern "C" fn status_changed_trampoline<F: Fn(&PrintJob) + 'static>(
290 this: *mut ffi::GtkPrintJob,
291 f: glib::ffi::gpointer,
292 ) {
293 let f: &F = &*(f as *const F);
294 f(&from_glib_borrow(this))
295 }
296 unsafe {
297 let f: Box_<F> = Box_::new(f);
298 connect_raw(
299 self.as_ptr() as *mut _,
300 c"status-changed".as_ptr() as *const _,
301 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
302 status_changed_trampoline::<F> as *const (),
303 )),
304 Box_::into_raw(f),
305 )
306 }
307 }
308
309 #[doc(alias = "track-print-status")]
310 pub fn connect_track_print_status_notify<F: Fn(&Self) + 'static>(
311 &self,
312 f: F,
313 ) -> SignalHandlerId {
314 unsafe extern "C" fn notify_track_print_status_trampoline<F: Fn(&PrintJob) + 'static>(
315 this: *mut ffi::GtkPrintJob,
316 _param_spec: glib::ffi::gpointer,
317 f: glib::ffi::gpointer,
318 ) {
319 let f: &F = &*(f as *const F);
320 f(&from_glib_borrow(this))
321 }
322 unsafe {
323 let f: Box_<F> = Box_::new(f);
324 connect_raw(
325 self.as_ptr() as *mut _,
326 c"notify::track-print-status".as_ptr() as *const _,
327 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
328 notify_track_print_status_trampoline::<F> as *const (),
329 )),
330 Box_::into_raw(f),
331 )
332 }
333 }
334}