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
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
// 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::Pixbuf;
use glib::{prelude::*, translate::*};
use std::{boxed::Box as Box_, fmt, pin::Pin, ptr};

glib::wrapper! {
    /// An opaque object representing an animation.
    ///
    /// The GdkPixBuf library provides a simple mechanism to load and
    /// represent animations. An animation is conceptually a series of
    /// frames to be displayed over time.
    ///
    /// The animation may not be represented as a series of frames
    /// internally; for example, it may be stored as a sprite and
    /// instructions for moving the sprite around a background.
    ///
    /// To display an animation you don't need to understand its
    /// representation, however; you just ask [`Pixbuf`][crate::Pixbuf] what should
    /// be displayed at a given point in time.
    ///
    /// # Implements
    ///
    /// [`PixbufAnimationExt`][trait@crate::prelude::PixbufAnimationExt], [`PixbufAnimationExtManual`][trait@crate::prelude::PixbufAnimationExtManual]
    #[doc(alias = "GdkPixbufAnimation")]
    pub struct PixbufAnimation(Object<ffi::GdkPixbufAnimation, ffi::GdkPixbufAnimationClass>);

    match fn {
        type_ => || ffi::gdk_pixbuf_animation_get_type(),
    }
}

impl PixbufAnimation {
    pub const NONE: Option<&'static PixbufAnimation> = None;

    /// Creates a new animation by loading it from a file.
    ///
    /// The file format is detected automatically.
    ///
    /// If the file's format does not support multi-frame images, then an animation
    /// with a single frame will be created.
    ///
    /// Possible errors are in the `GDK_PIXBUF_ERROR` and `G_FILE_ERROR` domains.
    /// ## `filename`
    /// Name of file to load, in the GLib file
    ///   name encoding
    ///
    /// # Returns
    ///
    /// A newly-created animation
    #[doc(alias = "gdk_pixbuf_animation_new_from_file")]
    #[doc(alias = "new_from_file")]
    pub fn from_file(
        filename: impl AsRef<std::path::Path>,
    ) -> Result<PixbufAnimation, glib::Error> {
        unsafe {
            let mut error = ptr::null_mut();
            let ret = ffi::gdk_pixbuf_animation_new_from_file(
                filename.as_ref().to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Creates a new pixbuf animation by loading an image from an resource.
    ///
    /// The file format is detected automatically. If `NULL` is returned, then
    /// @error will be set.
    /// ## `resource_path`
    /// the path of the resource file
    ///
    /// # Returns
    ///
    /// A newly-created animation
    #[doc(alias = "gdk_pixbuf_animation_new_from_resource")]
    #[doc(alias = "new_from_resource")]
    pub fn from_resource(resource_path: &str) -> Result<PixbufAnimation, glib::Error> {
        unsafe {
            let mut error = ptr::null_mut();
            let ret = ffi::gdk_pixbuf_animation_new_from_resource(
                resource_path.to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Creates a new animation by loading it from an input stream.
    ///
    /// The file format is detected automatically.
    ///
    /// If `NULL` is returned, then @error will be set.
    ///
    /// The @cancellable can be used to abort the operation from another thread.
    /// If the operation was cancelled, the error `G_IO_ERROR_CANCELLED` will be
    /// returned. Other possible errors are in the `GDK_PIXBUF_ERROR` and
    /// `G_IO_ERROR` domains.
    ///
    /// The stream is not closed.
    /// ## `stream`
    /// a `GInputStream` to load the pixbuf from
    /// ## `cancellable`
    /// optional `GCancellable` object
    ///
    /// # Returns
    ///
    /// A newly-created animation
    #[doc(alias = "gdk_pixbuf_animation_new_from_stream")]
    #[doc(alias = "new_from_stream")]
    pub fn from_stream(
        stream: &impl IsA<gio::InputStream>,
        cancellable: Option<&impl IsA<gio::Cancellable>>,
    ) -> Result<PixbufAnimation, glib::Error> {
        unsafe {
            let mut error = 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,
                &mut error,
            );
            if error.is_null() {
                Ok(from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Creates a new animation by asynchronously loading an image from an input stream.
    ///
    /// For more details see gdk_pixbuf_new_from_stream(), which is the synchronous
    /// version of this function.
    ///
    /// When the operation is finished, `callback` will be called in the main thread.
    /// You can then call gdk_pixbuf_animation_new_from_stream_finish() to get the
    /// result of the operation.
    /// ## `stream`
    /// a #GInputStream from which to load the animation
    /// ## `cancellable`
    /// optional #GCancellable object
    /// ## `callback`
    /// a `GAsyncReadyCallback` to call when the pixbuf is loaded
    #[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>(
        stream: &impl IsA<gio::InputStream>,
        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 from_stream_async_trampoline<
            P: FnOnce(Result<PixbufAnimation, 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 ret = ffi::gdk_pixbuf_animation_new_from_stream_finish(res, &mut error);
            let result = if error.is_null() {
                Ok(from_glib_full(ret))
            } 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 = from_stream_async_trampoline::<P>;
        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,
                Some(callback),
                Box_::into_raw(user_data) as *mut _,
            );
        }
    }

    pub fn from_stream_future(
        stream: &(impl IsA<gio::InputStream> + Clone + 'static),
    ) -> Pin<Box_<dyn std::future::Future<Output = Result<PixbufAnimation, glib::Error>> + 'static>>
    {
        let stream = stream.clone();
        Box_::pin(gio::GioFuture::new(&(), move |_obj, cancellable, send| {
            Self::from_stream_async(&stream, Some(cancellable), move |res| {
                send.resolve(res);
            });
        }))
    }
}

mod sealed {
    pub trait Sealed {}
    impl<T: super::IsA<super::PixbufAnimation>> Sealed for T {}
}

/// Trait containing all [`struct@PixbufAnimation`] methods.
///
/// # Implementors
///
/// [`PixbufAnimation`][struct@crate::PixbufAnimation], [`PixbufNonAnim`][struct@crate::PixbufNonAnim], [`PixbufSimpleAnim`][struct@crate::PixbufSimpleAnim]
pub trait PixbufAnimationExt: IsA<PixbufAnimation> + sealed::Sealed + 'static {
    /// Queries the height of the bounding box of a pixbuf animation.
    ///
    /// # Returns
    ///
    /// Height of the bounding box of the animation.
    #[doc(alias = "gdk_pixbuf_animation_get_height")]
    #[doc(alias = "get_height")]
    fn height(&self) -> i32 {
        unsafe { ffi::gdk_pixbuf_animation_get_height(self.as_ref().to_glib_none().0) }
    }

    /// Retrieves a static image for the animation.
    ///
    /// If an animation is really just a plain image (has only one frame),
    /// this function returns that image.
    ///
    /// If the animation is an animation, this function returns a reasonable
    /// image to use as a static unanimated image, which might be the first
    /// frame, or something more sophisticated depending on the file format.
    ///
    /// If an animation hasn't loaded any frames yet, this function will
    /// return `NULL`.
    ///
    /// # Returns
    ///
    /// unanimated image representing the animation
    #[doc(alias = "gdk_pixbuf_animation_get_static_image")]
    #[doc(alias = "get_static_image")]
    fn static_image(&self) -> Option<Pixbuf> {
        unsafe {
            from_glib_none(ffi::gdk_pixbuf_animation_get_static_image(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Queries the width of the bounding box of a pixbuf animation.
    ///
    /// # Returns
    ///
    /// Width of the bounding box of the animation.
    #[doc(alias = "gdk_pixbuf_animation_get_width")]
    #[doc(alias = "get_width")]
    fn width(&self) -> i32 {
        unsafe { ffi::gdk_pixbuf_animation_get_width(self.as_ref().to_glib_none().0) }
    }

    /// Checks whether the animation is a static image.
    ///
    /// If you load a file with gdk_pixbuf_animation_new_from_file() and it
    /// turns out to be a plain, unanimated image, then this function will
    /// return `TRUE`. Use gdk_pixbuf_animation_get_static_image() to retrieve
    /// the image.
    ///
    /// # Returns
    ///
    /// `TRUE` if the "animation" was really just an image
    #[doc(alias = "gdk_pixbuf_animation_is_static_image")]
    fn is_static_image(&self) -> bool {
        unsafe {
            from_glib(ffi::gdk_pixbuf_animation_is_static_image(
                self.as_ref().to_glib_none().0,
            ))
        }
    }
}

impl<O: IsA<PixbufAnimation>> PixbufAnimationExt for O {}

impl fmt::Display for PixbufAnimation {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.write_str("PixbufAnimation")
    }
}