Draft: Use Into<Option<_>> in argument position where applicable

gdk-pixbuf/src/auto/pixbuf.rs

@@ -60,7 +60,7 @@ impl Pixbuf {
 
     //#[doc(alias = "gdk_pixbuf_new_from_data")]
     //#[doc(alias = "new_from_data")]
-    //pub fn from_data(data: &[u8], colorspace: Colorspace, has_alpha: bool, bits_per_sample: i32, width: i32, height: i32, rowstride: i32, destroy_fn: Option<Box_<dyn FnOnce(&Vec<u8>) + 'static>>) -> Pixbuf {
+    //pub fn from_data(data: &[u8], colorspace: Colorspace, has_alpha: bool, bits_per_sample: i32, width: i32, height: i32, rowstride: i32, destroy_fn: Option<Box_<dyn FnOnce(&[u8]) + 'static>>) -> Pixbuf {
     //    unsafe { TODO: call ffi:gdk_pixbuf_new_from_data() }
     //}
 
@@ -167,15 +167,20 @@ impl Pixbuf {
 
     #[doc(alias = "gdk_pixbuf_new_from_stream")]
     #[doc(alias = "new_from_stream")]
-    pub fn from_stream(
+    pub fn from_stream<'a, P: IsA<gio::Cancellable>>(
         stream: &impl IsA<gio::InputStream>,
-        cancellable: Option<&impl IsA<gio::Cancellable>>,
+        cancellable: impl Into<Option<&'a P>>,
     ) -> Result<Pixbuf, glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let ret = ffi::gdk_pixbuf_new_from_stream(
                 stream.as_ref().to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             if error.is_null() {
@@ -188,12 +193,12 @@ impl Pixbuf {
 
     #[doc(alias = "gdk_pixbuf_new_from_stream_at_scale")]
     #[doc(alias = "new_from_stream_at_scale")]
-    pub fn from_stream_at_scale(
+    pub fn from_stream_at_scale<'a, P: IsA<gio::Cancellable>>(
         stream: &impl IsA<gio::InputStream>,
         width: i32,
         height: i32,
         preserve_aspect_ratio: bool,
-        cancellable: Option<&impl IsA<gio::Cancellable>>,
+        cancellable: impl Into<Option<&'a P>>,
     ) -> Result<Pixbuf, glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
@@ -202,7 +207,12 @@ impl Pixbuf {
                 width,
                 height,
                 preserve_aspect_ratio.into_glib(),
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             if error.is_null() {
@@ -465,7 +475,7 @@ impl Pixbuf {
 
     //#[doc(alias = "gdk_pixbuf_get_options")]
     //#[doc(alias = "get_options")]
-    //pub fn options(&self) -> /*Unknown conversion*//*Unimplemented*/HashTable TypeId { ns_id: 0, id: 28 }/TypeId { ns_id: 0, id: 28 } {
+    //pub fn options(&self) -> /*Unimplemented*/HashTable TypeId { ns_id: 0, id: 28 }/TypeId { ns_id: 0, id: 28 } {
     //    unsafe { TODO: call ffi:gdk_pixbuf_get_options() }
     //}
 
@@ -534,37 +544,37 @@ impl Pixbuf {
     }
 
     //#[doc(alias = "gdk_pixbuf_save")]
-    //pub fn save(&self, filename: impl AsRef<std::path::Path>, type_: &str, error: Option<&mut glib::Error>, : /*Unknown conversion*//*Unimplemented*/Basic: VarArgs) -> bool {
+    //pub fn save<'a>(&self, filename: impl AsRef<std::path::Path>, type_: &str, error: impl Into<Option<&'a mut  glib::Error>>, : /*Unimplemented*/Basic: VarArgs) -> bool {
     //    unsafe { TODO: call ffi:gdk_pixbuf_save() }
     //}
 
     //#[doc(alias = "gdk_pixbuf_save_to_buffer")]
-    //pub fn save_to_buffer(&self, type_: &str, error: Option<&mut glib::Error>, : /*Unknown conversion*//*Unimplemented*/Basic: VarArgs) -> Option<Vec<u8>> {
+    //pub fn save_to_buffer<'a>(&self, type_: &str, error: impl Into<Option<&'a mut  glib::Error>>, : /*Unimplemented*/Basic: VarArgs) -> Option<Vec<u8>> {
     //    unsafe { TODO: call ffi:gdk_pixbuf_save_to_buffer() }
     //}
 
     //#[doc(alias = "gdk_pixbuf_save_to_callback")]
-    //pub fn save_to_callback<P: FnMut(&Vec<u8>, usize, &glib::Error) -> bool>(&self, save_func: P, type_: &str, error: Option<&mut glib::Error>, : /*Unknown conversion*//*Unimplemented*/Basic: VarArgs) -> bool {
+    //pub fn save_to_callback<'a, P: FnMut(&[u8], usize, &glib::Error) -> bool>(&self, save_func: P, type_: &str, error: impl Into<Option<&'a mut  glib::Error>>, : /*Unimplemented*/Basic: VarArgs) -> bool {
     //    unsafe { TODO: call ffi:gdk_pixbuf_save_to_callback() }
     //}
 
     //#[doc(alias = "gdk_pixbuf_save_to_callbackv")]
-    //pub fn save_to_callbackv<P: FnMut(&Vec<u8>, usize, &glib::Error) -> bool>(&self, save_func: P, type_: &str, option_keys: &[&str], option_values: &[&str]) -> Result<(), glib::Error> {
+    //pub fn save_to_callbackv<P: FnMut(&[u8], usize, &glib::Error) -> bool>(&self, save_func: P, type_: &str, option_keys: &[&str], option_values: &[&str]) -> Result<(), glib::Error> {
     //    unsafe { TODO: call ffi:gdk_pixbuf_save_to_callbackv() }
     //}
 
     //#[doc(alias = "gdk_pixbuf_save_to_stream")]
-    //pub fn save_to_stream(&self, stream: &impl IsA<gio::OutputStream>, type_: &str, cancellable: Option<&impl IsA<gio::Cancellable>>, error: Option<&mut glib::Error>, : /*Unknown conversion*//*Unimplemented*/Basic: VarArgs) -> bool {
+    //pub fn save_to_stream<'a, P: IsA<gio::Cancellable>>(&self, stream: &impl IsA<gio::OutputStream>, type_: &str, cancellable: impl Into<Option<&'a P>>, error: impl Into<Option<&'a mut  glib::Error>>, : /*Unimplemented*/Basic: VarArgs) -> bool {
     //    unsafe { TODO: call ffi:gdk_pixbuf_save_to_stream() }
     //}
 
     //#[doc(alias = "gdk_pixbuf_save_to_stream_async")]
-    //pub fn save_to_stream_async<P: FnOnce(Result<(), glib::Error>) + 'static>(&self, stream: &impl IsA<gio::OutputStream>, type_: &str, cancellable: Option<&impl IsA<gio::Cancellable>>, callback: P, : /*Unknown conversion*//*Unimplemented*/Basic: VarArgs) {
+    //pub fn save_to_stream_async<'a, P: IsA<gio::Cancellable>, Q: FnOnce(Result<(), glib::Error>) + 'static>(&self, stream: &impl IsA<gio::OutputStream>, type_: &str, cancellable: impl Into<Option<&'a P>>, callback: Q, : /*Unimplemented*/Basic: VarArgs) {
     //    unsafe { TODO: call ffi:gdk_pixbuf_save_to_stream_async() }
     //}
 
     //
-    //pub fn save_to_stream_future(&self, stream: &(impl IsA<gio::OutputStream> + Clone + 'static), type_: &str, : /*Unknown conversion*//*Unimplemented*/Basic: VarArgs) -> Pin<Box_<dyn std::future::Future<Output = Result<(), glib::Error>> + 'static>> {
+    //pub fn save_to_stream_future(&self, stream: &(impl IsA<gio::OutputStream> + Clone + 'static), type_: &str, : /*Unimplemented*/Basic: VarArgs) -> Pin<Box_<dyn std::future::Future<Output = Result<(), glib::Error>> + 'static>> {
 
     //let stream = stream.clone();
     //let type_ = String::from(type_);

gdk-pixbuf/src/auto/pixbuf_animation.rs

@@ -56,15 +56,20 @@ impl PixbufAnimation {
 
     #[doc(alias = "gdk_pixbuf_animation_new_from_stream")]
     #[doc(alias = "new_from_stream")]
-    pub fn from_stream(
+    pub fn from_stream<'a, P: IsA<gio::Cancellable>>(
         stream: &impl IsA<gio::InputStream>,
-        cancellable: Option<&impl IsA<gio::Cancellable>>,
+        cancellable: impl Into<Option<&'a P>>,
     ) -> Result<PixbufAnimation, glib::Error> {
         unsafe {
             let mut error = std::ptr::null_mut();
             let ret = ffi::gdk_pixbuf_animation_new_from_stream(
                 stream.as_ref().to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 &mut error,
             );
             if error.is_null() {
@@ -77,10 +82,14 @@ impl PixbufAnimation {
 
     #[doc(alias = "gdk_pixbuf_animation_new_from_stream_async")]
     #[doc(alias = "new_from_stream_async")]
-    pub fn from_stream_async<P: FnOnce(Result<PixbufAnimation, glib::Error>) + 'static>(
+    pub fn from_stream_async<
+        'a,
+        P: IsA<gio::Cancellable>,
+        Q: FnOnce(Result<PixbufAnimation, glib::Error>) + 'static,
+    >(
         stream: &impl IsA<gio::InputStream>,
-        cancellable: Option<&impl IsA<gio::Cancellable>>,
-        callback: P,
+        cancellable: impl Into<Option<&'a P>>,
+        callback: Q,
     ) {
         let main_context = glib::MainContext::ref_thread_default();
         let is_main_context_owner = main_context.is_owner();
@@ -92,10 +101,10 @@ impl PixbufAnimation {
             "Async operations only allowed if the thread is owning the MainContext"
         );
 
-        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        let user_data: Box_<glib::thread_guard::ThreadGuard<Q>> =
             Box_::new(glib::thread_guard::ThreadGuard::new(callback));
         unsafe extern "C" fn from_stream_async_trampoline<
-            P: FnOnce(Result<PixbufAnimation, glib::Error>) + 'static,
+            Q: FnOnce(Result<PixbufAnimation, glib::Error>) + 'static,
         >(
             _source_object: *mut glib::gobject_ffi::GObject,
             res: *mut gio::ffi::GAsyncResult,
@@ -108,16 +117,21 @@ impl PixbufAnimation {
             } else {
                 Err(from_glib_full(error))
             };
-            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            let callback: Box_<glib::thread_guard::ThreadGuard<Q>> =
                 Box_::from_raw(user_data as *mut _);
-            let callback: P = callback.into_inner();
+            let callback: Q = callback.into_inner();
             callback(result);
         }
-        let callback = from_stream_async_trampoline::<P>;
+        let callback = from_stream_async_trampoline::<Q>;
         unsafe {
             ffi::gdk_pixbuf_animation_new_from_stream_async(
                 stream.as_ref().to_glib_none().0,
-                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable
+                    .into()
+                    .as_ref()
+                    .map(|p| p.as_ref())
+                    .to_glib_none()
+                    .0,
                 Some(callback),
                 Box_::into_raw(user_data) as *mut _,
             );

gdk-pixbuf/src/auto/versions.txt

@@ -1,2 +1,2 @@
-Generated by gir (https://github.com/gtk-rs/gir @ 1b34ebba86cb)
+Generated by gir (https://github.com/gtk-rs/gir @ 24f0d6639caa)
 from gir-files (https://github.com/gtk-rs/gir-files @ dfdf5ed146d5)

gdk-pixbuf/sys/versions.txt

@@ -1,2 +1,2 @@
-Generated by gir (https://github.com/gtk-rs/gir @ 1b34ebba86cb)
+Generated by gir (https://github.com/gtk-rs/gir @ 24f0d6639caa)
 from gir-files (https://github.com/gtk-rs/gir-files @ dfdf5ed146d5)

gio/src/auto/action.rs

@@ -51,24 +51,27 @@ impl Action {
     }
 
     #[doc(alias = "g_action_print_detailed_name")]
-    pub fn print_detailed_name(
+    pub fn print_detailed_name<'a>(
         action_name: &str,
-        target_value: Option<&glib::Variant>,
+        target_value: impl Into<Option<&'a glib::Variant>>,
     ) -> glib::GString {
         unsafe {
             from_glib_full(ffi::g_action_print_detailed_name(
                 action_name.to_glib_none().0,
-                target_value.to_glib_none().0,
+                target_value.into().to_glib_none().0,
             ))
         }
     }
 }
 
 pub trait ActionExt: IsA<Action> + 'static {
     #[doc(alias = "g_action_activate")]
-    fn activate(&self, parameter: Option<&glib::Variant>) {
+    fn activate<'a>(&self, parameter: impl Into<Option<&'a glib::Variant>>) {
         unsafe {
-            ffi::g_action_activate(self.as_ref().to_glib_none().0, parameter.to_glib_none().0);
+            ffi::g_action_activate(
+                self.as_ref().to_glib_none().0,
+                parameter.into().to_glib_none().0,
+            );
         }
     }
 

gio/src/auto/action_group.rs

@@ -67,12 +67,16 @@ pub trait ActionGroupExt: IsA<ActionGroup> + 'static {
     }
 
     #[doc(alias = "g_action_group_activate_action")]
-    fn activate_action(&self, action_name: &str, parameter: Option<&glib::Variant>) {
+    fn activate_action<'a>(
+        &self,
+        action_name: &str,
+        parameter: impl Into<Option<&'a glib::Variant>>,
+    ) {
         unsafe {
             ffi::g_action_group_activate_action(
                 self.as_ref().to_glib_none().0,
                 action_name.to_glib_none().0,
-                parameter.to_glib_none().0,
+                parameter.into().to_glib_none().0,
             );
         }
     }