gio/auto/
action_group.rs

1// This file was generated by gir (https://github.com/gtk-rs/gir)
2// from gir-files (https://github.com/gtk-rs/gir-files)
3// DO NOT EDIT
4
5use crate::ffi;
6use glib::{
7    object::ObjectType as _,
8    prelude::*,
9    signal::{connect_raw, SignalHandlerId},
10    translate::*,
11};
12use std::boxed::Box as Box_;
13
14glib::wrapper! {
15    #[doc(alias = "GActionGroup")]
16    pub struct ActionGroup(Interface<ffi::GActionGroup, ffi::GActionGroupInterface>);
17
18    match fn {
19        type_ => || ffi::g_action_group_get_type(),
20    }
21}
22
23impl ActionGroup {
24    pub const NONE: Option<&'static ActionGroup> = None;
25}
26
27mod sealed {
28    pub trait Sealed {}
29    impl<T: super::IsA<super::ActionGroup>> Sealed for T {}
30}
31
32pub trait ActionGroupExt: IsA<ActionGroup> + sealed::Sealed + 'static {
33    #[doc(alias = "g_action_group_action_added")]
34    fn action_added(&self, action_name: &str) {
35        unsafe {
36            ffi::g_action_group_action_added(
37                self.as_ref().to_glib_none().0,
38                action_name.to_glib_none().0,
39            );
40        }
41    }
42
43    #[doc(alias = "g_action_group_action_enabled_changed")]
44    fn action_enabled_changed(&self, action_name: &str, enabled: bool) {
45        unsafe {
46            ffi::g_action_group_action_enabled_changed(
47                self.as_ref().to_glib_none().0,
48                action_name.to_glib_none().0,
49                enabled.into_glib(),
50            );
51        }
52    }
53
54    #[doc(alias = "g_action_group_action_removed")]
55    fn action_removed(&self, action_name: &str) {
56        unsafe {
57            ffi::g_action_group_action_removed(
58                self.as_ref().to_glib_none().0,
59                action_name.to_glib_none().0,
60            );
61        }
62    }
63
64    #[doc(alias = "g_action_group_action_state_changed")]
65    fn action_state_changed(&self, action_name: &str, state: &glib::Variant) {
66        unsafe {
67            ffi::g_action_group_action_state_changed(
68                self.as_ref().to_glib_none().0,
69                action_name.to_glib_none().0,
70                state.to_glib_none().0,
71            );
72        }
73    }
74
75    #[doc(alias = "g_action_group_activate_action")]
76    fn activate_action(&self, action_name: &str, parameter: Option<&glib::Variant>) {
77        unsafe {
78            ffi::g_action_group_activate_action(
79                self.as_ref().to_glib_none().0,
80                action_name.to_glib_none().0,
81                parameter.to_glib_none().0,
82            );
83        }
84    }
85
86    #[doc(alias = "g_action_group_change_action_state")]
87    fn change_action_state(&self, action_name: &str, value: &glib::Variant) {
88        unsafe {
89            ffi::g_action_group_change_action_state(
90                self.as_ref().to_glib_none().0,
91                action_name.to_glib_none().0,
92                value.to_glib_none().0,
93            );
94        }
95    }
96
97    #[doc(alias = "g_action_group_get_action_enabled")]
98    #[doc(alias = "get_action_enabled")]
99    fn is_action_enabled(&self, action_name: &str) -> bool {
100        unsafe {
101            from_glib(ffi::g_action_group_get_action_enabled(
102                self.as_ref().to_glib_none().0,
103                action_name.to_glib_none().0,
104            ))
105        }
106    }
107
108    #[doc(alias = "g_action_group_get_action_parameter_type")]
109    #[doc(alias = "get_action_parameter_type")]
110    fn action_parameter_type(&self, action_name: &str) -> Option<glib::VariantType> {
111        unsafe {
112            from_glib_none(ffi::g_action_group_get_action_parameter_type(
113                self.as_ref().to_glib_none().0,
114                action_name.to_glib_none().0,
115            ))
116        }
117    }
118
119    #[doc(alias = "g_action_group_get_action_state")]
120    #[doc(alias = "get_action_state")]
121    fn action_state(&self, action_name: &str) -> Option<glib::Variant> {
122        unsafe {
123            from_glib_full(ffi::g_action_group_get_action_state(
124                self.as_ref().to_glib_none().0,
125                action_name.to_glib_none().0,
126            ))
127        }
128    }
129
130    #[doc(alias = "g_action_group_get_action_state_hint")]
131    #[doc(alias = "get_action_state_hint")]
132    fn action_state_hint(&self, action_name: &str) -> Option<glib::Variant> {
133        unsafe {
134            from_glib_full(ffi::g_action_group_get_action_state_hint(
135                self.as_ref().to_glib_none().0,
136                action_name.to_glib_none().0,
137            ))
138        }
139    }
140
141    #[doc(alias = "g_action_group_get_action_state_type")]
142    #[doc(alias = "get_action_state_type")]
143    fn action_state_type(&self, action_name: &str) -> Option<glib::VariantType> {
144        unsafe {
145            from_glib_none(ffi::g_action_group_get_action_state_type(
146                self.as_ref().to_glib_none().0,
147                action_name.to_glib_none().0,
148            ))
149        }
150    }
151
152    #[doc(alias = "g_action_group_has_action")]
153    fn has_action(&self, action_name: &str) -> bool {
154        unsafe {
155            from_glib(ffi::g_action_group_has_action(
156                self.as_ref().to_glib_none().0,
157                action_name.to_glib_none().0,
158            ))
159        }
160    }
161
162    #[doc(alias = "g_action_group_list_actions")]
163    fn list_actions(&self) -> Vec<glib::GString> {
164        unsafe {
165            FromGlibPtrContainer::from_glib_full(ffi::g_action_group_list_actions(
166                self.as_ref().to_glib_none().0,
167            ))
168        }
169    }
170
171    #[doc(alias = "action-added")]
172    fn connect_action_added<F: Fn(&Self, &str) + 'static>(
173        &self,
174        detail: Option<&str>,
175        f: F,
176    ) -> SignalHandlerId {
177        unsafe extern "C" fn action_added_trampoline<
178            P: IsA<ActionGroup>,
179            F: Fn(&P, &str) + 'static,
180        >(
181            this: *mut ffi::GActionGroup,
182            action_name: *mut std::ffi::c_char,
183            f: glib::ffi::gpointer,
184        ) {
185            let f: &F = &*(f as *const F);
186            f(
187                ActionGroup::from_glib_borrow(this).unsafe_cast_ref(),
188                &glib::GString::from_glib_borrow(action_name),
189            )
190        }
191        unsafe {
192            let f: Box_<F> = Box_::new(f);
193            let detailed_signal_name = detail.map(|name| format!("action-added::{name}\0"));
194            let signal_name: &[u8] = detailed_signal_name
195                .as_ref()
196                .map_or(&b"action-added\0"[..], |n| n.as_bytes());
197            connect_raw(
198                self.as_ptr() as *mut _,
199                signal_name.as_ptr() as *const _,
200                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
201                    action_added_trampoline::<Self, F> as *const (),
202                )),
203                Box_::into_raw(f),
204            )
205        }
206    }
207
208    #[doc(alias = "action-enabled-changed")]
209    fn connect_action_enabled_changed<F: Fn(&Self, &str, bool) + 'static>(
210        &self,
211        detail: Option<&str>,
212        f: F,
213    ) -> SignalHandlerId {
214        unsafe extern "C" fn action_enabled_changed_trampoline<
215            P: IsA<ActionGroup>,
216            F: Fn(&P, &str, bool) + 'static,
217        >(
218            this: *mut ffi::GActionGroup,
219            action_name: *mut std::ffi::c_char,
220            enabled: glib::ffi::gboolean,
221            f: glib::ffi::gpointer,
222        ) {
223            let f: &F = &*(f as *const F);
224            f(
225                ActionGroup::from_glib_borrow(this).unsafe_cast_ref(),
226                &glib::GString::from_glib_borrow(action_name),
227                from_glib(enabled),
228            )
229        }
230        unsafe {
231            let f: Box_<F> = Box_::new(f);
232            let detailed_signal_name =
233                detail.map(|name| format!("action-enabled-changed::{name}\0"));
234            let signal_name: &[u8] = detailed_signal_name
235                .as_ref()
236                .map_or(&b"action-enabled-changed\0"[..], |n| n.as_bytes());
237            connect_raw(
238                self.as_ptr() as *mut _,
239                signal_name.as_ptr() as *const _,
240                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
241                    action_enabled_changed_trampoline::<Self, F> as *const (),
242                )),
243                Box_::into_raw(f),
244            )
245        }
246    }
247
248    #[doc(alias = "action-removed")]
249    fn connect_action_removed<F: Fn(&Self, &str) + 'static>(
250        &self,
251        detail: Option<&str>,
252        f: F,
253    ) -> SignalHandlerId {
254        unsafe extern "C" fn action_removed_trampoline<
255            P: IsA<ActionGroup>,
256            F: Fn(&P, &str) + 'static,
257        >(
258            this: *mut ffi::GActionGroup,
259            action_name: *mut std::ffi::c_char,
260            f: glib::ffi::gpointer,
261        ) {
262            let f: &F = &*(f as *const F);
263            f(
264                ActionGroup::from_glib_borrow(this).unsafe_cast_ref(),
265                &glib::GString::from_glib_borrow(action_name),
266            )
267        }
268        unsafe {
269            let f: Box_<F> = Box_::new(f);
270            let detailed_signal_name = detail.map(|name| format!("action-removed::{name}\0"));
271            let signal_name: &[u8] = detailed_signal_name
272                .as_ref()
273                .map_or(&b"action-removed\0"[..], |n| n.as_bytes());
274            connect_raw(
275                self.as_ptr() as *mut _,
276                signal_name.as_ptr() as *const _,
277                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
278                    action_removed_trampoline::<Self, F> as *const (),
279                )),
280                Box_::into_raw(f),
281            )
282        }
283    }
284
285    #[doc(alias = "action-state-changed")]
286    fn connect_action_state_changed<F: Fn(&Self, &str, &glib::Variant) + 'static>(
287        &self,
288        detail: Option<&str>,
289        f: F,
290    ) -> SignalHandlerId {
291        unsafe extern "C" fn action_state_changed_trampoline<
292            P: IsA<ActionGroup>,
293            F: Fn(&P, &str, &glib::Variant) + 'static,
294        >(
295            this: *mut ffi::GActionGroup,
296            action_name: *mut std::ffi::c_char,
297            value: *mut glib::ffi::GVariant,
298            f: glib::ffi::gpointer,
299        ) {
300            let f: &F = &*(f as *const F);
301            f(
302                ActionGroup::from_glib_borrow(this).unsafe_cast_ref(),
303                &glib::GString::from_glib_borrow(action_name),
304                &from_glib_borrow(value),
305            )
306        }
307        unsafe {
308            let f: Box_<F> = Box_::new(f);
309            let detailed_signal_name = detail.map(|name| format!("action-state-changed::{name}\0"));
310            let signal_name: &[u8] = detailed_signal_name
311                .as_ref()
312                .map_or(&b"action-state-changed\0"[..], |n| n.as_bytes());
313            connect_raw(
314                self.as_ptr() as *mut _,
315                signal_name.as_ptr() as *const _,
316                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
317                    action_state_changed_trampoline::<Self, F> as *const (),
318                )),
319                Box_::into_raw(f),
320            )
321        }
322    }
323}
324
325impl<O: IsA<ActionGroup>> ActionGroupExt for O {}