gtk4/subclass/
accessible.rs1use std::mem::MaybeUninit;
7
8use glib::translate::*;
9
10use crate::{
11 ATContext, Accessible, AccessiblePlatformState, ffi, prelude::*, subclass::prelude::*,
12};
13
14pub trait AccessibleImpl: ObjectImpl + ObjectSubclass<Type: IsA<Accessible>> {
15 #[doc(alias = "get_platform_state")]
16 fn platform_state(&self, state: AccessiblePlatformState) -> bool {
17 self.parent_platform_state(state)
18 }
19
20 #[doc(alias = "get_bounds")]
21 fn bounds(&self) -> Option<(i32, i32, i32, i32)> {
22 self.parent_bounds()
23 }
24
25 #[doc(alias = "get_at_context")]
26 fn at_context(&self) -> Option<ATContext> {
27 self.parent_at_context()
28 }
29
30 #[doc(alias = "get_accessible_parent")]
31 fn accessible_parent(&self) -> Option<Accessible> {
32 self.parent_accessible_parent()
33 }
34
35 #[doc(alias = "get_first_accessible_child")]
36 fn first_accessible_child(&self) -> Option<Accessible> {
37 self.parent_first_accessible_child()
38 }
39
40 #[doc(alias = "get_next_accessible_sibling")]
41 fn next_accessible_sibling(&self) -> Option<Accessible> {
42 self.parent_next_accessible_sibling()
43 }
44}
45
46pub trait AccessibleImplExt: AccessibleImpl {
47 fn parent_platform_state(&self, state: AccessiblePlatformState) -> bool {
48 unsafe {
49 let type_data = Self::type_data();
50 let parent_iface = type_data.as_ref().parent_interface::<Accessible>()
51 as *const ffi::GtkAccessibleInterface;
52
53 let func = (*parent_iface)
54 .get_platform_state
55 .expect("no parent \"get_platform_state\" implementation");
56
57 from_glib(func(
58 self.obj().unsafe_cast_ref::<Accessible>().to_glib_none().0,
59 state.into_glib(),
60 ))
61 }
62 }
63
64 fn parent_bounds(&self) -> Option<(i32, i32, i32, i32)> {
65 unsafe {
66 let type_data = Self::type_data();
67 let parent_iface = type_data.as_ref().parent_interface::<Accessible>()
68 as *const ffi::GtkAccessibleInterface;
69
70 let func = (*parent_iface)
71 .get_bounds
72 .expect("no parent \"get_bounds\" implementation");
73
74 let mut x = MaybeUninit::uninit();
75 let mut y = MaybeUninit::uninit();
76 let mut width = MaybeUninit::uninit();
77 let mut height = MaybeUninit::uninit();
78 let res = from_glib(func(
79 self.obj().unsafe_cast_ref::<Accessible>().to_glib_none().0,
80 x.as_mut_ptr(),
81 y.as_mut_ptr(),
82 width.as_mut_ptr(),
83 height.as_mut_ptr(),
84 ));
85 if res {
86 Some((
87 x.assume_init(),
88 y.assume_init(),
89 width.assume_init(),
90 height.assume_init(),
91 ))
92 } else {
93 None
94 }
95 }
96 }
97
98 fn parent_at_context(&self) -> Option<ATContext> {
99 unsafe {
100 let type_data = Self::type_data();
101 let parent_iface = type_data.as_ref().parent_interface::<Accessible>()
102 as *const ffi::GtkAccessibleInterface;
103
104 let func = (*parent_iface)
105 .get_at_context
106 .expect("no parent \"get_at_context\" implementation");
107
108 from_glib_full(func(
109 self.obj().unsafe_cast_ref::<Accessible>().to_glib_none().0,
110 ))
111 }
112 }
113
114 fn parent_accessible_parent(&self) -> Option<Accessible> {
115 unsafe {
116 let type_data = Self::type_data();
117 let parent_iface = type_data.as_ref().parent_interface::<Accessible>()
118 as *const ffi::GtkAccessibleInterface;
119
120 let func = (*parent_iface)
121 .get_accessible_parent
122 .expect("no parent \"get_accessible_parent\" implementation");
123
124 from_glib_full(func(
125 self.obj().unsafe_cast_ref::<Accessible>().to_glib_none().0,
126 ))
127 }
128 }
129
130 fn parent_first_accessible_child(&self) -> Option<Accessible> {
131 unsafe {
132 let type_data = Self::type_data();
133 let parent_iface = type_data.as_ref().parent_interface::<Accessible>()
134 as *const ffi::GtkAccessibleInterface;
135
136 let func = (*parent_iface)
137 .get_first_accessible_child
138 .expect("no parent \"get_first_accessible_child\" implementation");
139
140 from_glib_full(func(
141 self.obj().unsafe_cast_ref::<Accessible>().to_glib_none().0,
142 ))
143 }
144 }
145
146 fn parent_next_accessible_sibling(&self) -> Option<Accessible> {
147 unsafe {
148 let type_data = Self::type_data();
149 let parent_iface = type_data.as_ref().parent_interface::<Accessible>()
150 as *const ffi::GtkAccessibleInterface;
151
152 let func = (*parent_iface)
153 .get_next_accessible_sibling
154 .expect("no parent \"get_next_accessible_sibling\" implementation");
155
156 from_glib_full(func(
157 self.obj().unsafe_cast_ref::<Accessible>().to_glib_none().0,
158 ))
159 }
160 }
161}
162
163impl<T: AccessibleImpl> AccessibleImplExt for T {}
164
165unsafe impl<T: AccessibleImpl> IsImplementable<T> for Accessible {
166 fn interface_init(iface: &mut glib::Interface<Self>) {
167 let iface = iface.as_mut();
168
169 iface.get_platform_state = Some(accessible_get_platform_state::<T>);
170 iface.get_bounds = Some(accessible_get_bounds::<T>);
171 iface.get_at_context = Some(accessible_get_at_context::<T>);
172 iface.get_accessible_parent = Some(accessible_get_accessible_parent::<T>);
173 iface.get_first_accessible_child = Some(accessible_get_first_accessible_child::<T>);
174 iface.get_next_accessible_sibling = Some(accessible_get_next_accessible_sibling::<T>);
175 }
176}
177
178unsafe extern "C" fn accessible_get_platform_state<T: AccessibleImpl>(
179 accessible: *mut ffi::GtkAccessible,
180 state: ffi::GtkAccessiblePlatformState,
181) -> glib::ffi::gboolean {
182 unsafe {
183 let instance = &*(accessible as *mut T::Instance);
184 let imp = instance.imp();
185
186 imp.platform_state(from_glib(state)).into_glib()
187 }
188}
189
190unsafe extern "C" fn accessible_get_bounds<T: AccessibleImpl>(
191 accessible: *mut ffi::GtkAccessible,
192 xptr: *mut libc::c_int,
193 yptr: *mut libc::c_int,
194 widthptr: *mut libc::c_int,
195 heightptr: *mut libc::c_int,
196) -> glib::ffi::gboolean {
197 unsafe {
198 let instance = &*(accessible as *mut T::Instance);
199 let imp = instance.imp();
200
201 if let Some((x, y, width, height)) = imp.bounds() {
202 *xptr = x;
203 *yptr = y;
204 *widthptr = width;
205 *heightptr = height;
206
207 true.into_glib()
208 } else {
209 false.into_glib()
210 }
211 }
212}
213
214unsafe extern "C" fn accessible_get_at_context<T: AccessibleImpl>(
215 accessible: *mut ffi::GtkAccessible,
216) -> *mut ffi::GtkATContext {
217 unsafe {
218 let instance = &*(accessible as *mut T::Instance);
219 let imp = instance.imp();
220
221 imp.at_context().into_glib_ptr()
222 }
223}
224
225unsafe extern "C" fn accessible_get_accessible_parent<T: AccessibleImpl>(
226 accessible: *mut ffi::GtkAccessible,
227) -> *mut ffi::GtkAccessible {
228 unsafe {
229 let instance = &*(accessible as *mut T::Instance);
230 let imp = instance.imp();
231
232 imp.accessible_parent().into_glib_ptr()
233 }
234}
235
236unsafe extern "C" fn accessible_get_first_accessible_child<T: AccessibleImpl>(
237 accessible: *mut ffi::GtkAccessible,
238) -> *mut ffi::GtkAccessible {
239 unsafe {
240 let instance = &*(accessible as *mut T::Instance);
241 let imp = instance.imp();
242
243 imp.first_accessible_child().into_glib_ptr()
244 }
245}
246
247unsafe extern "C" fn accessible_get_next_accessible_sibling<T: AccessibleImpl>(
248 accessible: *mut ffi::GtkAccessible,
249) -> *mut ffi::GtkAccessible {
250 unsafe {
251 let instance = &*(accessible as *mut T::Instance);
252 let imp = instance.imp();
253
254 imp.next_accessible_sibling().into_glib_ptr()
255 }
256}