1 // Take a look at the license at the top of the repository in the LICENSE file.
2
3 use crate::ActionGroup;
4 use glib::subclass::prelude::*;
5 use glib::translate::*;
6 use glib::{Cast, GString, ObjectExt, Quark, Variant, VariantType};
7 use once_cell::sync::Lazy;
8 use std::mem;
9 use std::ptr;
10
11 pub trait ActionGroupImpl: ObjectImpl {
action_added(&self, action_group: &Self::Type, action_name: &str)12 fn action_added(&self, action_group: &Self::Type, action_name: &str) {
13 self.parent_action_added(action_group, action_name);
14 }
15
action_enabled_changed(&self, action_group: &Self::Type, action_name: &str, enabled: bool)16 fn action_enabled_changed(&self, action_group: &Self::Type, action_name: &str, enabled: bool) {
17 self.parent_action_enabled_changed(action_group, action_name, enabled);
18 }
19
action_removed(&self, action_group: &Self::Type, action_name: &str)20 fn action_removed(&self, action_group: &Self::Type, action_name: &str) {
21 self.parent_action_removed(action_group, action_name);
22 }
23
action_state_changed(&self, action_group: &Self::Type, action_name: &str, state: &Variant)24 fn action_state_changed(&self, action_group: &Self::Type, action_name: &str, state: &Variant) {
25 self.parent_action_state_changed(action_group, action_name, state);
26 }
27
activate_action( &self, action_group: &Self::Type, action_name: &str, parameter: Option<&Variant>, )28 fn activate_action(
29 &self,
30 action_group: &Self::Type,
31 action_name: &str,
32 parameter: Option<&Variant>,
33 ) {
34 self.parent_activate_action(action_group, action_name, parameter);
35 }
36
change_action_state(&self, action_group: &Self::Type, action_name: &str, value: &Variant)37 fn change_action_state(&self, action_group: &Self::Type, action_name: &str, value: &Variant) {
38 self.parent_change_action_state(action_group, action_name, value)
39 }
40
41 #[doc(alias = "get_action_enabled")]
action_is_enabled(&self, action_group: &Self::Type, action_name: &str) -> bool42 fn action_is_enabled(&self, action_group: &Self::Type, action_name: &str) -> bool {
43 self.parent_action_is_enabled(action_group, action_name)
44 }
45
46 #[doc(alias = "get_action_parameter_type")]
action_parameter_type( &self, action_group: &Self::Type, action_name: &str, ) -> Option<VariantType>47 fn action_parameter_type(
48 &self,
49 action_group: &Self::Type,
50 action_name: &str,
51 ) -> Option<VariantType> {
52 self.parent_action_parameter_type(action_group, action_name)
53 }
54
55 #[doc(alias = "get_action_state")]
action_state(&self, action_group: &Self::Type, action_name: &str) -> Option<Variant>56 fn action_state(&self, action_group: &Self::Type, action_name: &str) -> Option<Variant> {
57 self.parent_action_state(action_group, action_name)
58 }
59
60 #[doc(alias = "get_action_state_hint")]
action_state_hint(&self, action_group: &Self::Type, action_name: &str) -> Option<Variant>61 fn action_state_hint(&self, action_group: &Self::Type, action_name: &str) -> Option<Variant> {
62 self.parent_action_state_hint(action_group, action_name)
63 }
64
65 #[doc(alias = "get_action_state_type")]
action_state_type( &self, action_group: &Self::Type, action_name: &str, ) -> Option<VariantType>66 fn action_state_type(
67 &self,
68 action_group: &Self::Type,
69 action_name: &str,
70 ) -> Option<VariantType> {
71 self.parent_action_state_type(action_group, action_name)
72 }
73
has_action(&self, action_group: &Self::Type, action_name: &str) -> bool74 fn has_action(&self, action_group: &Self::Type, action_name: &str) -> bool {
75 self.parent_has_action(action_group, action_name)
76 }
77
list_actions(&self, action_group: &Self::Type) -> Vec<String>78 fn list_actions(&self, action_group: &Self::Type) -> Vec<String>;
query_action( &self, action_group: &Self::Type, action_name: &str, ) -> Option<( bool, Option<VariantType>, Option<VariantType>, Option<Variant>, Option<Variant>, )>79 fn query_action(
80 &self,
81 action_group: &Self::Type,
82 action_name: &str,
83 ) -> Option<(
84 bool,
85 Option<VariantType>,
86 Option<VariantType>,
87 Option<Variant>,
88 Option<Variant>,
89 )>;
90 }
91
92 pub trait ActionGroupImplExt: ObjectSubclass {
parent_action_added(&self, action_group: &Self::Type, action_name: &str)93 fn parent_action_added(&self, action_group: &Self::Type, action_name: &str);
parent_action_enabled_changed( &self, action_group: &Self::Type, action_name: &str, enabled: bool, )94 fn parent_action_enabled_changed(
95 &self,
96 action_group: &Self::Type,
97 action_name: &str,
98 enabled: bool,
99 );
parent_action_removed(&self, action_group: &Self::Type, action_name: &str)100 fn parent_action_removed(&self, action_group: &Self::Type, action_name: &str);
parent_action_state_changed( &self, action_group: &Self::Type, action_name: &str, state: &Variant, )101 fn parent_action_state_changed(
102 &self,
103 action_group: &Self::Type,
104 action_name: &str,
105 state: &Variant,
106 );
parent_activate_action( &self, action_group: &Self::Type, action_name: &str, parameter: Option<&Variant>, )107 fn parent_activate_action(
108 &self,
109 action_group: &Self::Type,
110 action_name: &str,
111 parameter: Option<&Variant>,
112 );
parent_change_action_state( &self, action_group: &Self::Type, action_name: &str, value: &Variant, )113 fn parent_change_action_state(
114 &self,
115 action_group: &Self::Type,
116 action_name: &str,
117 value: &Variant,
118 );
parent_action_is_enabled(&self, action_group: &Self::Type, action_name: &str) -> bool119 fn parent_action_is_enabled(&self, action_group: &Self::Type, action_name: &str) -> bool;
parent_action_parameter_type( &self, action_group: &Self::Type, action_name: &str, ) -> Option<VariantType>120 fn parent_action_parameter_type(
121 &self,
122 action_group: &Self::Type,
123 action_name: &str,
124 ) -> Option<VariantType>;
parent_action_state(&self, action_group: &Self::Type, action_name: &str) -> Option<Variant>125 fn parent_action_state(&self, action_group: &Self::Type, action_name: &str) -> Option<Variant>;
parent_action_state_hint( &self, action_group: &Self::Type, action_name: &str, ) -> Option<Variant>126 fn parent_action_state_hint(
127 &self,
128 action_group: &Self::Type,
129 action_name: &str,
130 ) -> Option<Variant>;
parent_action_state_type( &self, action_group: &Self::Type, action_name: &str, ) -> Option<VariantType>131 fn parent_action_state_type(
132 &self,
133 action_group: &Self::Type,
134 action_name: &str,
135 ) -> Option<VariantType>;
parent_has_action(&self, action_group: &Self::Type, action_name: &str) -> bool136 fn parent_has_action(&self, action_group: &Self::Type, action_name: &str) -> bool;
137
parent_list_actions(&self, action_group: &Self::Type) -> Vec<String>138 fn parent_list_actions(&self, action_group: &Self::Type) -> Vec<String>;
parent_query_action( &self, action_group: &Self::Type, action_name: &str, ) -> Option<( bool, Option<VariantType>, Option<VariantType>, Option<Variant>, Option<Variant>, )>139 fn parent_query_action(
140 &self,
141 action_group: &Self::Type,
142 action_name: &str,
143 ) -> Option<(
144 bool,
145 Option<VariantType>,
146 Option<VariantType>,
147 Option<Variant>,
148 Option<Variant>,
149 )>;
150 }
151
152 impl<T: ActionGroupImpl> ActionGroupImplExt for T {
parent_action_added(&self, action_group: &Self::Type, action_name: &str)153 fn parent_action_added(&self, action_group: &Self::Type, action_name: &str) {
154 unsafe {
155 let type_data = Self::type_data();
156 let parent_iface = type_data.as_ref().parent_interface::<ActionGroup>()
157 as *const ffi::GActionGroupInterface;
158
159 if let Some(func) = (*parent_iface).action_added {
160 func(
161 action_group
162 .unsafe_cast_ref::<ActionGroup>()
163 .to_glib_none()
164 .0,
165 action_name.to_glib_none().0,
166 );
167 }
168 }
169 }
170
parent_action_enabled_changed( &self, action_group: &Self::Type, action_name: &str, enabled: bool, )171 fn parent_action_enabled_changed(
172 &self,
173 action_group: &Self::Type,
174 action_name: &str,
175 enabled: bool,
176 ) {
177 unsafe {
178 let type_data = Self::type_data();
179 let parent_iface = type_data.as_ref().parent_interface::<ActionGroup>()
180 as *const ffi::GActionGroupInterface;
181
182 if let Some(func) = (*parent_iface).action_enabled_changed {
183 func(
184 action_group
185 .unsafe_cast_ref::<ActionGroup>()
186 .to_glib_none()
187 .0,
188 action_name.to_glib_none().0,
189 enabled.into_glib(),
190 );
191 }
192 }
193 }
194
parent_action_removed(&self, action_group: &Self::Type, action_name: &str)195 fn parent_action_removed(&self, action_group: &Self::Type, action_name: &str) {
196 unsafe {
197 let type_data = Self::type_data();
198 let parent_iface = type_data.as_ref().parent_interface::<ActionGroup>()
199 as *const ffi::GActionGroupInterface;
200
201 if let Some(func) = (*parent_iface).action_removed {
202 func(
203 action_group
204 .unsafe_cast_ref::<ActionGroup>()
205 .to_glib_none()
206 .0,
207 action_name.to_glib_none().0,
208 );
209 }
210 }
211 }
212
parent_action_state_changed( &self, action_group: &Self::Type, action_name: &str, state: &Variant, )213 fn parent_action_state_changed(
214 &self,
215 action_group: &Self::Type,
216 action_name: &str,
217 state: &Variant,
218 ) {
219 unsafe {
220 let type_data = Self::type_data();
221 let parent_iface = type_data.as_ref().parent_interface::<ActionGroup>()
222 as *const ffi::GActionGroupInterface;
223
224 if let Some(func) = (*parent_iface).action_state_changed {
225 func(
226 action_group
227 .unsafe_cast_ref::<ActionGroup>()
228 .to_glib_none()
229 .0,
230 action_name.to_glib_none().0,
231 state.to_glib_none().0,
232 );
233 }
234 }
235 }
236
parent_activate_action( &self, action_group: &Self::Type, action_name: &str, parameter: Option<&Variant>, )237 fn parent_activate_action(
238 &self,
239 action_group: &Self::Type,
240 action_name: &str,
241 parameter: Option<&Variant>,
242 ) {
243 unsafe {
244 let type_data = Self::type_data();
245 let parent_iface = type_data.as_ref().parent_interface::<ActionGroup>()
246 as *const ffi::GActionGroupInterface;
247
248 let func = (*parent_iface)
249 .activate_action
250 .expect("no parent \"activate_action\" implementation");
251 func(
252 action_group
253 .unsafe_cast_ref::<ActionGroup>()
254 .to_glib_none()
255 .0,
256 action_name.to_glib_none().0,
257 parameter.to_glib_none().0,
258 );
259 }
260 }
261
parent_change_action_state( &self, action_group: &Self::Type, action_name: &str, value: &Variant, )262 fn parent_change_action_state(
263 &self,
264 action_group: &Self::Type,
265 action_name: &str,
266 value: &Variant,
267 ) {
268 unsafe {
269 let type_data = Self::type_data();
270 let parent_iface = type_data.as_ref().parent_interface::<ActionGroup>()
271 as *const ffi::GActionGroupInterface;
272
273 let func = (*parent_iface)
274 .change_action_state
275 .expect("no parent \"change_action_state\" implementation");
276 func(
277 action_group
278 .unsafe_cast_ref::<ActionGroup>()
279 .to_glib_none()
280 .0,
281 action_name.to_glib_none().0,
282 value.to_glib_none().0,
283 );
284 }
285 }
286
parent_action_is_enabled(&self, action_group: &Self::Type, action_name: &str) -> bool287 fn parent_action_is_enabled(&self, action_group: &Self::Type, action_name: &str) -> bool {
288 unsafe {
289 let type_data = Self::type_data();
290 let parent_iface = type_data.as_ref().parent_interface::<ActionGroup>()
291 as *const ffi::GActionGroupInterface;
292
293 let func = (*parent_iface)
294 .get_action_enabled
295 .expect("no parent \"action_is_enabled\" implementation");
296 let ret = func(
297 action_group
298 .unsafe_cast_ref::<ActionGroup>()
299 .to_glib_none()
300 .0,
301 action_name.to_glib_none().0,
302 );
303 from_glib(ret)
304 }
305 }
306
parent_action_parameter_type( &self, action_group: &Self::Type, action_name: &str, ) -> Option<VariantType>307 fn parent_action_parameter_type(
308 &self,
309 action_group: &Self::Type,
310 action_name: &str,
311 ) -> Option<VariantType> {
312 unsafe {
313 let type_data = Self::type_data();
314 let parent_iface = type_data.as_ref().parent_interface::<ActionGroup>()
315 as *const ffi::GActionGroupInterface;
316
317 let func = (*parent_iface)
318 .get_action_parameter_type
319 .expect("no parent \"get_action_parameter_type\" implementation");
320 let ret = func(
321 action_group
322 .unsafe_cast_ref::<ActionGroup>()
323 .to_glib_none()
324 .0,
325 action_name.to_glib_none().0,
326 );
327 from_glib_none(ret)
328 }
329 }
330
parent_action_state(&self, action_group: &Self::Type, action_name: &str) -> Option<Variant>331 fn parent_action_state(&self, action_group: &Self::Type, action_name: &str) -> Option<Variant> {
332 unsafe {
333 let type_data = Self::type_data();
334 let parent_iface = type_data.as_ref().parent_interface::<ActionGroup>()
335 as *const ffi::GActionGroupInterface;
336
337 let func = (*parent_iface)
338 .get_action_state
339 .expect("no parent \"get_action_state\" implementation");
340 let ret = func(
341 action_group
342 .unsafe_cast_ref::<ActionGroup>()
343 .to_glib_none()
344 .0,
345 action_name.to_glib_none().0,
346 );
347 from_glib_none(ret)
348 }
349 }
350
parent_action_state_hint( &self, action_group: &Self::Type, action_name: &str, ) -> Option<Variant>351 fn parent_action_state_hint(
352 &self,
353 action_group: &Self::Type,
354 action_name: &str,
355 ) -> Option<Variant> {
356 unsafe {
357 let type_data = Self::type_data();
358 let parent_iface = type_data.as_ref().parent_interface::<ActionGroup>()
359 as *const ffi::GActionGroupInterface;
360
361 let func = (*parent_iface)
362 .get_action_state_hint
363 .expect("no parent \"get_action_state_hint\" implementation");
364 let ret = func(
365 action_group
366 .unsafe_cast_ref::<ActionGroup>()
367 .to_glib_none()
368 .0,
369 action_name.to_glib_none().0,
370 );
371 from_glib_none(ret)
372 }
373 }
374
parent_action_state_type( &self, action_group: &Self::Type, action_name: &str, ) -> Option<VariantType>375 fn parent_action_state_type(
376 &self,
377 action_group: &Self::Type,
378 action_name: &str,
379 ) -> Option<VariantType> {
380 unsafe {
381 let type_data = Self::type_data();
382 let parent_iface = type_data.as_ref().parent_interface::<ActionGroup>()
383 as *const ffi::GActionGroupInterface;
384
385 let func = (*parent_iface)
386 .get_action_state_type
387 .expect("no parent \"get_action_state_type\" implementation");
388 let ret = func(
389 action_group
390 .unsafe_cast_ref::<ActionGroup>()
391 .to_glib_none()
392 .0,
393 action_name.to_glib_none().0,
394 );
395 from_glib_none(ret)
396 }
397 }
398
parent_has_action(&self, action_group: &Self::Type, action_name: &str) -> bool399 fn parent_has_action(&self, action_group: &Self::Type, action_name: &str) -> bool {
400 unsafe {
401 let type_data = Self::type_data();
402 let parent_iface = type_data.as_ref().parent_interface::<ActionGroup>()
403 as *const ffi::GActionGroupInterface;
404
405 let func = (*parent_iface)
406 .has_action
407 .expect("no parent \"has_action\" implementation");
408 let ret = func(
409 action_group
410 .unsafe_cast_ref::<ActionGroup>()
411 .to_glib_none()
412 .0,
413 action_name.to_glib_none().0,
414 );
415 from_glib(ret)
416 }
417 }
418
parent_list_actions(&self, action_group: &Self::Type) -> Vec<String>419 fn parent_list_actions(&self, action_group: &Self::Type) -> Vec<String> {
420 unsafe {
421 let type_data = Self::type_data();
422 let parent_iface = type_data.as_ref().parent_interface::<ActionGroup>()
423 as *const ffi::GActionGroupInterface;
424
425 let func = (*parent_iface)
426 .list_actions
427 .expect("no parent \"list_actions\" implementation");
428 let ret = func(
429 action_group
430 .unsafe_cast_ref::<ActionGroup>()
431 .to_glib_none()
432 .0,
433 );
434 FromGlibPtrContainer::from_glib_none(ret)
435 }
436 }
437
parent_query_action( &self, action_group: &Self::Type, action_name: &str, ) -> Option<( bool, Option<VariantType>, Option<VariantType>, Option<Variant>, Option<Variant>, )>438 fn parent_query_action(
439 &self,
440 action_group: &Self::Type,
441 action_name: &str,
442 ) -> Option<(
443 bool,
444 Option<VariantType>,
445 Option<VariantType>,
446 Option<Variant>,
447 Option<Variant>,
448 )> {
449 unsafe {
450 let type_data = Self::type_data();
451 let parent_iface = type_data.as_ref().parent_interface::<ActionGroup>()
452 as *const ffi::GActionGroupInterface;
453
454 let func = (*parent_iface)
455 .query_action
456 .expect("no parent \"query_action\" implementation");
457
458 let mut enabled = mem::MaybeUninit::uninit();
459 let mut parameter_type = ptr::null();
460 let mut state_type = ptr::null();
461 let mut state_hint = ptr::null_mut();
462 let mut state = ptr::null_mut();
463
464 let ret: bool = from_glib(func(
465 action_group
466 .unsafe_cast_ref::<ActionGroup>()
467 .to_glib_none()
468 .0,
469 action_name.to_glib_none().0,
470 enabled.as_mut_ptr(),
471 &mut parameter_type,
472 &mut state_type,
473 &mut state_hint,
474 &mut state,
475 ));
476
477 if !ret {
478 None
479 } else {
480 Some((
481 from_glib(enabled.assume_init()),
482 from_glib_none(parameter_type),
483 from_glib_none(state_type),
484 from_glib_none(state_hint),
485 from_glib_none(state),
486 ))
487 }
488 }
489 }
490 }
491
492 unsafe impl<T: ActionGroupImpl> IsImplementable<T> for ActionGroup {
interface_init(iface: &mut glib::Interface<Self>)493 fn interface_init(iface: &mut glib::Interface<Self>) {
494 let iface = iface.as_mut();
495
496 iface.action_added = Some(action_group_action_added::<T>);
497 iface.action_enabled_changed = Some(action_group_action_enabled_changed::<T>);
498 iface.action_removed = Some(action_group_action_removed::<T>);
499 iface.action_state_changed = Some(action_group_action_state_changed::<T>);
500 iface.activate_action = Some(action_group_activate_action::<T>);
501 iface.change_action_state = Some(action_group_change_action_state::<T>);
502 iface.get_action_enabled = Some(action_group_get_action_enabled::<T>);
503 iface.get_action_parameter_type = Some(action_group_get_action_parameter_type::<T>);
504 iface.get_action_state = Some(action_group_get_action_state::<T>);
505 iface.get_action_state_hint = Some(action_group_get_action_state_hint::<T>);
506 iface.get_action_state_type = Some(action_group_get_action_state_type::<T>);
507 iface.has_action = Some(action_group_has_action::<T>);
508 iface.list_actions = Some(action_group_list_actions::<T>);
509 iface.query_action = Some(action_group_query_action::<T>);
510 }
511
instance_init(_instance: &mut glib::subclass::InitializingObject<T>)512 fn instance_init(_instance: &mut glib::subclass::InitializingObject<T>) {}
513 }
514
action_group_has_action<T: ActionGroupImpl>( action_group: *mut ffi::GActionGroup, action_nameptr: *const libc::c_char, ) -> glib::ffi::gboolean515 unsafe extern "C" fn action_group_has_action<T: ActionGroupImpl>(
516 action_group: *mut ffi::GActionGroup,
517 action_nameptr: *const libc::c_char,
518 ) -> glib::ffi::gboolean {
519 let instance = &*(action_group as *mut T::Instance);
520 let action_name = GString::from_glib_borrow(action_nameptr);
521 let imp = instance.impl_();
522
523 imp.has_action(
524 from_glib_borrow::<_, ActionGroup>(action_group).unsafe_cast_ref(),
525 &action_name,
526 )
527 .into_glib()
528 }
529
action_group_get_action_enabled<T: ActionGroupImpl>( action_group: *mut ffi::GActionGroup, action_nameptr: *const libc::c_char, ) -> glib::ffi::gboolean530 unsafe extern "C" fn action_group_get_action_enabled<T: ActionGroupImpl>(
531 action_group: *mut ffi::GActionGroup,
532 action_nameptr: *const libc::c_char,
533 ) -> glib::ffi::gboolean {
534 let instance = &*(action_group as *mut T::Instance);
535 let imp = instance.impl_();
536 let action_name = GString::from_glib_borrow(action_nameptr);
537
538 imp.action_is_enabled(
539 from_glib_borrow::<_, ActionGroup>(action_group).unsafe_cast_ref(),
540 &action_name,
541 )
542 .into_glib()
543 }
544
545 /// Struct to hold a pointer and free it on `Drop::drop`
546 struct PtrHolder<T, F: Fn(*mut T) + 'static>(*mut T, F);
547
548 impl<T, F: Fn(*mut T) + 'static> Drop for PtrHolder<T, F> {
drop(&mut self)549 fn drop(&mut self) {
550 (self.1)(self.0)
551 }
552 }
553
554 static ACTION_GROUP_GET_ACTION_PARAMETER_QUARK: Lazy<Quark> =
555 Lazy::new(|| Quark::from_string("gtk-rs-subclass-action-group-get-action-parameter"));
556
action_group_get_action_parameter_type<T: ActionGroupImpl>( action_group: *mut ffi::GActionGroup, action_nameptr: *const libc::c_char, ) -> *const glib::ffi::GVariantType557 unsafe extern "C" fn action_group_get_action_parameter_type<T: ActionGroupImpl>(
558 action_group: *mut ffi::GActionGroup,
559 action_nameptr: *const libc::c_char,
560 ) -> *const glib::ffi::GVariantType {
561 let instance = &*(action_group as *mut T::Instance);
562 let imp = instance.impl_();
563 let action_name = GString::from_glib_borrow(action_nameptr);
564 let wrap = from_glib_borrow::<_, ActionGroup>(action_group);
565
566 let ret = imp.action_parameter_type(wrap.unsafe_cast_ref(), &action_name);
567
568 if let Some(param_type) = ret {
569 let param_type = param_type.to_glib_full();
570 wrap.set_qdata(
571 *ACTION_GROUP_GET_ACTION_PARAMETER_QUARK,
572 PtrHolder(param_type, |ptr| glib::ffi::g_free(ptr as *mut _)),
573 );
574 param_type
575 } else {
576 ptr::null()
577 }
578 }
579
580 static ACTION_GROUP_GET_ACTION_STATE_TYPE_QUARK: Lazy<Quark> =
581 Lazy::new(|| Quark::from_string("gtk-rs-subclass-action-group-get-action-state-type"));
582
action_group_get_action_state_type<T: ActionGroupImpl>( action_group: *mut ffi::GActionGroup, action_nameptr: *const libc::c_char, ) -> *const glib::ffi::GVariantType583 unsafe extern "C" fn action_group_get_action_state_type<T: ActionGroupImpl>(
584 action_group: *mut ffi::GActionGroup,
585 action_nameptr: *const libc::c_char,
586 ) -> *const glib::ffi::GVariantType {
587 let instance = &*(action_group as *mut T::Instance);
588 let imp = instance.impl_();
589 let action_name = GString::from_glib_borrow(action_nameptr);
590 let wrap = from_glib_borrow::<_, ActionGroup>(action_group);
591
592 let ret = imp.action_state_type(wrap.unsafe_cast_ref(), &action_name);
593
594 if let Some(state_type) = ret {
595 let state_type = state_type.to_glib_full();
596 wrap.set_qdata(
597 *ACTION_GROUP_GET_ACTION_STATE_TYPE_QUARK,
598 PtrHolder(state_type, |ptr| glib::ffi::g_free(ptr as *mut _)),
599 );
600 state_type
601 } else {
602 ptr::null()
603 }
604 }
605
606 static ACTION_GROUP_GET_ACTION_STATE_HINT_QUARK: Lazy<Quark> =
607 Lazy::new(|| Quark::from_string("gtk-rs-subclass-action-group-get-action-state-hint"));
608
action_group_get_action_state_hint<T: ActionGroupImpl>( action_group: *mut ffi::GActionGroup, action_nameptr: *const libc::c_char, ) -> *mut glib::ffi::GVariant609 unsafe extern "C" fn action_group_get_action_state_hint<T: ActionGroupImpl>(
610 action_group: *mut ffi::GActionGroup,
611 action_nameptr: *const libc::c_char,
612 ) -> *mut glib::ffi::GVariant {
613 let instance = &*(action_group as *mut T::Instance);
614 let imp = instance.impl_();
615 let action_name = GString::from_glib_borrow(action_nameptr);
616
617 let wrap = from_glib_borrow::<_, ActionGroup>(action_group);
618
619 let ret = imp.action_state_hint(wrap.unsafe_cast_ref(), &action_name);
620 if let Some(state_hint) = ret {
621 let state_hint_ptr = state_hint.to_glib_full();
622 wrap.set_qdata(
623 *ACTION_GROUP_GET_ACTION_STATE_HINT_QUARK,
624 PtrHolder(state_hint_ptr, |ptr| glib::ffi::g_variant_unref(ptr)),
625 );
626 state_hint_ptr
627 } else {
628 ptr::null_mut()
629 }
630 }
631 static ACTION_GROUP_GET_ACTION_STATE_QUARK: Lazy<Quark> =
632 Lazy::new(|| Quark::from_string("gtk-rs-subclass-action-group-get-action-state"));
633
action_group_get_action_state<T: ActionGroupImpl>( action_group: *mut ffi::GActionGroup, action_nameptr: *const libc::c_char, ) -> *mut glib::ffi::GVariant634 unsafe extern "C" fn action_group_get_action_state<T: ActionGroupImpl>(
635 action_group: *mut ffi::GActionGroup,
636 action_nameptr: *const libc::c_char,
637 ) -> *mut glib::ffi::GVariant {
638 let instance = &*(action_group as *mut T::Instance);
639 let imp = instance.impl_();
640 let action_name = GString::from_glib_borrow(action_nameptr);
641 let wrap = from_glib_borrow::<_, ActionGroup>(action_group);
642
643 let ret = imp.action_state(wrap.unsafe_cast_ref(), &action_name);
644 if let Some(state) = ret {
645 let state_ptr = state.to_glib_full();
646 wrap.set_qdata(
647 *ACTION_GROUP_GET_ACTION_STATE_QUARK,
648 PtrHolder(state_ptr, |ptr| glib::ffi::g_variant_unref(ptr)),
649 );
650 state_ptr
651 } else {
652 ptr::null_mut()
653 }
654 }
655
action_group_change_action_state<T: ActionGroupImpl>( action_group: *mut ffi::GActionGroup, action_nameptr: *const libc::c_char, stateptr: *mut glib::ffi::GVariant, )656 unsafe extern "C" fn action_group_change_action_state<T: ActionGroupImpl>(
657 action_group: *mut ffi::GActionGroup,
658 action_nameptr: *const libc::c_char,
659 stateptr: *mut glib::ffi::GVariant,
660 ) {
661 let instance = &*(action_group as *mut T::Instance);
662 let imp = instance.impl_();
663 let action_name = GString::from_glib_borrow(action_nameptr);
664 let state = Variant::from_glib_borrow(stateptr);
665
666 imp.change_action_state(
667 from_glib_borrow::<_, ActionGroup>(action_group).unsafe_cast_ref(),
668 &action_name,
669 &state,
670 )
671 }
672
action_group_activate_action<T: ActionGroupImpl>( action_group: *mut ffi::GActionGroup, action_nameptr: *const libc::c_char, parameterptr: *mut glib::ffi::GVariant, )673 unsafe extern "C" fn action_group_activate_action<T: ActionGroupImpl>(
674 action_group: *mut ffi::GActionGroup,
675 action_nameptr: *const libc::c_char,
676 parameterptr: *mut glib::ffi::GVariant,
677 ) {
678 let instance = &*(action_group as *mut T::Instance);
679 let imp = instance.impl_();
680 let action_name = GString::from_glib_borrow(action_nameptr);
681 let param: Borrowed<Option<Variant>> = from_glib_borrow(parameterptr);
682
683 imp.activate_action(
684 from_glib_borrow::<_, ActionGroup>(action_group).unsafe_cast_ref(),
685 &action_name,
686 param.as_ref().as_ref(),
687 )
688 }
689
action_group_action_added<T: ActionGroupImpl>( action_group: *mut ffi::GActionGroup, action_nameptr: *const libc::c_char, )690 unsafe extern "C" fn action_group_action_added<T: ActionGroupImpl>(
691 action_group: *mut ffi::GActionGroup,
692 action_nameptr: *const libc::c_char,
693 ) {
694 let instance = &*(action_group as *mut T::Instance);
695 let imp = instance.impl_();
696 let action_name = GString::from_glib_borrow(action_nameptr);
697
698 imp.action_added(
699 from_glib_borrow::<_, ActionGroup>(action_group).unsafe_cast_ref(),
700 &action_name,
701 )
702 }
703
action_group_action_removed<T: ActionGroupImpl>( action_group: *mut ffi::GActionGroup, action_nameptr: *const libc::c_char, )704 unsafe extern "C" fn action_group_action_removed<T: ActionGroupImpl>(
705 action_group: *mut ffi::GActionGroup,
706 action_nameptr: *const libc::c_char,
707 ) {
708 let instance = &*(action_group as *mut T::Instance);
709 let imp = instance.impl_();
710 let action_name = GString::from_glib_borrow(action_nameptr);
711
712 imp.action_removed(
713 from_glib_borrow::<_, ActionGroup>(action_group).unsafe_cast_ref(),
714 &action_name,
715 )
716 }
717
action_group_action_enabled_changed<T: ActionGroupImpl>( action_group: *mut ffi::GActionGroup, action_nameptr: *const libc::c_char, enabled: glib::ffi::gboolean, )718 unsafe extern "C" fn action_group_action_enabled_changed<T: ActionGroupImpl>(
719 action_group: *mut ffi::GActionGroup,
720 action_nameptr: *const libc::c_char,
721 enabled: glib::ffi::gboolean,
722 ) {
723 let instance = &*(action_group as *mut T::Instance);
724 let imp = instance.impl_();
725 let action_name = GString::from_glib_borrow(action_nameptr);
726
727 imp.action_enabled_changed(
728 from_glib_borrow::<_, ActionGroup>(action_group).unsafe_cast_ref(),
729 &action_name,
730 from_glib(enabled),
731 )
732 }
733
action_group_action_state_changed<T: ActionGroupImpl>( action_group: *mut ffi::GActionGroup, action_nameptr: *const libc::c_char, stateptr: *mut glib::ffi::GVariant, )734 unsafe extern "C" fn action_group_action_state_changed<T: ActionGroupImpl>(
735 action_group: *mut ffi::GActionGroup,
736 action_nameptr: *const libc::c_char,
737 stateptr: *mut glib::ffi::GVariant,
738 ) {
739 let instance = &*(action_group as *mut T::Instance);
740 let imp = instance.impl_();
741 let action_name = GString::from_glib_borrow(action_nameptr);
742 let state = Variant::from_glib_borrow(stateptr);
743
744 imp.action_state_changed(
745 from_glib_borrow::<_, ActionGroup>(action_group).unsafe_cast_ref(),
746 &action_name,
747 &state,
748 )
749 }
750
751 static ACTION_GROUP_LIST_ACTIONS_QUARK: Lazy<Quark> =
752 Lazy::new(|| Quark::from_string("gtk-rs-subclass-action-group-list-actions"));
753
action_group_list_actions<T: ActionGroupImpl>( action_group: *mut ffi::GActionGroup, ) -> *mut *mut libc::c_char754 unsafe extern "C" fn action_group_list_actions<T: ActionGroupImpl>(
755 action_group: *mut ffi::GActionGroup,
756 ) -> *mut *mut libc::c_char {
757 let instance = &*(action_group as *mut T::Instance);
758 let imp = instance.impl_();
759 let wrap = from_glib_borrow::<_, ActionGroup>(action_group);
760
761 let actions = imp.list_actions(wrap.unsafe_cast_ref());
762
763 {
764 let actionsptr = actions.to_glib_full();
765 wrap.set_qdata(*ACTION_GROUP_LIST_ACTIONS_QUARK, actionsptr);
766 actionsptr
767 }
768 }
769
770 static ACTION_GROUP_QUERY_ACTION_PARAM_TYPE_QUARK: Lazy<Quark> =
771 Lazy::new(|| Quark::from_string("gtk-rs-subclass-action-group-query-action-parameter-type"));
772
773 static ACTION_GROUP_QUERY_ACTION_STATE_TYPE_QUARK: Lazy<Quark> =
774 Lazy::new(|| Quark::from_string("gtk-rs-subclass-action-group-query-action-state-type"));
775
776 static ACTION_GROUP_QUERY_ACTION_STATE_HINT_QUARK: Lazy<Quark> =
777 Lazy::new(|| Quark::from_string("gtk-rs-subclass-action-group-query-action-state-hint"));
778
779 static ACTION_GROUP_QUERY_ACTION_STATE_QUARK: Lazy<Quark> =
780 Lazy::new(|| Quark::from_string("gtk-rs-subclass-action-group-query-action-state"));
781
action_group_query_action<T: ActionGroupImpl>( action_group: *mut ffi::GActionGroup, action_nameptr: *const libc::c_char, enabled: *mut glib::ffi::gboolean, parameter_type: *mut *const glib::ffi::GVariantType, state_type: *mut *const glib::ffi::GVariantType, state_hint: *mut *mut glib::ffi::GVariant, state: *mut *mut glib::ffi::GVariant, ) -> glib::ffi::gboolean782 unsafe extern "C" fn action_group_query_action<T: ActionGroupImpl>(
783 action_group: *mut ffi::GActionGroup,
784 action_nameptr: *const libc::c_char,
785 enabled: *mut glib::ffi::gboolean,
786 parameter_type: *mut *const glib::ffi::GVariantType,
787 state_type: *mut *const glib::ffi::GVariantType,
788 state_hint: *mut *mut glib::ffi::GVariant,
789 state: *mut *mut glib::ffi::GVariant,
790 ) -> glib::ffi::gboolean {
791 let instance = &*(action_group as *mut T::Instance);
792 let imp = instance.impl_();
793 let action_name = GString::from_glib_borrow(action_nameptr);
794 let wrap = from_glib_borrow::<_, ActionGroup>(action_group);
795
796 let ret = imp.query_action(wrap.unsafe_cast_ref(), &action_name);
797 if let Some((rs_enabled, rs_parameter_type, rs_state_type, rs_state_hint, rs_state)) = ret {
798 if !enabled.is_null() {
799 *enabled = rs_enabled.into_glib();
800 }
801 if !parameter_type.is_null() {
802 if let Some(rs_parameter_type) = rs_parameter_type {
803 let ret = rs_parameter_type.to_glib_full();
804 wrap.set_qdata(
805 *ACTION_GROUP_QUERY_ACTION_PARAM_TYPE_QUARK,
806 PtrHolder(ret, |ptr| glib::ffi::g_free(ptr as *mut _)),
807 );
808 *parameter_type = ret;
809 } else {
810 *parameter_type = ptr::null_mut();
811 }
812 }
813 if !state_type.is_null() {
814 if let Some(rs_state_type) = rs_state_type {
815 let ret = rs_state_type.to_glib_full();
816 wrap.set_qdata(
817 *ACTION_GROUP_QUERY_ACTION_STATE_TYPE_QUARK,
818 PtrHolder(ret, |ptr| glib::ffi::g_free(ptr as *mut _)),
819 );
820 *state_type = ret;
821 } else {
822 *state_type = ptr::null_mut();
823 }
824 }
825 if !state_hint.is_null() {
826 if let Some(rs_state_hint) = rs_state_hint {
827 let ret = rs_state_hint.to_glib_full();
828 wrap.set_qdata(
829 *ACTION_GROUP_QUERY_ACTION_STATE_HINT_QUARK,
830 PtrHolder(ret, |ptr| glib::ffi::g_variant_unref(ptr)),
831 );
832 *state_hint = ret;
833 } else {
834 *state_hint = ptr::null_mut();
835 }
836 }
837 if !state.is_null() {
838 if let Some(rs_state) = rs_state {
839 let ret = rs_state.to_glib_full();
840 wrap.set_qdata(
841 *ACTION_GROUP_QUERY_ACTION_STATE_QUARK,
842 PtrHolder(ret, |ptr| glib::ffi::g_variant_unref(ptr)),
843 );
844 *state = ret;
845 } else {
846 *state = ptr::null_mut();
847 }
848 }
849 true
850 } else {
851 false
852 }
853 .into_glib()
854 }
855