// 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::object::IsA;
use glib::translate::*;
use std::boxed::Box as Box_;
use std::fmt;
use std::pin::Pin;
use std::ptr;

glib::wrapper! {
    /// An opaque struct representing an animation.
    ///
    /// # Implements
    ///
    /// [`PixbufAnimationExt`][trait@crate::prelude::PixbufAnimationExt]
    #[doc(alias = "GdkPixbufAnimation")]
    pub struct PixbufAnimation(Object<ffi::GdkPixbufAnimation, ffi::GdkPixbufAnimationClass>);

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

impl PixbufAnimation {
    /// 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 with a reference count of 1, or [`None`]
    /// if any of several error conditions ocurred: the file could not be opened,
    /// there was no loader for the file's format, there was not enough memory to
    /// allocate the image buffer, or the image file contained invalid data.
    #[doc(alias = "gdk_pixbuf_animation_new_from_file")]
    #[doc(alias = "new_from_file")]
    pub fn from_file<P: AsRef<std::path::Path>>(
        filename: P,
    ) -> 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 [`None`] is returned, then
    /// `error` will be set.
    /// ## `resource_path`
    /// the path of the resource file
    ///
    /// # Returns
    ///
    /// A newly-created animation, or [`None`] if any of several error
    /// conditions occurred: the file could not be opened, the image format is
    /// not supported, there was not enough memory to allocate the image buffer,
    /// the stream contained invalid data, or the operation was cancelled.
    #[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 [`None`] 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 [`gio::InputStream`][crate::gio::InputStream] to load the pixbuf from
    /// ## `cancellable`
    /// optional [`gio::Cancellable`][crate::gio::Cancellable] object, [`None`] to ignore
    ///
    /// # Returns
    ///
    /// A newly-created pixbuf, or [`None`] if any of several error
    /// conditions occurred: the file could not be opened, the image format is
    /// not supported, there was not enough memory to allocate the image buffer,
    /// the stream contained invalid data, or the operation was cancelled.
    #[doc(alias = "gdk_pixbuf_animation_new_from_stream")]
    #[doc(alias = "new_from_stream")]
    pub fn from_stream<P: IsA<gio::InputStream>, Q: IsA<gio::Cancellable>>(
        stream: &P,
        cancellable: Option<&Q>,
    ) -> 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 [`Pixbuf::from_stream()`][crate::Pixbuf::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 [`gio::InputStream`][crate::gio::InputStream] from which to load the animation
    /// ## `cancellable`
    /// optional [`gio::Cancellable`][crate::gio::Cancellable] object, [`None`] to ignore
    /// ## `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: IsA<gio::InputStream>,
        Q: IsA<gio::Cancellable>,
        R: FnOnce(Result<PixbufAnimation, glib::Error>) + Send + 'static,
    >(
        stream: &P,
        cancellable: Option<&Q>,
        callback: R,
    ) {
        let user_data: Box_<R> = Box_::new(callback);
        unsafe extern "C" fn from_stream_async_trampoline<
            R: FnOnce(Result<PixbufAnimation, glib::Error>) + Send + '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_<R> = Box_::from_raw(user_data as *mut _);
            callback(result);
        }
        let callback = from_stream_async_trampoline::<R>;
        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_async_future<P: IsA<gio::InputStream> + Clone + 'static>(
        stream: &P,
    ) -> 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);
            });
        }))
    }
}

pub const NONE_PIXBUF_ANIMATION: Option<&PixbufAnimation> = None;

/// Trait containing all [`struct@PixbufAnimation`] methods.
///
/// # Implementors
///
/// [`PixbufAnimation`][struct@crate::PixbufAnimation], [`PixbufSimpleAnim`][struct@crate::PixbufSimpleAnim]
pub trait PixbufAnimationExt: '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;

    /// 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 thing to display as a static
    /// unanimated image, which might be the first frame, or something more
    /// sophisticated. If an animation hasn't loaded any frames yet, this
    /// function will return [`None`].
    ///
    /// # 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>;

    /// 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;

    /// If you load a file with [`PixbufAnimation::from_file()`][crate::PixbufAnimation::from_file()] and it
    /// turns out to be a plain, unanimated image, then this function will
    /// return [`true`]. Use [`static_image()`][Self::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;
}

impl<O: IsA<PixbufAnimation>> PixbufAnimationExt for O {
    fn height(&self) -> i32 {
        unsafe { ffi::gdk_pixbuf_animation_get_height(self.as_ref().to_glib_none().0) }
    }

    fn static_image(&self) -> Option<Pixbuf> {
        unsafe {
            from_glib_none(ffi::gdk_pixbuf_animation_get_static_image(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn width(&self) -> i32 {
        unsafe { ffi::gdk_pixbuf_animation_get_width(self.as_ref().to_glib_none().0) }
    }

    fn is_static_image(&self) -> bool {
        unsafe {
            from_glib(ffi::gdk_pixbuf_animation_is_static_image(
                self.as_ref().to_glib_none().0,
            ))
        }
    }
}

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