1 // This file was generated by gir (https://github.com/gtk-rs/gir)
2 // from gir-files (https://github.com/gtk-rs/gir-files)
3 // DO NOT EDIT
4 
5 use crate::IconTheme;
6 use crate::StyleContext;
7 use glib::object::IsA;
8 use glib::translate::*;
9 use std::boxed::Box as Box_;
10 use std::fmt;
11 use std::mem;
12 use std::pin::Pin;
13 use std::ptr;
14 
15 glib::wrapper! {
16     #[doc(alias = "GtkIconInfo")]
17     pub struct IconInfo(Object<ffi::GtkIconInfo, ffi::GtkIconInfoClass>);
18 
19     match fn {
20         type_ => || ffi::gtk_icon_info_get_type(),
21     }
22 }
23 
24 impl IconInfo {
25     #[doc(alias = "gtk_icon_info_new_for_pixbuf")]
26     #[doc(alias = "new_for_pixbuf")]
for_pixbuf<P: IsA<IconTheme>>(icon_theme: &P, pixbuf: &gdk_pixbuf::Pixbuf) -> IconInfo27     pub fn for_pixbuf<P: IsA<IconTheme>>(icon_theme: &P, pixbuf: &gdk_pixbuf::Pixbuf) -> IconInfo {
28         skip_assert_initialized!();
29         unsafe {
30             from_glib_full(ffi::gtk_icon_info_new_for_pixbuf(
31                 icon_theme.as_ref().to_glib_none().0,
32                 pixbuf.to_glib_none().0,
33             ))
34         }
35     }
36 
37     #[doc(alias = "gtk_icon_info_get_base_scale")]
38     #[doc(alias = "get_base_scale")]
base_scale(&self) -> i3239     pub fn base_scale(&self) -> i32 {
40         unsafe { ffi::gtk_icon_info_get_base_scale(self.to_glib_none().0) }
41     }
42 
43     #[doc(alias = "gtk_icon_info_get_base_size")]
44     #[doc(alias = "get_base_size")]
base_size(&self) -> i3245     pub fn base_size(&self) -> i32 {
46         unsafe { ffi::gtk_icon_info_get_base_size(self.to_glib_none().0) }
47     }
48 
49     #[doc(alias = "gtk_icon_info_get_filename")]
50     #[doc(alias = "get_filename")]
filename(&self) -> Option<std::path::PathBuf>51     pub fn filename(&self) -> Option<std::path::PathBuf> {
52         unsafe { from_glib_none(ffi::gtk_icon_info_get_filename(self.to_glib_none().0)) }
53     }
54 
55     #[doc(alias = "gtk_icon_info_is_symbolic")]
is_symbolic(&self) -> bool56     pub fn is_symbolic(&self) -> bool {
57         unsafe { from_glib(ffi::gtk_icon_info_is_symbolic(self.to_glib_none().0)) }
58     }
59 
60     #[doc(alias = "gtk_icon_info_load_icon")]
load_icon(&self) -> Result<gdk_pixbuf::Pixbuf, glib::Error>61     pub fn load_icon(&self) -> Result<gdk_pixbuf::Pixbuf, glib::Error> {
62         unsafe {
63             let mut error = ptr::null_mut();
64             let ret = ffi::gtk_icon_info_load_icon(self.to_glib_none().0, &mut error);
65             if error.is_null() {
66                 Ok(from_glib_full(ret))
67             } else {
68                 Err(from_glib_full(error))
69             }
70         }
71     }
72 
73     #[doc(alias = "gtk_icon_info_load_icon_async")]
load_icon_async< P: IsA<gio::Cancellable>, Q: FnOnce(Result<gdk_pixbuf::Pixbuf, glib::Error>) + Send + 'static, >( &self, cancellable: Option<&P>, callback: Q, )74     pub fn load_icon_async<
75         P: IsA<gio::Cancellable>,
76         Q: FnOnce(Result<gdk_pixbuf::Pixbuf, glib::Error>) + Send + 'static,
77     >(
78         &self,
79         cancellable: Option<&P>,
80         callback: Q,
81     ) {
82         let user_data: Box_<Q> = Box_::new(callback);
83         unsafe extern "C" fn load_icon_async_trampoline<
84             Q: FnOnce(Result<gdk_pixbuf::Pixbuf, glib::Error>) + Send + 'static,
85         >(
86             _source_object: *mut glib::gobject_ffi::GObject,
87             res: *mut gio::ffi::GAsyncResult,
88             user_data: glib::ffi::gpointer,
89         ) {
90             let mut error = ptr::null_mut();
91             let ret =
92                 ffi::gtk_icon_info_load_icon_finish(_source_object as *mut _, res, &mut error);
93             let result = if error.is_null() {
94                 Ok(from_glib_full(ret))
95             } else {
96                 Err(from_glib_full(error))
97             };
98             let callback: Box_<Q> = Box_::from_raw(user_data as *mut _);
99             callback(result);
100         }
101         let callback = load_icon_async_trampoline::<Q>;
102         unsafe {
103             ffi::gtk_icon_info_load_icon_async(
104                 self.to_glib_none().0,
105                 cancellable.map(|p| p.as_ref()).to_glib_none().0,
106                 Some(callback),
107                 Box_::into_raw(user_data) as *mut _,
108             );
109         }
110     }
111 
load_icon_async_future( &self, ) -> Pin< Box_<dyn std::future::Future<Output = Result<gdk_pixbuf::Pixbuf, glib::Error>> + 'static>, >112     pub fn load_icon_async_future(
113         &self,
114     ) -> Pin<
115         Box_<dyn std::future::Future<Output = Result<gdk_pixbuf::Pixbuf, glib::Error>> + 'static>,
116     > {
117         Box_::pin(gio::GioFuture::new(self, move |obj, cancellable, send| {
118             obj.load_icon_async(Some(cancellable), move |res| {
119                 send.resolve(res);
120             });
121         }))
122     }
123 
124     #[doc(alias = "gtk_icon_info_load_surface")]
load_surface( &self, for_window: Option<&gdk::Window>, ) -> Result<cairo::Surface, glib::Error>125     pub fn load_surface(
126         &self,
127         for_window: Option<&gdk::Window>,
128     ) -> Result<cairo::Surface, glib::Error> {
129         unsafe {
130             let mut error = ptr::null_mut();
131             let ret = ffi::gtk_icon_info_load_surface(
132                 self.to_glib_none().0,
133                 for_window.to_glib_none().0,
134                 &mut error,
135             );
136             if error.is_null() {
137                 Ok(from_glib_full(ret))
138             } else {
139                 Err(from_glib_full(error))
140             }
141         }
142     }
143 
144     #[doc(alias = "gtk_icon_info_load_symbolic")]
load_symbolic( &self, fg: &gdk::RGBA, success_color: Option<&gdk::RGBA>, warning_color: Option<&gdk::RGBA>, error_color: Option<&gdk::RGBA>, ) -> Result<(gdk_pixbuf::Pixbuf, bool), glib::Error>145     pub fn load_symbolic(
146         &self,
147         fg: &gdk::RGBA,
148         success_color: Option<&gdk::RGBA>,
149         warning_color: Option<&gdk::RGBA>,
150         error_color: Option<&gdk::RGBA>,
151     ) -> Result<(gdk_pixbuf::Pixbuf, bool), glib::Error> {
152         unsafe {
153             let mut was_symbolic = mem::MaybeUninit::uninit();
154             let mut error = ptr::null_mut();
155             let ret = ffi::gtk_icon_info_load_symbolic(
156                 self.to_glib_none().0,
157                 fg.to_glib_none().0,
158                 success_color.to_glib_none().0,
159                 warning_color.to_glib_none().0,
160                 error_color.to_glib_none().0,
161                 was_symbolic.as_mut_ptr(),
162                 &mut error,
163             );
164             let was_symbolic = was_symbolic.assume_init();
165             if error.is_null() {
166                 Ok((from_glib_full(ret), from_glib(was_symbolic)))
167             } else {
168                 Err(from_glib_full(error))
169             }
170         }
171     }
172 
173     #[doc(alias = "gtk_icon_info_load_symbolic_async")]
load_symbolic_async< P: IsA<gio::Cancellable>, Q: FnOnce(Result<(gdk_pixbuf::Pixbuf, bool), glib::Error>) + Send + 'static, >( &self, fg: &gdk::RGBA, success_color: Option<&gdk::RGBA>, warning_color: Option<&gdk::RGBA>, error_color: Option<&gdk::RGBA>, cancellable: Option<&P>, callback: Q, )174     pub fn load_symbolic_async<
175         P: IsA<gio::Cancellable>,
176         Q: FnOnce(Result<(gdk_pixbuf::Pixbuf, bool), glib::Error>) + Send + 'static,
177     >(
178         &self,
179         fg: &gdk::RGBA,
180         success_color: Option<&gdk::RGBA>,
181         warning_color: Option<&gdk::RGBA>,
182         error_color: Option<&gdk::RGBA>,
183         cancellable: Option<&P>,
184         callback: Q,
185     ) {
186         let user_data: Box_<Q> = Box_::new(callback);
187         unsafe extern "C" fn load_symbolic_async_trampoline<
188             Q: FnOnce(Result<(gdk_pixbuf::Pixbuf, bool), glib::Error>) + Send + 'static,
189         >(
190             _source_object: *mut glib::gobject_ffi::GObject,
191             res: *mut gio::ffi::GAsyncResult,
192             user_data: glib::ffi::gpointer,
193         ) {
194             let mut error = ptr::null_mut();
195             let mut was_symbolic = mem::MaybeUninit::uninit();
196             let ret = ffi::gtk_icon_info_load_symbolic_finish(
197                 _source_object as *mut _,
198                 res,
199                 was_symbolic.as_mut_ptr(),
200                 &mut error,
201             );
202             let was_symbolic = was_symbolic.assume_init();
203             let result = if error.is_null() {
204                 Ok((from_glib_full(ret), from_glib(was_symbolic)))
205             } else {
206                 Err(from_glib_full(error))
207             };
208             let callback: Box_<Q> = Box_::from_raw(user_data as *mut _);
209             callback(result);
210         }
211         let callback = load_symbolic_async_trampoline::<Q>;
212         unsafe {
213             ffi::gtk_icon_info_load_symbolic_async(
214                 self.to_glib_none().0,
215                 fg.to_glib_none().0,
216                 success_color.to_glib_none().0,
217                 warning_color.to_glib_none().0,
218                 error_color.to_glib_none().0,
219                 cancellable.map(|p| p.as_ref()).to_glib_none().0,
220                 Some(callback),
221                 Box_::into_raw(user_data) as *mut _,
222             );
223         }
224     }
225 
load_symbolic_async_future( &self, fg: &gdk::RGBA, success_color: Option<&gdk::RGBA>, warning_color: Option<&gdk::RGBA>, error_color: Option<&gdk::RGBA>, ) -> Pin< Box_< dyn std::future::Future<Output = Result<(gdk_pixbuf::Pixbuf, bool), glib::Error>> + 'static, >, >226     pub fn load_symbolic_async_future(
227         &self,
228         fg: &gdk::RGBA,
229         success_color: Option<&gdk::RGBA>,
230         warning_color: Option<&gdk::RGBA>,
231         error_color: Option<&gdk::RGBA>,
232     ) -> Pin<
233         Box_<
234             dyn std::future::Future<Output = Result<(gdk_pixbuf::Pixbuf, bool), glib::Error>>
235                 + 'static,
236         >,
237     > {
238         let fg = fg.clone();
239         let success_color = success_color.map(ToOwned::to_owned);
240         let warning_color = warning_color.map(ToOwned::to_owned);
241         let error_color = error_color.map(ToOwned::to_owned);
242         Box_::pin(gio::GioFuture::new(self, move |obj, cancellable, send| {
243             obj.load_symbolic_async(
244                 &fg,
245                 success_color.as_ref().map(::std::borrow::Borrow::borrow),
246                 warning_color.as_ref().map(::std::borrow::Borrow::borrow),
247                 error_color.as_ref().map(::std::borrow::Borrow::borrow),
248                 Some(cancellable),
249                 move |res| {
250                     send.resolve(res);
251                 },
252             );
253         }))
254     }
255 
256     #[doc(alias = "gtk_icon_info_load_symbolic_for_context")]
load_symbolic_for_context<P: IsA<StyleContext>>( &self, context: &P, ) -> Result<(gdk_pixbuf::Pixbuf, bool), glib::Error>257     pub fn load_symbolic_for_context<P: IsA<StyleContext>>(
258         &self,
259         context: &P,
260     ) -> Result<(gdk_pixbuf::Pixbuf, bool), glib::Error> {
261         unsafe {
262             let mut was_symbolic = mem::MaybeUninit::uninit();
263             let mut error = ptr::null_mut();
264             let ret = ffi::gtk_icon_info_load_symbolic_for_context(
265                 self.to_glib_none().0,
266                 context.as_ref().to_glib_none().0,
267                 was_symbolic.as_mut_ptr(),
268                 &mut error,
269             );
270             let was_symbolic = was_symbolic.assume_init();
271             if error.is_null() {
272                 Ok((from_glib_full(ret), from_glib(was_symbolic)))
273             } else {
274                 Err(from_glib_full(error))
275             }
276         }
277     }
278 
279     #[doc(alias = "gtk_icon_info_load_symbolic_for_context_async")]
load_symbolic_for_context_async< P: IsA<StyleContext>, Q: IsA<gio::Cancellable>, R: FnOnce(Result<(gdk_pixbuf::Pixbuf, bool), glib::Error>) + Send + 'static, >( &self, context: &P, cancellable: Option<&Q>, callback: R, )280     pub fn load_symbolic_for_context_async<
281         P: IsA<StyleContext>,
282         Q: IsA<gio::Cancellable>,
283         R: FnOnce(Result<(gdk_pixbuf::Pixbuf, bool), glib::Error>) + Send + 'static,
284     >(
285         &self,
286         context: &P,
287         cancellable: Option<&Q>,
288         callback: R,
289     ) {
290         let user_data: Box_<R> = Box_::new(callback);
291         unsafe extern "C" fn load_symbolic_for_context_async_trampoline<
292             R: FnOnce(Result<(gdk_pixbuf::Pixbuf, bool), glib::Error>) + Send + 'static,
293         >(
294             _source_object: *mut glib::gobject_ffi::GObject,
295             res: *mut gio::ffi::GAsyncResult,
296             user_data: glib::ffi::gpointer,
297         ) {
298             let mut error = ptr::null_mut();
299             let mut was_symbolic = mem::MaybeUninit::uninit();
300             let ret = ffi::gtk_icon_info_load_symbolic_for_context_finish(
301                 _source_object as *mut _,
302                 res,
303                 was_symbolic.as_mut_ptr(),
304                 &mut error,
305             );
306             let was_symbolic = was_symbolic.assume_init();
307             let result = if error.is_null() {
308                 Ok((from_glib_full(ret), from_glib(was_symbolic)))
309             } else {
310                 Err(from_glib_full(error))
311             };
312             let callback: Box_<R> = Box_::from_raw(user_data as *mut _);
313             callback(result);
314         }
315         let callback = load_symbolic_for_context_async_trampoline::<R>;
316         unsafe {
317             ffi::gtk_icon_info_load_symbolic_for_context_async(
318                 self.to_glib_none().0,
319                 context.as_ref().to_glib_none().0,
320                 cancellable.map(|p| p.as_ref()).to_glib_none().0,
321                 Some(callback),
322                 Box_::into_raw(user_data) as *mut _,
323             );
324         }
325     }
326 
load_symbolic_for_context_async_future<P: IsA<StyleContext> + Clone + 'static>( &self, context: &P, ) -> Pin< Box_< dyn std::future::Future<Output = Result<(gdk_pixbuf::Pixbuf, bool), glib::Error>> + 'static, >, >327     pub fn load_symbolic_for_context_async_future<P: IsA<StyleContext> + Clone + 'static>(
328         &self,
329         context: &P,
330     ) -> Pin<
331         Box_<
332             dyn std::future::Future<Output = Result<(gdk_pixbuf::Pixbuf, bool), glib::Error>>
333                 + 'static,
334         >,
335     > {
336         let context = context.clone();
337         Box_::pin(gio::GioFuture::new(self, move |obj, cancellable, send| {
338             obj.load_symbolic_for_context_async(&context, Some(cancellable), move |res| {
339                 send.resolve(res);
340             });
341         }))
342     }
343 }
344 
345 impl fmt::Display for IconInfo {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result346     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
347         f.write_str("IconInfo")
348     }
349 }
350