1use 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
389struct 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}