gtk: Generate FileLauncher API

bilelmoussaoui · bilelmoussaoui · commit af1db7098efd · 2023-01-02T11:43:15.000+01:00
diff --git a/gtk4/Gir.toml b/gtk4/Gir.toml
@@ -1199,6 +1199,11 @@ name = "Gtk.FileFilter"
 status = "generate"
 generate_builder = false
 
+[[object]]
+name = "Gtk.FileLauncher"
+status = "generate"
+generate_builder = false
+
 [[object]]
 name = "Gtk.FilterListModel"
 status = "generate"
diff --git a/gtk4/src/auto/file_launcher.rs b/gtk4/src/auto/file_launcher.rs
@@ -0,0 +1,217 @@
+// This file was generated by gir (https://github.com/gtk-rs/gir)
+// from gir-files (https://github.com/gtk-rs/gir-files)
+// DO NOT EDIT
+
+use crate::Window;
+use glib::object::IsA;
+use glib::object::ObjectType as ObjectType_;
+use glib::signal::connect_raw;
+use glib::signal::SignalHandlerId;
+use glib::translate::*;
+use std::boxed::Box as Box_;
+use std::fmt;
+use std::mem::transmute;
+use std::pin::Pin;
+use std::ptr;
+
+glib::wrapper! {
+    #[doc(alias = "GtkFileLauncher")]
+    pub struct FileLauncher(Object<ffi::GtkFileLauncher, ffi::GtkFileLauncherClass>);
+
+    match fn {
+        type_ => || ffi::gtk_file_launcher_get_type(),
+    }
+}
+
+impl FileLauncher {
+    #[doc(alias = "gtk_file_launcher_new")]
+    pub fn new(file: Option<&impl IsA<gio::File>>) -> FileLauncher {
+        assert_initialized_main_thread!();
+        unsafe {
+            from_glib_full(ffi::gtk_file_launcher_new(
+                file.map(|p| p.as_ref()).to_glib_none().0,
+            ))
+        }
+    }
+
+    #[doc(alias = "gtk_file_launcher_get_file")]
+    #[doc(alias = "get_file")]
+    pub fn file(&self) -> Option<gio::File> {
+        unsafe { from_glib_none(ffi::gtk_file_launcher_get_file(self.to_glib_none().0)) }
+    }
+
+    #[doc(alias = "gtk_file_launcher_launch")]
+    pub fn launch<P: FnOnce(Result<(), glib::Error>) + 'static>(
+        &self,
+        parent: Option<&impl IsA<Window>>,
+        cancellable: Option<&impl IsA<gio::Cancellable>>,
+        callback: P,
+    ) {
+        let main_context = glib::MainContext::ref_thread_default();
+        let is_main_context_owner = main_context.is_owner();
+        let has_acquired_main_context = (!is_main_context_owner)
+            .then(|| main_context.acquire().ok())
+            .flatten();
+        assert!(
+            is_main_context_owner || has_acquired_main_context.is_some(),
+            "Async operations only allowed if the thread is owning the MainContext"
+        );
+
+        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+            Box_::new(glib::thread_guard::ThreadGuard::new(callback));
+        unsafe extern "C" fn launch_trampoline<P: FnOnce(Result<(), glib::Error>) + 'static>(
+            _source_object: *mut glib::gobject_ffi::GObject,
+            res: *mut gio::ffi::GAsyncResult,
+            user_data: glib::ffi::gpointer,
+        ) {
+            let mut error = ptr::null_mut();
+            let _ = ffi::gtk_file_launcher_launch_finish(_source_object as *mut _, res, &mut error);
+            let result = if error.is_null() {
+                Ok(())
+            } else {
+                Err(from_glib_full(error))
+            };
+            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+                Box_::from_raw(user_data as *mut _);
+            let callback: P = callback.into_inner();
+            callback(result);
+        }
+        let callback = launch_trampoline::<P>;
+        unsafe {
+            ffi::gtk_file_launcher_launch(
+                self.to_glib_none().0,
+                parent.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                Some(callback),
+                Box_::into_raw(user_data) as *mut _,
+            );
+        }
+    }
+
+    pub fn launch_future(
+        &self,
+        parent: Option<&(impl IsA<Window> + Clone + 'static)>,
+    ) -> Pin<Box_<dyn std::future::Future<Output = Result<(), glib::Error>> + 'static>> {
+        let parent = parent.map(ToOwned::to_owned);
+        Box_::pin(gio::GioFuture::new(self, move |obj, cancellable, send| {
+            obj.launch(
+                parent.as_ref().map(::std::borrow::Borrow::borrow),
+                Some(cancellable),
+                move |res| {
+                    send.resolve(res);
+                },
+            );
+        }))
+    }
+
+    #[doc(alias = "gtk_file_launcher_open_containing_folder")]
+    pub fn open_containing_folder<P: FnOnce(Result<(), glib::Error>) + 'static>(
+        &self,
+        parent: Option<&impl IsA<Window>>,
+        cancellable: Option<&impl IsA<gio::Cancellable>>,
+        callback: P,
+    ) {
+        let main_context = glib::MainContext::ref_thread_default();
+        let is_main_context_owner = main_context.is_owner();
+        let has_acquired_main_context = (!is_main_context_owner)
+            .then(|| main_context.acquire().ok())
+            .flatten();
+        assert!(
+            is_main_context_owner || has_acquired_main_context.is_some(),
+            "Async operations only allowed if the thread is owning the MainContext"
+        );
+
+        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+            Box_::new(glib::thread_guard::ThreadGuard::new(callback));
+        unsafe extern "C" fn open_containing_folder_trampoline<
+            P: FnOnce(Result<(), glib::Error>) + 'static,
+        >(
+            _source_object: *mut glib::gobject_ffi::GObject,
+            res: *mut gio::ffi::GAsyncResult,
+            user_data: glib::ffi::gpointer,
+        ) {
+            let mut error = ptr::null_mut();
+            let _ = ffi::gtk_file_launcher_open_containing_folder_finish(
+                _source_object as *mut _,
+                res,
+                &mut error,
+            );
+            let result = if error.is_null() {
+                Ok(())
+            } else {
+                Err(from_glib_full(error))
+            };
+            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+                Box_::from_raw(user_data as *mut _);
+            let callback: P = callback.into_inner();
+            callback(result);
+        }
+        let callback = open_containing_folder_trampoline::<P>;
+        unsafe {
+            ffi::gtk_file_launcher_open_containing_folder(
+                self.to_glib_none().0,
+                parent.map(|p| p.as_ref()).to_glib_none().0,
+                cancellable.map(|p| p.as_ref()).to_glib_none().0,
+                Some(callback),
+                Box_::into_raw(user_data) as *mut _,
+            );
+        }
+    }
+
+    pub fn open_containing_folder_future(
+        &self,
+        parent: Option<&(impl IsA<Window> + Clone + 'static)>,
+    ) -> Pin<Box_<dyn std::future::Future<Output = Result<(), glib::Error>> + 'static>> {
+        let parent = parent.map(ToOwned::to_owned);
+        Box_::pin(gio::GioFuture::new(self, move |obj, cancellable, send| {
+            obj.open_containing_folder(
+                parent.as_ref().map(::std::borrow::Borrow::borrow),
+                Some(cancellable),
+                move |res| {
+                    send.resolve(res);
+                },
+            );
+        }))
+    }
+
+    #[doc(alias = "gtk_file_launcher_set_file")]
+    pub fn set_file(&self, file: Option<&impl IsA<gio::File>>) {
+        unsafe {
+            ffi::gtk_file_launcher_set_file(
+                self.to_glib_none().0,
+                file.map(|p| p.as_ref()).to_glib_none().0,
+            );
+        }
+    }
+
+    #[cfg(any(feature = "v4_10", feature = "dox"))]
+    #[cfg_attr(feature = "dox", doc(cfg(feature = "v4_10")))]
+    #[doc(alias = "file")]
+    pub fn connect_file_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
+        unsafe extern "C" fn notify_file_trampoline<F: Fn(&FileLauncher) + 'static>(
+            this: *mut ffi::GtkFileLauncher,
+            _param_spec: glib::ffi::gpointer,
+            f: glib::ffi::gpointer,
+        ) {
+            let f: &F = &*(f as *const F);
+            f(&from_glib_borrow(this))
+        }
+        unsafe {
+            let f: Box_<F> = Box_::new(f);
+            connect_raw(
+                self.as_ptr() as *mut _,
+                b"notify::file\0".as_ptr() as *const _,
+                Some(transmute::<_, unsafe extern "C" fn()>(
+                    notify_file_trampoline::<F> as *const (),
+                )),
+                Box_::into_raw(f),
+            )
+        }
+    }
+}
+
+impl fmt::Display for FileLauncher {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.write_str("FileLauncher")
+    }
+}
diff --git a/gtk4/src/auto/mod.rs b/gtk4/src/auto/mod.rs
@@ -387,6 +387,13 @@ pub use self::file_dialog::FileDialog;
 mod file_filter;
 pub use self::file_filter::FileFilter;
 
+#[cfg(any(feature = "v4_10", feature = "dox"))]
+#[cfg_attr(feature = "dox", doc(cfg(feature = "v4_10")))]
+mod file_launcher;
+#[cfg(any(feature = "v4_10", feature = "dox"))]
+#[cfg_attr(feature = "dox", doc(cfg(feature = "v4_10")))]
+pub use self::file_launcher::FileLauncher;
+
 mod filter;
 pub use self::filter::Filter;
 
