gio/subclass/
action_group.rs

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