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 static ACTION_GROUP_GET_ACTION_PARAMETER_QUARK: Lazy<Quark> =
546 Lazy::new(|| Quark::from_string("gtk-rs-subclass-action-group-get-action-parameter"));
547
action_group_get_action_parameter_type<T: ActionGroupImpl>( action_group: *mut ffi::GActionGroup, action_nameptr: *const libc::c_char, ) -> *const glib::ffi::GVariantType548 unsafe extern "C" fn action_group_get_action_parameter_type<T: ActionGroupImpl>(
549 action_group: *mut ffi::GActionGroup,
550 action_nameptr: *const libc::c_char,
551 ) -> *const glib::ffi::GVariantType {
552 let instance = &*(action_group as *mut T::Instance);
553 let imp = instance.impl_();
554 let action_name = GString::from_glib_borrow(action_nameptr);
555 let wrap = from_glib_borrow::<_, ActionGroup>(action_group);
556
557 let ret = imp.action_parameter_type(wrap.unsafe_cast_ref(), &action_name);
558
559 if let Some(param_type) = ret {
560 let param_type = param_type.to_glib_full();
561 wrap.set_qdata(*ACTION_GROUP_GET_ACTION_PARAMETER_QUARK, param_type);
562 param_type
563 } else {
564 ptr::null()
565 }
566 }
567
568 static ACTION_GROUP_GET_ACTION_STATE_TYPE_QUARK: Lazy<Quark> =
569 Lazy::new(|| Quark::from_string("gtk-rs-subclass-action-group-get-action-state-type"));
570
action_group_get_action_state_type<T: ActionGroupImpl>( action_group: *mut ffi::GActionGroup, action_nameptr: *const libc::c_char, ) -> *const glib::ffi::GVariantType571 unsafe extern "C" fn action_group_get_action_state_type<T: ActionGroupImpl>(
572 action_group: *mut ffi::GActionGroup,
573 action_nameptr: *const libc::c_char,
574 ) -> *const glib::ffi::GVariantType {
575 let instance = &*(action_group as *mut T::Instance);
576 let imp = instance.impl_();
577 let action_name = GString::from_glib_borrow(action_nameptr);
578 let wrap = from_glib_borrow::<_, ActionGroup>(action_group);
579
580 let ret = imp.action_state_type(wrap.unsafe_cast_ref(), &action_name);
581
582 if let Some(state_type) = ret {
583 let state_type = state_type.to_glib_full();
584 wrap.set_qdata(*ACTION_GROUP_GET_ACTION_STATE_TYPE_QUARK, state_type);
585 state_type
586 } else {
587 ptr::null()
588 }
589 }
590
591 static ACTION_GROUP_GET_ACTION_STATE_HINT_QUARK: Lazy<Quark> =
592 Lazy::new(|| Quark::from_string("gtk-rs-subclass-action-group-get-action-state-hint"));
593
action_group_get_action_state_hint<T: ActionGroupImpl>( action_group: *mut ffi::GActionGroup, action_nameptr: *const libc::c_char, ) -> *mut glib::ffi::GVariant594 unsafe extern "C" fn action_group_get_action_state_hint<T: ActionGroupImpl>(
595 action_group: *mut ffi::GActionGroup,
596 action_nameptr: *const libc::c_char,
597 ) -> *mut glib::ffi::GVariant {
598 let instance = &*(action_group as *mut T::Instance);
599 let imp = instance.impl_();
600 let action_name = GString::from_glib_borrow(action_nameptr);
601
602 let wrap = from_glib_borrow::<_, ActionGroup>(action_group);
603
604 let ret = imp.action_state_hint(wrap.unsafe_cast_ref(), &action_name);
605 if let Some(state_hint) = ret {
606 let state_hint_ptr = state_hint.to_glib_full();
607 wrap.set_qdata(*ACTION_GROUP_GET_ACTION_STATE_HINT_QUARK, state_hint_ptr);
608 state_hint_ptr
609 } else {
610 ptr::null_mut()
611 }
612 }
613 static ACTION_GROUP_GET_ACTION_STATE_QUARK: Lazy<Quark> =
614 Lazy::new(|| Quark::from_string("gtk-rs-subclass-action-group-get-action-state"));
615
action_group_get_action_state<T: ActionGroupImpl>( action_group: *mut ffi::GActionGroup, action_nameptr: *const libc::c_char, ) -> *mut glib::ffi::GVariant616 unsafe extern "C" fn action_group_get_action_state<T: ActionGroupImpl>(
617 action_group: *mut ffi::GActionGroup,
618 action_nameptr: *const libc::c_char,
619 ) -> *mut glib::ffi::GVariant {
620 let instance = &*(action_group as *mut T::Instance);
621 let imp = instance.impl_();
622 let action_name = GString::from_glib_borrow(action_nameptr);
623 let wrap = from_glib_borrow::<_, ActionGroup>(action_group);
624
625 let ret = imp.action_state(wrap.unsafe_cast_ref(), &action_name);
626 if let Some(state) = ret {
627 let state_ptr = state.to_glib_full();
628 wrap.set_qdata(*ACTION_GROUP_GET_ACTION_STATE_QUARK, state_ptr);
629 state_ptr
630 } else {
631 ptr::null_mut()
632 }
633 }
634
action_group_change_action_state<T: ActionGroupImpl>( action_group: *mut ffi::GActionGroup, action_nameptr: *const libc::c_char, stateptr: *mut glib::ffi::GVariant, )635 unsafe extern "C" fn action_group_change_action_state<T: ActionGroupImpl>(
636 action_group: *mut ffi::GActionGroup,
637 action_nameptr: *const libc::c_char,
638 stateptr: *mut glib::ffi::GVariant,
639 ) {
640 let instance = &*(action_group as *mut T::Instance);
641 let imp = instance.impl_();
642 let action_name = GString::from_glib_borrow(action_nameptr);
643 let state = Variant::from_glib_borrow(stateptr);
644
645 imp.change_action_state(
646 from_glib_borrow::<_, ActionGroup>(action_group).unsafe_cast_ref(),
647 &action_name,
648 &state,
649 )
650 }
651
action_group_activate_action<T: ActionGroupImpl>( action_group: *mut ffi::GActionGroup, action_nameptr: *const libc::c_char, parameterptr: *mut glib::ffi::GVariant, )652 unsafe extern "C" fn action_group_activate_action<T: ActionGroupImpl>(
653 action_group: *mut ffi::GActionGroup,
654 action_nameptr: *const libc::c_char,
655 parameterptr: *mut glib::ffi::GVariant,
656 ) {
657 let instance = &*(action_group as *mut T::Instance);
658 let imp = instance.impl_();
659 let action_name = GString::from_glib_borrow(action_nameptr);
660 let param: Borrowed<Option<Variant>> = from_glib_borrow(parameterptr);
661
662 imp.activate_action(
663 from_glib_borrow::<_, ActionGroup>(action_group).unsafe_cast_ref(),
664 &action_name,
665 param.as_ref().as_ref(),
666 )
667 }
668
action_group_action_added<T: ActionGroupImpl>( action_group: *mut ffi::GActionGroup, action_nameptr: *const libc::c_char, )669 unsafe extern "C" fn action_group_action_added<T: ActionGroupImpl>(
670 action_group: *mut ffi::GActionGroup,
671 action_nameptr: *const libc::c_char,
672 ) {
673 let instance = &*(action_group as *mut T::Instance);
674 let imp = instance.impl_();
675 let action_name = GString::from_glib_borrow(action_nameptr);
676
677 imp.action_added(
678 from_glib_borrow::<_, ActionGroup>(action_group).unsafe_cast_ref(),
679 &action_name,
680 )
681 }
682
action_group_action_removed<T: ActionGroupImpl>( action_group: *mut ffi::GActionGroup, action_nameptr: *const libc::c_char, )683 unsafe extern "C" fn action_group_action_removed<T: ActionGroupImpl>(
684 action_group: *mut ffi::GActionGroup,
685 action_nameptr: *const libc::c_char,
686 ) {
687 let instance = &*(action_group as *mut T::Instance);
688 let imp = instance.impl_();
689 let action_name = GString::from_glib_borrow(action_nameptr);
690
691 imp.action_removed(
692 from_glib_borrow::<_, ActionGroup>(action_group).unsafe_cast_ref(),
693 &action_name,
694 )
695 }
696
action_group_action_enabled_changed<T: ActionGroupImpl>( action_group: *mut ffi::GActionGroup, action_nameptr: *const libc::c_char, enabled: glib::ffi::gboolean, )697 unsafe extern "C" fn action_group_action_enabled_changed<T: ActionGroupImpl>(
698 action_group: *mut ffi::GActionGroup,
699 action_nameptr: *const libc::c_char,
700 enabled: glib::ffi::gboolean,
701 ) {
702 let instance = &*(action_group as *mut T::Instance);
703 let imp = instance.impl_();
704 let action_name = GString::from_glib_borrow(action_nameptr);
705
706 imp.action_enabled_changed(
707 from_glib_borrow::<_, ActionGroup>(action_group).unsafe_cast_ref(),
708 &action_name,
709 from_glib(enabled),
710 )
711 }
712
action_group_action_state_changed<T: ActionGroupImpl>( action_group: *mut ffi::GActionGroup, action_nameptr: *const libc::c_char, stateptr: *mut glib::ffi::GVariant, )713 unsafe extern "C" fn action_group_action_state_changed<T: ActionGroupImpl>(
714 action_group: *mut ffi::GActionGroup,
715 action_nameptr: *const libc::c_char,
716 stateptr: *mut glib::ffi::GVariant,
717 ) {
718 let instance = &*(action_group as *mut T::Instance);
719 let imp = instance.impl_();
720 let action_name = GString::from_glib_borrow(action_nameptr);
721 let state = Variant::from_glib_borrow(stateptr);
722
723 imp.action_state_changed(
724 from_glib_borrow::<_, ActionGroup>(action_group).unsafe_cast_ref(),
725 &action_name,
726 &state,
727 )
728 }
729
730 static ACTION_GROUP_LIST_ACTIONS_QUARK: Lazy<Quark> =
731 Lazy::new(|| Quark::from_string("gtk-rs-subclass-action-group-list-actions"));
732
action_group_list_actions<T: ActionGroupImpl>( action_group: *mut ffi::GActionGroup, ) -> *mut *mut libc::c_char733 unsafe extern "C" fn action_group_list_actions<T: ActionGroupImpl>(
734 action_group: *mut ffi::GActionGroup,
735 ) -> *mut *mut libc::c_char {
736 let instance = &*(action_group as *mut T::Instance);
737 let imp = instance.impl_();
738 let wrap = from_glib_borrow::<_, ActionGroup>(action_group);
739
740 let actions = imp.list_actions(wrap.unsafe_cast_ref());
741
742 {
743 let actionsptr = actions.to_glib_full();
744 wrap.set_qdata(*ACTION_GROUP_LIST_ACTIONS_QUARK, actionsptr);
745 actionsptr
746 }
747 }
748
749 static ACTION_GROUP_QUERY_ACTION_PARAM_TYPE_QUARK: Lazy<Quark> =
750 Lazy::new(|| Quark::from_string("gtk-rs-subclass-action-group-query-action-parameter-type"));
751
752 static ACTION_GROUP_QUERY_ACTION_STATE_TYPE_QUARK: Lazy<Quark> =
753 Lazy::new(|| Quark::from_string("gtk-rs-subclass-action-group-query-action-state-type"));
754
755 static ACTION_GROUP_QUERY_ACTION_STATE_HINT_QUARK: Lazy<Quark> =
756 Lazy::new(|| Quark::from_string("gtk-rs-subclass-action-group-query-action-state-hint"));
757
758 static ACTION_GROUP_QUERY_ACTION_STATE_QUARK: Lazy<Quark> =
759 Lazy::new(|| Quark::from_string("gtk-rs-subclass-action-group-query-action-state"));
760
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::gboolean761 unsafe extern "C" fn action_group_query_action<T: ActionGroupImpl>(
762 action_group: *mut ffi::GActionGroup,
763 action_nameptr: *const libc::c_char,
764 enabled: *mut glib::ffi::gboolean,
765 parameter_type: *mut *const glib::ffi::GVariantType,
766 state_type: *mut *const glib::ffi::GVariantType,
767 state_hint: *mut *mut glib::ffi::GVariant,
768 state: *mut *mut glib::ffi::GVariant,
769 ) -> glib::ffi::gboolean {
770 let instance = &*(action_group as *mut T::Instance);
771 let imp = instance.impl_();
772 let action_name = GString::from_glib_borrow(action_nameptr);
773 let wrap = from_glib_borrow::<_, ActionGroup>(action_group);
774
775 let ret = imp.query_action(wrap.unsafe_cast_ref(), &action_name);
776 if let Some((rs_enabled, rs_parameter_type, rs_state_type, rs_state_hint, rs_state)) = ret {
777 if !enabled.is_null() {
778 *enabled = rs_enabled.into_glib();
779 }
780 if !parameter_type.is_null() {
781 if let Some(rs_parameter_type) = rs_parameter_type {
782 let ret = rs_parameter_type.to_glib_full();
783 wrap.set_qdata(*ACTION_GROUP_QUERY_ACTION_PARAM_TYPE_QUARK, ret);
784 *parameter_type = ret;
785 } else {
786 *parameter_type = ptr::null_mut();
787 }
788 }
789 if !state_type.is_null() {
790 if let Some(rs_state_type) = rs_state_type {
791 let ret = rs_state_type.to_glib_full();
792 wrap.set_qdata(*ACTION_GROUP_QUERY_ACTION_STATE_TYPE_QUARK, ret);
793 *state_type = ret;
794 } else {
795 *state_type = ptr::null_mut();
796 }
797 }
798 if !state_hint.is_null() {
799 if let Some(rs_state_hint) = rs_state_hint {
800 let ret = rs_state_hint.to_glib_full();
801 wrap.set_qdata(*ACTION_GROUP_QUERY_ACTION_STATE_HINT_QUARK, ret);
802 *state_hint = ret;
803 } else {
804 *state_hint = ptr::null_mut();
805 }
806 }
807 if !state.is_null() {
808 if let Some(rs_state) = rs_state {
809 let ret = rs_state.to_glib_full();
810 wrap.set_qdata(*ACTION_GROUP_QUERY_ACTION_STATE_QUARK, ret);
811 *state = ret;
812 } else {
813 *state = ptr::null_mut();
814 }
815 }
816 true
817 } else {
818 false
819 }
820 .into_glib()
821 }
822