1use 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 {}