Merge pull request #870 from pbor/master

ActionEntry: take proper types instead of strings

Author: sdroege

gio/Gir.toml

@@ -1135,6 +1135,21 @@ status = "generate"
     name = "state"
     #value glib::VariantTy
     ignore = true
+    [[object.function]]
+    name = "new_stateful"
+        [[object.function.parameter]]
+        name = "state"
+        move = true
+    [[object.function]]
+    name = "set_state"
+        [[object.function.parameter]]
+        name = "value"
+        move = true
+    [[object.function]]
+    name = "set_state_hint"
+        [[object.function.parameter]]
+        name = "state_hint"
+        move = true
 
 [[object]]
 name = "Gio.SimpleIOStream"

gio/src/action_entry.rs

@@ -1,6 +1,6 @@
 // Take a look at the license at the top of the repository in the LICENSE file.
 
-use glib::{prelude::*, Variant};
+use glib::{prelude::*, Variant, VariantTy, VariantType};
 
 use crate::{ActionMap, SimpleAction};
 
@@ -10,8 +10,8 @@ where
     O: IsA<ActionMap>,
 {
     name: String,
-    parameter_type: Option<String>,
-    state: Option<String>,
+    parameter_type: Option<VariantType>,
+    state: Option<Variant>,
     pub(crate) activate: Option<Box<dyn Fn(&O, &SimpleAction, Option<&Variant>) + 'static>>,
     pub(crate) change_state: Option<Box<dyn Fn(&O, &SimpleAction, Option<&Variant>) + 'static>>,
 }
@@ -24,12 +24,12 @@ where
         &self.name
     }
 
-    pub fn parameter_type(&self) -> Option<&str> {
+    pub fn parameter_type(&self) -> Option<&VariantTy> {
         self.parameter_type.as_deref()
     }
 
-    pub fn state(&self) -> Option<&str> {
-        self.state.as_deref()
+    pub fn state(&self) -> Option<&Variant> {
+        self.state.as_ref()
     }
 
     pub fn builder(name: &str) -> ActionEntryBuilder<O> {
@@ -69,13 +69,13 @@ where
         })
     }
 
-    pub fn parameter_type(mut self, parameter_type: &str) -> Self {
-        self.0.parameter_type = Some(parameter_type.to_owned());
+    pub fn parameter_type(mut self, parameter_type: Option<&VariantTy>) -> Self {
+        self.0.parameter_type = parameter_type.map(|vt| vt.to_owned());
         self
     }
 
-    pub fn state(mut self, state: &str) -> Self {
-        self.0.state = Some(state.to_owned());
+    pub fn state(mut self, state: Variant) -> Self {
+        self.0.state = Some(state);
         self
     }
 
@@ -109,12 +109,20 @@ mod tests {
     fn action_entry() {
         let app = crate::Application::new(None, Default::default());
 
-        let close = ActionEntry::builder("close")
-            .activate(move |_app, _, _| {
-                //Do something
-            })
-            .build();
-        app.add_action_entries(vec![close]).unwrap();
+        app.add_action_entries(vec![
+            ActionEntry::builder("close")
+                .activate(move |_app, _, _| {
+                    //Do something
+                })
+                .build(),
+            ActionEntry::builder("enable")
+                .state(true.to_variant())
+                .change_state(move |_app, _, _| {
+                    //Do something
+                })
+                .build(),
+        ]);
         assert!(app.lookup_action("close").is_some());
+        assert!(app.lookup_action("enable").is_some());
     }
 }

gio/src/action_map.rs

@@ -6,36 +6,18 @@ use crate::{prelude::*, ActionEntry, ActionMap, SimpleAction};
 
 pub trait ActionMapExtManual {
     #[doc(alias = "g_action_map_add_action_entries")]
-    fn add_action_entries(
-        &self,
-        entries: impl IntoIterator<Item = ActionEntry<Self>>,
-    ) -> Result<(), glib::BoolError>
+    fn add_action_entries(&self, entries: impl IntoIterator<Item = ActionEntry<Self>>)
     where
         Self: IsA<ActionMap>;
 }
 
 impl<O: IsA<ActionMap>> ActionMapExtManual for O {
-    fn add_action_entries(
-        &self,
-        entries: impl IntoIterator<Item = ActionEntry<Self>>,
-    ) -> Result<(), glib::BoolError> {
+    fn add_action_entries(&self, entries: impl IntoIterator<Item = ActionEntry<Self>>) {
         for entry in entries.into_iter() {
-            let parameter_type = if let Some(param_type) = entry.parameter_type() {
-                Some(glib::VariantType::new(param_type)?)
-            } else {
-                None
-            };
             let action = if let Some(state) = entry.state() {
-                let state = glib::Variant::parse(None, state).map_err(|e| {
-                    glib::bool_error!(
-                        "Invalid state passed to gio::ActionEntry {} {}",
-                        entry.name(),
-                        e
-                    )
-                })?;
-                SimpleAction::new_stateful(entry.name(), parameter_type.as_deref(), &state)
+                SimpleAction::new_stateful(entry.name(), entry.parameter_type(), state.clone())
             } else {
-                SimpleAction::new(entry.name(), parameter_type.as_deref())
+                SimpleAction::new(entry.name(), entry.parameter_type())
             };
             let action_map = self.as_ref();
             if let Some(callback) = entry.activate {
@@ -52,6 +34,5 @@ impl<O: IsA<ActionMap>> ActionMapExtManual for O {
             }
             self.as_ref().add_action(&action);
         }
-        Ok(())
     }
 }

gio/src/auto/simple_action.rs

@@ -34,13 +34,13 @@ impl SimpleAction {
     pub fn new_stateful(
         name: &str,
         parameter_type: Option<&glib::VariantTy>,
-        state: &glib::Variant,
+        state: glib::Variant,
     ) -> SimpleAction {
         unsafe {
             from_glib_full(ffi::g_simple_action_new_stateful(
                 name.to_glib_none().0,
                 parameter_type.to_glib_none().0,
-                state.to_glib_none().0,
+                state.into_glib_ptr(),
             ))
         }
     }
@@ -53,16 +53,16 @@ impl SimpleAction {
     }
 
     #[doc(alias = "g_simple_action_set_state")]
-    pub fn set_state(&self, value: &glib::Variant) {
+    pub fn set_state(&self, value: glib::Variant) {
         unsafe {
-            ffi::g_simple_action_set_state(self.to_glib_none().0, value.to_glib_none().0);
+            ffi::g_simple_action_set_state(self.to_glib_none().0, value.into_glib_ptr());
         }
     }
 
     #[doc(alias = "g_simple_action_set_state_hint")]
-    pub fn set_state_hint(&self, state_hint: Option<&glib::Variant>) {
+    pub fn set_state_hint(&self, state_hint: Option<glib::Variant>) {
         unsafe {
-            ffi::g_simple_action_set_state_hint(self.to_glib_none().0, state_hint.to_glib_none().0);
+            ffi::g_simple_action_set_state_hint(self.to_glib_none().0, state_hint.into_glib_ptr());
         }
     }