gio: Use builder pattern for Settings::bind() (#210)

This now wraps `g_settings_bind_with_mapping`, so mapping can optionally
be specified.

Author: ids1024

gio/Gir.toml

@@ -870,6 +870,12 @@ status = "generate"
     name = "get_value"
         [object.function.return]
         nullable = false
+    [[object.function]]
+    name = "bind"
+    manual = true
+    [[object.function]]
+    name = "bind_with_mapping"
+    manual = true
 
 [[object]]
 name = "Gio.SettingsSchemaKey"

gio/src/auto/settings.rs

@@ -4,7 +4,6 @@
 
 use crate::Action;
 use crate::SettingsBackend;
-use crate::SettingsBindFlags;
 use crate::SettingsSchema;
 use glib::object::Cast;
 use glib::object::IsA;
@@ -101,18 +100,6 @@ pub trait SettingsExt: 'static {
     #[doc(alias = "g_settings_apply")]
     fn apply(&self);
 
-    #[doc(alias = "g_settings_bind")]
-    fn bind<P: IsA<glib::Object>>(
-        &self,
-        key: &str,
-        object: &P,
-        property: &str,
-        flags: SettingsBindFlags,
-    );
-
-    //#[doc(alias = "g_settings_bind_with_mapping")]
-    //fn bind_with_mapping<P: IsA<glib::Object>, Q: Fn(&glib::Value, &glib::Variant) -> bool + 'static, R: Fn(&glib::Value, &glib::VariantType) -> glib::Variant + 'static>(&self, key: &str, object: &P, property: &str, flags: SettingsBindFlags, get_mapping: Q, set_mapping: R);
-
     #[doc(alias = "g_settings_bind_writable")]
     fn bind_writable<P: IsA<glib::Object>>(
         &self,
@@ -275,28 +262,6 @@ impl<O: IsA<Settings>> SettingsExt for O {
         }
     }
 
-    fn bind<P: IsA<glib::Object>>(
-        &self,
-        key: &str,
-        object: &P,
-        property: &str,
-        flags: SettingsBindFlags,
-    ) {
-        unsafe {
-            ffi::g_settings_bind(
-                self.as_ref().to_glib_none().0,
-                key.to_glib_none().0,
-                object.as_ref().to_glib_none().0,
-                property.to_glib_none().0,
-                flags.to_glib(),
-            );
-        }
-    }
-
-    //fn bind_with_mapping<P: IsA<glib::Object>, Q: Fn(&glib::Value, &glib::Variant) -> bool + 'static, R: Fn(&glib::Value, &glib::VariantType) -> glib::Variant + 'static>(&self, key: &str, object: &P, property: &str, flags: SettingsBindFlags, get_mapping: Q, set_mapping: R) {
-    //    unsafe { TODO: call ffi:g_settings_bind_with_mapping() }
-    //}
-
     fn bind_writable<P: IsA<glib::Object>>(
         &self,
         key: &str,

gio/src/settings.rs

@@ -1,11 +1,119 @@
-use crate::{Settings, SettingsExt};
+use crate::{Settings, SettingsBindFlags, SettingsExt};
+use glib::prelude::*;
+use glib::translate::{from_glib_borrow, from_glib_none, ToGlib, ToGlibPtr};
 use glib::variant::FromVariant;
 use glib::{BoolError, IsA, ToVariant};
 
+pub struct BindingBuilder<'a> {
+    settings: &'a Settings,
+    key: &'a str,
+    object: &'a glib::Object,
+    property: &'a str,
+    flags: SettingsBindFlags,
+    get_mapping: Option<Box<dyn Fn(&glib::Variant, glib::Type) -> Option<glib::Value>>>,
+    set_mapping: Option<Box<dyn Fn(&glib::Value, glib::VariantType) -> Option<glib::Variant>>>,
+}
+
+impl<'a> BindingBuilder<'a> {
+    pub fn flags(mut self, flags: SettingsBindFlags) -> Self {
+        self.flags = flags;
+        self
+    }
+
+    pub fn get_mapping<F: Fn(&glib::Variant, glib::Type) -> Option<glib::Value> + 'static>(
+        mut self,
+        f: F,
+    ) -> Self {
+        self.get_mapping = Some(Box::new(f));
+        self
+    }
+
+    pub fn set_mapping<
+        F: Fn(&glib::Value, glib::VariantType) -> Option<glib::Variant> + 'static,
+    >(
+        mut self,
+        f: F,
+    ) -> Self {
+        self.set_mapping = Some(Box::new(f));
+        self
+    }
+
+    pub fn build(self) {
+        type Mappings = (
+            Option<Box<dyn Fn(&glib::Variant, glib::Type) -> Option<glib::Value>>>,
+            Option<Box<dyn Fn(&glib::Value, glib::VariantType) -> Option<glib::Variant>>>,
+        );
+        unsafe extern "C" fn bind_with_mapping_get_trampoline(
+            value: *mut glib::gobject_ffi::GValue,
+            variant: *mut glib::ffi::GVariant,
+            user_data: glib::ffi::gpointer,
+        ) -> glib::ffi::gboolean {
+            let user_data = &*(user_data as *const Mappings);
+            let f = user_data.0.as_ref().unwrap();
+            let value = &mut *(value as *mut glib::Value);
+            if let Some(v) = f(&*from_glib_borrow(variant), value.type_()) {
+                *value = v;
+                true
+            } else {
+                false
+            }
+            .to_glib()
+        }
+        unsafe extern "C" fn bind_with_mapping_set_trampoline(
+            value: *const glib::gobject_ffi::GValue,
+            variant_type: *const glib::ffi::GVariantType,
+            user_data: glib::ffi::gpointer,
+        ) -> *mut glib::ffi::GVariant {
+            let user_data = &*(user_data as *const Mappings);
+            let f = user_data.1.as_ref().unwrap();
+            let value = &*(value as *const glib::Value);
+            f(value, from_glib_none(variant_type)).to_glib_full()
+        }
+        unsafe extern "C" fn destroy_closure(ptr: *mut libc::c_void) {
+            Box::<Mappings>::from_raw(ptr as *mut _);
+        }
+        let get_trampoline: Option<unsafe extern "C" fn(_, _, _) -> _> =
+            if self.get_mapping.is_none() {
+                None
+            } else {
+                Some(bind_with_mapping_get_trampoline)
+            };
+        let set_trampoline: Option<unsafe extern "C" fn(_, _, _) -> _> =
+            if self.set_mapping.is_none() {
+                None
+            } else {
+                Some(bind_with_mapping_set_trampoline)
+            };
+        let mappings: Mappings = (self.get_mapping, self.set_mapping);
+        unsafe {
+            ffi::g_settings_bind_with_mapping(
+                self.settings.to_glib_none().0,
+                self.key.to_glib_none().0,
+                self.object.to_glib_none().0,
+                self.property.to_glib_none().0,
+                self.flags.to_glib(),
+                get_trampoline,
+                set_trampoline,
+                Box::into_raw(Box::new(mappings)) as *mut libc::c_void,
+                Some(destroy_closure),
+            )
+        }
+    }
+}
+
 pub trait SettingsExtManual {
     fn get<U: FromVariant>(&self, key: &str) -> U;
 
     fn set<U: ToVariant>(&self, key: &str, value: &U) -> Result<(), BoolError>;
+
+    #[doc(alias = "g_settings_bind")]
+    #[doc(alias = "g_settings_bind_with_mapping")]
+    fn bind<'a, P: IsA<glib::Object>>(
+        &'a self,
+        key: &'a str,
+        object: &'a P,
+        property: &'a str,
+    ) -> BindingBuilder<'a>;
 }
 
 impl<O: IsA<Settings>> SettingsExtManual for O {
@@ -23,6 +131,23 @@ impl<O: IsA<Settings>> SettingsExtManual for O {
     fn set<U: ToVariant>(&self, key: &str, value: &U) -> Result<(), BoolError> {
         self.set_value(key, &value.to_variant())
     }
+
+    fn bind<'a, P: IsA<glib::Object>>(
+        &'a self,
+        key: &'a str,
+        object: &'a P,
+        property: &'a str,
+    ) -> BindingBuilder<'a> {
+        BindingBuilder {
+            settings: self.upcast_ref(),
+            key,
+            object: object.upcast_ref(),
+            property,
+            flags: SettingsBindFlags::DEFAULT,
+            get_mapping: None,
+            set_mapping: None,
+        }
+    }
 }
 
 #[cfg(test)]