1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164
// 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::{ffi, AsyncResult, Cancellable, Icon, InputStream};
use glib::{prelude::*, translate::*};
use std::{boxed::Box as Box_, pin::Pin};
glib::wrapper! {
/// `GLoadableIcon` extends the [`Icon`][crate::Icon] interface and adds the ability
/// to load icons from streams.
///
/// # Implements
///
/// [`LoadableIconExt`][trait@crate::prelude::LoadableIconExt], [`IconExt`][trait@crate::prelude::IconExt]
#[doc(alias = "GLoadableIcon")]
pub struct LoadableIcon(Interface<ffi::GLoadableIcon, ffi::GLoadableIconIface>) @requires Icon;
match fn {
type_ => || ffi::g_loadable_icon_get_type(),
}
}
impl LoadableIcon {
pub const NONE: Option<&'static LoadableIcon> = None;
}
mod sealed {
pub trait Sealed {}
impl<T: super::IsA<super::LoadableIcon>> Sealed for T {}
}
/// Trait containing all [`struct@LoadableIcon`] methods.
///
/// # Implementors
///
/// [`BytesIcon`][struct@crate::BytesIcon], [`FileIcon`][struct@crate::FileIcon], [`LoadableIcon`][struct@crate::LoadableIcon]
pub trait LoadableIconExt: IsA<LoadableIcon> + sealed::Sealed + 'static {
/// Loads a loadable icon. For the asynchronous version of this function,
/// see g_loadable_icon_load_async().
/// ## `size`
/// an integer.
/// ## `cancellable`
/// optional #GCancellable object, [`None`] to
/// ignore.
///
/// # Returns
///
/// a #GInputStream to read the icon from.
///
/// ## `type_`
/// a location to store the type of the loaded
/// icon, [`None`] to ignore.
#[doc(alias = "g_loadable_icon_load")]
fn load(
&self,
size: i32,
cancellable: Option<&impl IsA<Cancellable>>,
) -> Result<(InputStream, glib::GString), glib::Error> {
unsafe {
let mut type_ = std::ptr::null_mut();
let mut error = std::ptr::null_mut();
let ret = ffi::g_loadable_icon_load(
self.as_ref().to_glib_none().0,
size,
&mut type_,
cancellable.map(|p| p.as_ref()).to_glib_none().0,
&mut error,
);
if error.is_null() {
Ok((from_glib_full(ret), from_glib_full(type_)))
} else {
Err(from_glib_full(error))
}
}
}
/// Loads an icon asynchronously. To finish this function, see
/// g_loadable_icon_load_finish(). For the synchronous, blocking
/// version of this function, see g_loadable_icon_load().
/// ## `size`
/// an integer.
/// ## `cancellable`
/// optional #GCancellable object, [`None`] to ignore.
/// ## `callback`
/// a #GAsyncReadyCallback
/// to call when the request is satisfied
#[doc(alias = "g_loadable_icon_load_async")]
fn load_async<P: FnOnce(Result<(InputStream, glib::GString), glib::Error>) + 'static>(
&self,
size: i32,
cancellable: Option<&impl IsA<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 load_async_trampoline<
P: FnOnce(Result<(InputStream, glib::GString), glib::Error>) + 'static,
>(
_source_object: *mut glib::gobject_ffi::GObject,
res: *mut crate::ffi::GAsyncResult,
user_data: glib::ffi::gpointer,
) {
let mut error = std::ptr::null_mut();
let mut type_ = std::ptr::null_mut();
let ret = ffi::g_loadable_icon_load_finish(
_source_object as *mut _,
res,
&mut type_,
&mut error,
);
let result = if error.is_null() {
Ok((from_glib_full(ret), from_glib_full(type_)))
} 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 = load_async_trampoline::<P>;
unsafe {
ffi::g_loadable_icon_load_async(
self.as_ref().to_glib_none().0,
size,
cancellable.map(|p| p.as_ref()).to_glib_none().0,
Some(callback),
Box_::into_raw(user_data) as *mut _,
);
}
}
fn load_future(
&self,
size: i32,
) -> Pin<
Box_<
dyn std::future::Future<Output = Result<(InputStream, glib::GString), glib::Error>>
+ 'static,
>,
> {
Box_::pin(crate::GioFuture::new(
self,
move |obj, cancellable, send| {
obj.load_async(size, Some(cancellable), move |res| {
send.resolve(res);
});
},
))
}
}
impl<O: IsA<LoadableIcon>> LoadableIconExt for O {}