gtk4/subclass/
print_operation_preview.rs

1// Take a look at the license at the top of the repository in the LICENSE file.
2
3// rustdoc-stripper-ignore-next
4//! Traits intended for implementing the
5//! [`PrintOperationPreview`](crate::PrintOperationPreview) interface.
6
7use glib::translate::*;
8
9use crate::{
10    ffi, prelude::*, subclass::prelude::*, PageSetup, PrintContext, PrintOperationPreview,
11};
12
13pub trait PrintOperationPreviewImpl: ObjectImpl {
14    fn ready(&self, context: &PrintContext) {
15        self.parent_ready(context)
16    }
17
18    fn got_page_size(&self, context: &PrintContext, page_setup: &PageSetup) {
19        self.parent_got_page_size(context, page_setup)
20    }
21
22    fn render_page(&self, page_nr: i32);
23    fn is_selected(&self, page_nr: i32) -> bool;
24    fn end_preview(&self);
25}
26
27mod sealed {
28    pub trait Sealed {}
29    impl<T: super::PrintOperationPreviewImplExt> Sealed for T {}
30}
31
32pub trait PrintOperationPreviewImplExt: sealed::Sealed + ObjectSubclass {
33    fn parent_ready(&self, context: &PrintContext) {
34        unsafe {
35            let type_data = Self::type_data();
36            let parent_iface = type_data
37                .as_ref()
38                .parent_interface::<PrintOperationPreview>()
39                as *const ffi::GtkPrintOperationPreviewIface;
40
41            if let Some(func) = (*parent_iface).ready {
42                func(
43                    self.obj()
44                        .unsafe_cast_ref::<PrintOperationPreview>()
45                        .to_glib_none()
46                        .0,
47                    context.to_glib_none().0,
48                );
49            }
50        }
51    }
52
53    fn parent_got_page_size(&self, context: &PrintContext, page_setup: &PageSetup) {
54        unsafe {
55            let type_data = Self::type_data();
56            let parent_iface = type_data
57                .as_ref()
58                .parent_interface::<PrintOperationPreview>()
59                as *const ffi::GtkPrintOperationPreviewIface;
60
61            if let Some(func) = (*parent_iface).got_page_size {
62                func(
63                    self.obj()
64                        .unsafe_cast_ref::<PrintOperationPreview>()
65                        .to_glib_none()
66                        .0,
67                    context.to_glib_none().0,
68                    page_setup.to_glib_none().0,
69                );
70            }
71        }
72    }
73
74    fn parent_render_page(&self, page_nr: i32) {
75        unsafe {
76            let type_data = Self::type_data();
77            let parent_iface = type_data
78                .as_ref()
79                .parent_interface::<PrintOperationPreview>()
80                as *const ffi::GtkPrintOperationPreviewIface;
81
82            if let Some(func) = (*parent_iface).render_page {
83                func(
84                    self.obj()
85                        .unsafe_cast_ref::<PrintOperationPreview>()
86                        .to_glib_none()
87                        .0,
88                    page_nr,
89                );
90            }
91        }
92    }
93
94    fn parent_is_selected(&self, page_nr: i32) -> bool {
95        unsafe {
96            let type_data = Self::type_data();
97            let parent_iface = type_data
98                .as_ref()
99                .parent_interface::<PrintOperationPreview>()
100                as *const ffi::GtkPrintOperationPreviewIface;
101            let func = (*parent_iface)
102                .is_selected
103                .expect("no parent \"is_selected\" implementation");
104
105            from_glib(func(
106                self.obj()
107                    .unsafe_cast_ref::<PrintOperationPreview>()
108                    .to_glib_none()
109                    .0,
110                page_nr,
111            ))
112        }
113    }
114
115    fn parent_end_preview(&self) {
116        unsafe {
117            let type_data = Self::type_data();
118            let parent_iface = type_data
119                .as_ref()
120                .parent_interface::<PrintOperationPreview>()
121                as *const ffi::GtkPrintOperationPreviewIface;
122
123            if let Some(func) = (*parent_iface).end_preview {
124                func(
125                    self.obj()
126                        .unsafe_cast_ref::<PrintOperationPreview>()
127                        .to_glib_none()
128                        .0,
129                );
130            }
131        }
132    }
133}
134
135impl<T: PrintOperationPreviewImpl> PrintOperationPreviewImplExt for T {}
136
137unsafe impl<T: PrintOperationPreviewImpl> IsImplementable<T> for PrintOperationPreview {
138    fn interface_init(iface: &mut glib::Interface<Self>) {
139        let iface = iface.as_mut();
140
141        assert_initialized_main_thread!();
142
143        iface.ready = Some(print_operation_preview_ready::<T>);
144        iface.got_page_size = Some(print_operation_preview_got_page_size::<T>);
145        iface.render_page = Some(print_operation_preview_render_page::<T>);
146        iface.is_selected = Some(print_operation_preview_is_selected::<T>);
147        iface.end_preview = Some(print_operation_preview_end_preview::<T>);
148    }
149}
150
151unsafe extern "C" fn print_operation_preview_ready<T: PrintOperationPreviewImpl>(
152    print_operation_preview: *mut ffi::GtkPrintOperationPreview,
153    contextptr: *mut ffi::GtkPrintContext,
154) {
155    let instance = &*(print_operation_preview as *mut T::Instance);
156    let imp = instance.imp();
157    let context: Borrowed<PrintContext> = from_glib_borrow(contextptr);
158
159    imp.ready(&context)
160}
161
162unsafe extern "C" fn print_operation_preview_got_page_size<T: PrintOperationPreviewImpl>(
163    print_operation_preview: *mut ffi::GtkPrintOperationPreview,
164    contextptr: *mut ffi::GtkPrintContext,
165    setupptr: *mut ffi::GtkPageSetup,
166) {
167    let instance = &*(print_operation_preview as *mut T::Instance);
168    let imp = instance.imp();
169
170    let context: Borrowed<PrintContext> = from_glib_borrow(contextptr);
171    let setup: Borrowed<PageSetup> = from_glib_borrow(setupptr);
172
173    imp.got_page_size(&context, &setup)
174}
175
176unsafe extern "C" fn print_operation_preview_render_page<T: PrintOperationPreviewImpl>(
177    print_operation_preview: *mut ffi::GtkPrintOperationPreview,
178    page_nr: i32,
179) {
180    let instance = &*(print_operation_preview as *mut T::Instance);
181    let imp = instance.imp();
182
183    imp.render_page(page_nr)
184}
185
186unsafe extern "C" fn print_operation_preview_is_selected<T: PrintOperationPreviewImpl>(
187    print_operation_preview: *mut ffi::GtkPrintOperationPreview,
188    page_nr: i32,
189) -> glib::ffi::gboolean {
190    let instance = &*(print_operation_preview as *mut T::Instance);
191    let imp = instance.imp();
192
193    imp.is_selected(page_nr).into_glib()
194}
195
196unsafe extern "C" fn print_operation_preview_end_preview<T: PrintOperationPreviewImpl>(
197    print_operation_preview: *mut ffi::GtkPrintOperationPreview,
198) {
199    let instance = &*(print_operation_preview as *mut T::Instance);
200    let imp = instance.imp();
201
202    imp.end_preview()
203}