// 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::Colorspace;
use crate::InterpType;
use crate::PixbufFormat;
use crate::PixbufRotation;
use glib::object::IsA;
use glib::object::ObjectType as ObjectType_;
use glib::translate::*;
use glib::StaticType;
use std::fmt;
use std::ptr;

glib::wrapper! {
    /// A pixel buffer.
    ///
    /// [`Pixbuf`][crate::Pixbuf] contains information about an image's pixel data,
    /// its color space, bits per sample, width and height, and the
    /// rowstride (the number of bytes between the start of one row
    /// and the start of the next).
    ///
    /// ## Creating new [`Pixbuf`][crate::Pixbuf]
    ///
    /// The most basic way to create a pixbuf is to wrap an existing pixel
    /// buffer with a [`Pixbuf`][crate::Pixbuf] instance. You can use the
    /// [`ctor@GdkPixbuf.Pixbuf.new_from_data`] function to do this.
    ///
    /// Every time you create a new [`Pixbuf`][crate::Pixbuf] instance for some data, you
    /// will need to specify the destroy notification function that will be
    /// called when the data buffer needs to be freed; this will happen when
    /// a [`Pixbuf`][crate::Pixbuf] is finalized by the reference counting functions. If
    /// you have a chunk of static data compiled into your application, you
    /// can pass in `NULL` as the destroy notification function so that the
    /// data will not be freed.
    ///
    /// The [`ctor@GdkPixbuf.Pixbuf.new`] constructor function can be used
    /// as a convenience to create a pixbuf with an empty buffer; this is
    /// equivalent to allocating a data buffer using `malloc()` and then
    /// wrapping it with `gdk_pixbuf_new_from_data()`. The `gdk_pixbuf_new()`
    /// function will compute an optimal rowstride so that rendering can be
    /// performed with an efficient algorithm.
    ///
    /// As a special case, you can use the [`ctor@GdkPixbuf.Pixbuf.new_from_xpm_data`]
    /// function to create a pixbuf from inline XPM image data.
    ///
    /// You can also copy an existing pixbuf with the `Pixbuf::copy()`
    /// function. This is not the same as just acquiring a reference to
    /// the old pixbuf instance: the copy function will actually duplicate
    /// the pixel data in memory and create a new [`Pixbuf`][crate::Pixbuf] instance
    /// for it.
    ///
    /// ## Reference counting
    ///
    /// [`Pixbuf`][crate::Pixbuf] structures are reference counted. This means that an
    /// application can share a single pixbuf among many parts of the
    /// code. When a piece of the program needs to use a pixbuf, it should
    /// acquire a reference to it by calling `g_object_ref()`; when it no
    /// longer needs the pixbuf, it should release the reference it acquired
    /// by calling `g_object_unref()`. The resources associated with a
    /// [`Pixbuf`][crate::Pixbuf] will be freed when its reference count drops to zero.
    /// Newly-created [`Pixbuf`][crate::Pixbuf] instances start with a reference count
    /// of one.
    ///
    /// ## Image Data
    ///
    /// Image data in a pixbuf is stored in memory in an uncompressed,
    /// packed format. Rows in the image are stored top to bottom, and
    /// in each row pixels are stored from left to right.
    ///
    /// There may be padding at the end of a row.
    ///
    /// The "rowstride" value of a pixbuf, as returned by [`method@GdkPixbuf.Pixbuf.get_rowstride`],
    /// indicates the number of bytes between rows.
    ///
    /// **NOTE**: If you are copying raw pixbuf data with `memcpy()` note that the
    /// last row in the pixbuf may not be as wide as the full rowstride, but rather
    /// just as wide as the pixel data needs to be; that is: it is unsafe to do
    /// `memcpy (dest, pixels, rowstride * height)` to copy a whole pixbuf. Use
    /// `GdkPixbuf::Pixbuf::copy()` instead, or compute the width in bytes of the
    /// last row as:
    ///
    /// **⚠️ The following code is in c ⚠️**
    ///
    /// ```c
    /// last_row = width * ((n_channels * bits_per_sample + 7) / 8);
    /// ```
    ///
    /// The same rule applies when iterating over each row of a [`Pixbuf`][crate::Pixbuf] pixels
    /// array.
    ///
    /// The following code illustrates a simple `put_pixel()`
    /// function for RGB pixbufs with 8 bits per channel with an alpha
    /// channel.
    ///
    /// **⚠️ The following code is in c ⚠️**
    ///
    /// ```c
    /// static void
    /// put_pixel (GdkPixbuf *pixbuf,
    ///            int x,
    ///        int y,
    ///        guchar red,
    ///        guchar green,
    ///        guchar blue,
    ///        guchar alpha)
    /// {
    ///   int n_channels = gdk_pixbuf_get_n_channels (pixbuf);
    ///
    ///   // Ensure that the pixbuf is valid
    ///   g_assert (gdk_pixbuf_get_colorspace (pixbuf) == GDK_COLORSPACE_RGB);
    ///   g_assert (gdk_pixbuf_get_bits_per_sample (pixbuf) == 8);
    ///   g_assert (gdk_pixbuf_get_has_alpha (pixbuf));
    ///   g_assert (n_channels == 4);
    ///
    ///   int width = gdk_pixbuf_get_width (pixbuf);
    ///   int height = gdk_pixbuf_get_height (pixbuf);
    ///
    ///   // Ensure that the coordinates are in a valid range
    ///   g_assert (x >= 0 && x < width);
    ///   g_assert (y >= 0 && y < height);
    ///
    ///   int rowstride = gdk_pixbuf_get_rowstride (pixbuf);
    ///
    ///   // The pixel buffer in the GdkPixbuf instance
    ///   guchar *pixels = gdk_pixbuf_get_pixels (pixbuf);
    ///
    ///   // The pixel we wish to modify
    ///   guchar *p = pixels + y * rowstride + x * n_channels;
    ///   p[0] = red;
    ///   p[1] = green;
    ///   p[2] = blue;
    ///   p[3] = alpha;
    /// }
    /// ```
    ///
    /// ## Loading images
    ///
    /// The `GdkPixBuf` class provides a simple mechanism for loading
    /// an image from a file in synchronous and asynchronous fashion.
    ///
    /// For GUI applications, it is recommended to use the asynchronous
    /// stream API to avoid blocking the control flow of the application.
    ///
    /// Additionally, [`Pixbuf`][crate::Pixbuf] provides the [`PixbufLoader`][crate::PixbufLoader]`]
    /// API for progressive image loading.
    ///
    /// ## Saving images
    ///
    /// The [`Pixbuf`][crate::Pixbuf] class provides methods for saving image data in
    /// a number of file formats. The formatted data can be written to a
    /// file or to a memory buffer. [`Pixbuf`][crate::Pixbuf] can also call a user-defined
    /// callback on the data, which allows to e.g. write the image
    /// to a socket or store it in a database.
    ///
    /// # Implements
    ///
    /// [`trait@gio::prelude::IconExt`], [`trait@gio::prelude::LoadableIconExt`]
    #[doc(alias = "GdkPixbuf")]
    pub struct Pixbuf(Object<ffi::GdkPixbuf>) @implements gio::Icon, gio::LoadableIcon;

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

impl Pixbuf {
    /// Creates a new [`Pixbuf`][crate::Pixbuf] structure and allocates a buffer for it.
    ///
    /// If the allocation of the buffer failed, this function will return `NULL`.
    ///
    /// The buffer has an optimal rowstride. Note that the buffer is not cleared;
    /// you will have to fill it completely yourself.
    /// ## `colorspace`
    /// Color space for image
    /// ## `has_alpha`
    /// Whether the image should have transparency information
    /// ## `bits_per_sample`
    /// Number of bits per color sample
    /// ## `width`
    /// Width of image in pixels, must be > 0
    /// ## `height`
    /// Height of image in pixels, must be > 0
    ///
    /// # Returns
    ///
    /// A newly-created pixel buffer
    #[doc(alias = "gdk_pixbuf_new")]
    pub fn new(
        colorspace: Colorspace,
        has_alpha: bool,
        bits_per_sample: i32,
        width: i32,
        height: i32,
    ) -> Option<Pixbuf> {
        unsafe {
            from_glib_full(ffi::gdk_pixbuf_new(
                colorspace.into_glib(),
                has_alpha.into_glib(),
                bits_per_sample,
                width,
                height,
            ))
        }
    }

    /// Creates a new #GdkPixbuf out of in-memory readonly image data.
    ///
    /// Currently only RGB images with 8 bits per sample are supported.
    ///
    /// This is the `GBytes` variant of gdk_pixbuf_new_from_data(), useful
    /// for language bindings.
    /// ## `data`
    /// Image data in 8-bit/sample packed format inside a #GBytes
    /// ## `colorspace`
    /// Colorspace for the image data
    /// ## `has_alpha`
    /// Whether the data has an opacity channel
    /// ## `bits_per_sample`
    /// Number of bits per sample
    /// ## `width`
    /// Width of the image in pixels, must be > 0
    /// ## `height`
    /// Height of the image in pixels, must be > 0
    /// ## `rowstride`
    /// Distance in bytes between row starts
    ///
    /// # Returns
    ///
    /// A newly-created pixbuf
    #[doc(alias = "gdk_pixbuf_new_from_bytes")]
    #[doc(alias = "new_from_bytes")]
    pub fn from_bytes(
        data: &glib::Bytes,
        colorspace: Colorspace,
        has_alpha: bool,
        bits_per_sample: i32,
        width: i32,
        height: i32,
        rowstride: i32,
    ) -> Pixbuf {
        unsafe {
            from_glib_full(ffi::gdk_pixbuf_new_from_bytes(
                data.to_glib_none().0,
                colorspace.into_glib(),
                has_alpha.into_glib(),
                bits_per_sample,
                width,
                height,
                rowstride,
            ))
        }
    }

    //#[doc(alias = "gdk_pixbuf_new_from_data")]
    //#[doc(alias = "new_from_data")]
    //pub fn from_data(data: &[u8], colorspace: Colorspace, has_alpha: bool, bits_per_sample: i32, width: i32, height: i32, rowstride: i32, destroy_fn: Option<Box_<dyn FnOnce(&Vec<u8>) + 'static>>) -> Pixbuf {
    //    unsafe { TODO: call ffi:gdk_pixbuf_new_from_data() }
    //}

    /// Creates a new pixbuf 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 pixbuf
    #[doc(alias = "gdk_pixbuf_new_from_resource")]
    #[doc(alias = "new_from_resource")]
    pub fn from_resource(resource_path: &str) -> Result<Pixbuf, glib::Error> {
        unsafe {
            let mut error = ptr::null_mut();
            let ret = ffi::gdk_pixbuf_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 pixbuf by loading an image from an resource.
    ///
    /// The file format is detected automatically. If `NULL` is returned, then
    /// @error will be set.
    ///
    /// The image will be scaled to fit in the requested size, optionally
    /// preserving the image's aspect ratio. When preserving the aspect ratio,
    /// a @width of -1 will cause the image to be scaled to the exact given
    /// height, and a @height of -1 will cause the image to be scaled to the
    /// exact given width. When not preserving aspect ratio, a @width or
    /// @height of -1 means to not scale the image at all in that dimension.
    ///
    /// The stream is not closed.
    /// ## `resource_path`
    /// the path of the resource file
    /// ## `width`
    /// The width the image should have or -1 to not constrain the width
    /// ## `height`
    /// The height the image should have or -1 to not constrain the height
    /// ## `preserve_aspect_ratio`
    /// `TRUE` to preserve the image's aspect ratio
    ///
    /// # Returns
    ///
    /// A newly-created pixbuf
    #[doc(alias = "gdk_pixbuf_new_from_resource_at_scale")]
    #[doc(alias = "new_from_resource_at_scale")]
    pub fn from_resource_at_scale(
        resource_path: &str,
        width: i32,
        height: i32,
        preserve_aspect_ratio: bool,
    ) -> Result<Pixbuf, glib::Error> {
        unsafe {
            let mut error = ptr::null_mut();
            let ret = ffi::gdk_pixbuf_new_from_resource_at_scale(
                resource_path.to_glib_none().0,
                width,
                height,
                preserve_aspect_ratio.into_glib(),
                &mut error,
            );
            if error.is_null() {
                Ok(from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Creates a new pixbuf by loading an image 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, `NULL` to ignore
    ///
    /// # Returns
    ///
    /// A newly-created pixbuf
    #[doc(alias = "gdk_pixbuf_new_from_stream")]
    #[doc(alias = "new_from_stream")]
    pub fn from_stream(
        stream: &impl IsA<gio::InputStream>,
        cancellable: Option<&impl IsA<gio::Cancellable>>,
    ) -> Result<Pixbuf, glib::Error> {
        unsafe {
            let mut error = ptr::null_mut();
            let ret = ffi::gdk_pixbuf_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 pixbuf by loading an image 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 image will be scaled to fit in the requested size, optionally
    /// preserving the image's aspect ratio.
    ///
    /// When preserving the aspect ratio, a `width` of -1 will cause the image to be
    /// scaled to the exact given height, and a `height` of -1 will cause the image
    /// to be scaled to the exact given width. If both `width` and `height` are
    /// given, this function will behave as if the smaller of the two values
    /// is passed as -1.
    ///
    /// When not preserving aspect ratio, a `width` or `height` of -1 means to not
    /// scale the image at all in that dimension.
    ///
    /// The stream is not closed.
    /// ## `stream`
    /// a `GInputStream` to load the pixbuf from
    /// ## `width`
    /// The width the image should have or -1 to not constrain the width
    /// ## `height`
    /// The height the image should have or -1 to not constrain the height
    /// ## `preserve_aspect_ratio`
    /// `TRUE` to preserve the image's aspect ratio
    /// ## `cancellable`
    /// optional `GCancellable` object, `NULL` to ignore
    ///
    /// # Returns
    ///
    /// A newly-created pixbuf
    #[doc(alias = "gdk_pixbuf_new_from_stream_at_scale")]
    #[doc(alias = "new_from_stream_at_scale")]
    pub fn from_stream_at_scale(
        stream: &impl IsA<gio::InputStream>,
        width: i32,
        height: i32,
        preserve_aspect_ratio: bool,
        cancellable: Option<&impl IsA<gio::Cancellable>>,
    ) -> Result<Pixbuf, glib::Error> {
        unsafe {
            let mut error = ptr::null_mut();
            let ret = ffi::gdk_pixbuf_new_from_stream_at_scale(
                stream.as_ref().to_glib_none().0,
                width,
                height,
                preserve_aspect_ratio.into_glib(),
                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 pixbuf by parsing XPM data in memory.
    ///
    /// This data is commonly the result of including an XPM file into a
    /// program's C source.
    /// ## `data`
    /// Pointer to inline XPM data.
    ///
    /// # Returns
    ///
    /// A newly-created pixbuf
    #[doc(alias = "gdk_pixbuf_new_from_xpm_data")]
    #[doc(alias = "new_from_xpm_data")]
    pub fn from_xpm_data(data: &[&str]) -> Pixbuf {
        unsafe { from_glib_full(ffi::gdk_pixbuf_new_from_xpm_data(data.to_glib_none().0)) }
    }

    /// Takes an existing pixbuf and adds an alpha channel to it.
    ///
    /// If the existing pixbuf already had an alpha channel, the channel
    /// values are copied from the original; otherwise, the alpha channel
    /// is initialized to 255 (full opacity).
    ///
    /// If `substitute_color` is `TRUE`, then the color specified by the
    /// (`r`, `g`, `b`) arguments will be assigned zero opacity. That is,
    /// if you pass `(255, 255, 255)` for the substitute color, all white
    /// pixels will become fully transparent.
    ///
    /// If `substitute_color` is `FALSE`, then the (`r`, `g`, `b`) arguments
    /// will be ignored.
    /// ## `substitute_color`
    /// Whether to set a color to zero opacity.
    /// ## `r`
    /// Red value to substitute.
    /// ## `g`
    /// Green value to substitute.
    /// ## `b`
    /// Blue value to substitute.
    ///
    /// # Returns
    ///
    /// A newly-created pixbuf
    #[doc(alias = "gdk_pixbuf_add_alpha")]
    #[must_use]
    pub fn add_alpha(&self, substitute_color: bool, r: u8, g: u8, b: u8) -> Option<Pixbuf> {
        unsafe {
            from_glib_full(ffi::gdk_pixbuf_add_alpha(
                self.to_glib_none().0,
                substitute_color.into_glib(),
                r,
                g,
                b,
            ))
        }
    }

    /// Takes an existing pixbuf and checks for the presence of an
    /// associated "orientation" option.
    ///
    /// The orientation option may be provided by the JPEG loader (which
    /// reads the exif orientation tag) or the TIFF loader (which reads
    /// the TIFF orientation tag, and compensates it for the partial
    /// transforms performed by libtiff).
    ///
    /// If an orientation option/tag is present, the appropriate transform
    /// will be performed so that the pixbuf is oriented correctly.
    ///
    /// # Returns
    ///
    /// A newly-created pixbuf
    #[doc(alias = "gdk_pixbuf_apply_embedded_orientation")]
    #[must_use]
    pub fn apply_embedded_orientation(&self) -> Option<Pixbuf> {
        unsafe {
            from_glib_full(ffi::gdk_pixbuf_apply_embedded_orientation(
                self.to_glib_none().0,
            ))
        }
    }

    /// Creates a transformation of the source image @self by scaling by
    /// @scale_x and @scale_y then translating by @offset_x and @offset_y.
    ///
    /// This gives an image in the coordinates of the destination pixbuf.
    /// The rectangle (@dest_x, @dest_y, @dest_width, @dest_height)
    /// is then alpha blended onto the corresponding rectangle of the
    /// original destination image.
    ///
    /// When the destination rectangle contains parts not in the source
    /// image, the data at the edges of the source image is replicated
    /// to infinity.
    ///
    /// ![](composite.png)
    /// ## `dest`
    /// the #GdkPixbuf into which to render the results
    /// ## `dest_x`
    /// the left coordinate for region to render
    /// ## `dest_y`
    /// the top coordinate for region to render
    /// ## `dest_width`
    /// the width of the region to render
    /// ## `dest_height`
    /// the height of the region to render
    /// ## `offset_x`
    /// the offset in the X direction (currently rounded to an integer)
    /// ## `offset_y`
    /// the offset in the Y direction (currently rounded to an integer)
    /// ## `scale_x`
    /// the scale factor in the X direction
    /// ## `scale_y`
    /// the scale factor in the Y direction
    /// ## `interp_type`
    /// the interpolation type for the transformation.
    /// ## `overall_alpha`
    /// overall alpha for source image (0..255)
    #[doc(alias = "gdk_pixbuf_composite")]
    pub fn composite(
        &self,
        dest: &Pixbuf,
        dest_x: i32,
        dest_y: i32,
        dest_width: i32,
        dest_height: i32,
        offset_x: f64,
        offset_y: f64,
        scale_x: f64,
        scale_y: f64,
        interp_type: InterpType,
        overall_alpha: i32,
    ) {
        unsafe {
            ffi::gdk_pixbuf_composite(
                self.to_glib_none().0,
                dest.to_glib_none().0,
                dest_x,
                dest_y,
                dest_width,
                dest_height,
                offset_x,
                offset_y,
                scale_x,
                scale_y,
                interp_type.into_glib(),
                overall_alpha,
            );
        }
    }

    /// Creates a transformation of the source image @self by scaling by
    /// @scale_x and @scale_y then translating by @offset_x and @offset_y,
    /// then alpha blends the rectangle (@dest_x ,@dest_y, @dest_width,
    /// @dest_height) of the resulting image with a checkboard of the
    /// colors @color1 and @color2 and renders it onto the destination
    /// image.
    ///
    /// If the source image has no alpha channel, and @overall_alpha is 255, a fast
    /// path is used which omits the alpha blending and just performs the scaling.
    ///
    /// See gdk_pixbuf_composite_color_simple() for a simpler variant of this
    /// function suitable for many tasks.
    /// ## `dest`
    /// the #GdkPixbuf into which to render the results
    /// ## `dest_x`
    /// the left coordinate for region to render
    /// ## `dest_y`
    /// the top coordinate for region to render
    /// ## `dest_width`
    /// the width of the region to render
    /// ## `dest_height`
    /// the height of the region to render
    /// ## `offset_x`
    /// the offset in the X direction (currently rounded to an integer)
    /// ## `offset_y`
    /// the offset in the Y direction (currently rounded to an integer)
    /// ## `scale_x`
    /// the scale factor in the X direction
    /// ## `scale_y`
    /// the scale factor in the Y direction
    /// ## `interp_type`
    /// the interpolation type for the transformation.
    /// ## `overall_alpha`
    /// overall alpha for source image (0..255)
    /// ## `check_x`
    /// the X offset for the checkboard (origin of checkboard is at -@check_x, -@check_y)
    /// ## `check_y`
    /// the Y offset for the checkboard
    /// ## `check_size`
    /// the size of checks in the checkboard (must be a power of two)
    /// ## `color1`
    /// the color of check at upper left
    /// ## `color2`
    /// the color of the other check
    #[doc(alias = "gdk_pixbuf_composite_color")]
    pub fn composite_color(
        &self,
        dest: &Pixbuf,
        dest_x: i32,
        dest_y: i32,
        dest_width: i32,
        dest_height: i32,
        offset_x: f64,
        offset_y: f64,
        scale_x: f64,
        scale_y: f64,
        interp_type: InterpType,
        overall_alpha: i32,
        check_x: i32,
        check_y: i32,
        check_size: i32,
        color1: u32,
        color2: u32,
    ) {
        unsafe {
            ffi::gdk_pixbuf_composite_color(
                self.to_glib_none().0,
                dest.to_glib_none().0,
                dest_x,
                dest_y,
                dest_width,
                dest_height,
                offset_x,
                offset_y,
                scale_x,
                scale_y,
                interp_type.into_glib(),
                overall_alpha,
                check_x,
                check_y,
                check_size,
                color1,
                color2,
            );
        }
    }

    /// Creates a new pixbuf by scaling `src` to `dest_width` x `dest_height`
    /// and alpha blending the result with a checkboard of colors `color1`
    /// and `color2`.
    /// ## `dest_width`
    /// the width of destination image
    /// ## `dest_height`
    /// the height of destination image
    /// ## `interp_type`
    /// the interpolation type for the transformation.
    /// ## `overall_alpha`
    /// overall alpha for source image (0..255)
    /// ## `check_size`
    /// the size of checks in the checkboard (must be a power of two)
    /// ## `color1`
    /// the color of check at upper left
    /// ## `color2`
    /// the color of the other check
    ///
    /// # Returns
    ///
    /// the new pixbuf
    #[doc(alias = "gdk_pixbuf_composite_color_simple")]
    #[must_use]
    pub fn composite_color_simple(
        &self,
        dest_width: i32,
        dest_height: i32,
        interp_type: InterpType,
        overall_alpha: i32,
        check_size: i32,
        color1: u32,
        color2: u32,
    ) -> Option<Pixbuf> {
        unsafe {
            from_glib_full(ffi::gdk_pixbuf_composite_color_simple(
                self.to_glib_none().0,
                dest_width,
                dest_height,
                interp_type.into_glib(),
                overall_alpha,
                check_size,
                color1,
                color2,
            ))
        }
    }

    #[doc(alias = "gdk_pixbuf_copy")]
    #[must_use]
    pub fn copy(&self) -> Option<Pixbuf> {
        unsafe { from_glib_full(ffi::gdk_pixbuf_copy(self.to_glib_none().0)) }
    }

    /// Copies a rectangular area from `src_pixbuf` to `dest_pixbuf`.
    ///
    /// Conversion of pixbuf formats is done automatically.
    ///
    /// If the source rectangle overlaps the destination rectangle on the
    /// same pixbuf, it will be overwritten during the copy operation.
    /// Therefore, you can not use this function to scroll a pixbuf.
    /// ## `src_x`
    /// Source X coordinate within @self.
    /// ## `src_y`
    /// Source Y coordinate within @self.
    /// ## `width`
    /// Width of the area to copy.
    /// ## `height`
    /// Height of the area to copy.
    /// ## `dest_pixbuf`
    /// Destination pixbuf.
    /// ## `dest_x`
    /// X coordinate within @dest_pixbuf.
    /// ## `dest_y`
    /// Y coordinate within @dest_pixbuf.
    #[doc(alias = "gdk_pixbuf_copy_area")]
    pub fn copy_area(
        &self,
        src_x: i32,
        src_y: i32,
        width: i32,
        height: i32,
        dest_pixbuf: &Pixbuf,
        dest_x: i32,
        dest_y: i32,
    ) {
        unsafe {
            ffi::gdk_pixbuf_copy_area(
                self.to_glib_none().0,
                src_x,
                src_y,
                width,
                height,
                dest_pixbuf.to_glib_none().0,
                dest_x,
                dest_y,
            );
        }
    }

    /// Copies the key/value pair options attached to a [`Pixbuf`][crate::Pixbuf] to another
    /// [`Pixbuf`][crate::Pixbuf].
    ///
    /// This is useful to keep original metadata after having manipulated
    /// a file. However be careful to remove metadata which you've already
    /// applied, such as the "orientation" option after rotating the image.
    /// ## `dest_pixbuf`
    /// the destination pixbuf
    ///
    /// # Returns
    ///
    /// `TRUE` on success.
    #[cfg(any(feature = "v2_36", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_36")))]
    #[doc(alias = "gdk_pixbuf_copy_options")]
    pub fn copy_options(&self, dest_pixbuf: &Pixbuf) -> bool {
        unsafe {
            from_glib(ffi::gdk_pixbuf_copy_options(
                self.to_glib_none().0,
                dest_pixbuf.to_glib_none().0,
            ))
        }
    }

    /// Clears a pixbuf to the given RGBA value, converting the RGBA value into
    /// the pixbuf's pixel format.
    ///
    /// The alpha component will be ignored if the pixbuf doesn't have an alpha
    /// channel.
    /// ## `pixel`
    /// RGBA pixel to used to clear (`0xffffffff` is opaque white,
    ///   `0x00000000` transparent black)
    #[doc(alias = "gdk_pixbuf_fill")]
    pub fn fill(&self, pixel: u32) {
        unsafe {
            ffi::gdk_pixbuf_fill(self.to_glib_none().0, pixel);
        }
    }

    /// Flips a pixbuf horizontally or vertically and returns the
    /// result in a new pixbuf.
    /// ## `horizontal`
    /// `TRUE` to flip horizontally, `FALSE` to flip vertically
    ///
    /// # Returns
    ///
    /// the new pixbuf
    #[doc(alias = "gdk_pixbuf_flip")]
    #[must_use]
    pub fn flip(&self, horizontal: bool) -> Option<Pixbuf> {
        unsafe {
            from_glib_full(ffi::gdk_pixbuf_flip(
                self.to_glib_none().0,
                horizontal.into_glib(),
            ))
        }
    }

    /// Queries the number of bits per color sample in a pixbuf.
    ///
    /// # Returns
    ///
    /// Number of bits per color sample.
    #[doc(alias = "gdk_pixbuf_get_bits_per_sample")]
    #[doc(alias = "get_bits_per_sample")]
    pub fn bits_per_sample(&self) -> i32 {
        unsafe { ffi::gdk_pixbuf_get_bits_per_sample(self.to_glib_none().0) }
    }

    /// Returns the length of the pixel data, in bytes.
    ///
    /// # Returns
    ///
    /// The length of the pixel data.
    #[doc(alias = "gdk_pixbuf_get_byte_length")]
    #[doc(alias = "get_byte_length")]
    pub fn byte_length(&self) -> usize {
        unsafe { ffi::gdk_pixbuf_get_byte_length(self.to_glib_none().0) }
    }

    /// Queries the color space of a pixbuf.
    ///
    /// # Returns
    ///
    /// Color space.
    #[doc(alias = "gdk_pixbuf_get_colorspace")]
    #[doc(alias = "get_colorspace")]
    pub fn colorspace(&self) -> Colorspace {
        unsafe { from_glib(ffi::gdk_pixbuf_get_colorspace(self.to_glib_none().0)) }
    }

    /// Queries whether a pixbuf has an alpha channel (opacity information).
    ///
    /// # Returns
    ///
    /// `TRUE` if it has an alpha channel, `FALSE` otherwise.
    #[doc(alias = "gdk_pixbuf_get_has_alpha")]
    #[doc(alias = "get_has_alpha")]
    pub fn has_alpha(&self) -> bool {
        unsafe { from_glib(ffi::gdk_pixbuf_get_has_alpha(self.to_glib_none().0)) }
    }

    /// Queries the height of a pixbuf.
    ///
    /// # Returns
    ///
    /// Height in pixels.
    #[doc(alias = "gdk_pixbuf_get_height")]
    #[doc(alias = "get_height")]
    pub fn height(&self) -> i32 {
        unsafe { ffi::gdk_pixbuf_get_height(self.to_glib_none().0) }
    }

    /// Queries the number of channels of a pixbuf.
    ///
    /// # Returns
    ///
    /// Number of channels.
    #[doc(alias = "gdk_pixbuf_get_n_channels")]
    #[doc(alias = "get_n_channels")]
    pub fn n_channels(&self) -> i32 {
        unsafe { ffi::gdk_pixbuf_get_n_channels(self.to_glib_none().0) }
    }

    /// Looks up @key in the list of options that may have been attached to the
    /// @self when it was loaded, or that may have been attached by another
    /// function using gdk_pixbuf_set_option().
    ///
    /// For instance, the ANI loader provides "Title" and "Artist" options.
    /// The ICO, XBM, and XPM loaders provide "x_hot" and "y_hot" hot-spot
    /// options for cursor definitions. The PNG loader provides the tEXt ancillary
    /// chunk key/value pairs as options. Since 2.12, the TIFF and JPEG loaders
    /// return an "orientation" option string that corresponds to the embedded
    /// TIFF/Exif orientation tag (if present). Since 2.32, the TIFF loader sets
    /// the "multipage" option string to "yes" when a multi-page TIFF is loaded.
    /// Since 2.32 the JPEG and PNG loaders set "x-dpi" and "y-dpi" if the file
    /// contains image density information in dots per inch.
    /// Since 2.36.6, the JPEG loader sets the "comment" option with the comment
    /// EXIF tag.
    /// ## `key`
    /// a nul-terminated string.
    ///
    /// # Returns
    ///
    /// the value associated with `key`
    #[doc(alias = "gdk_pixbuf_get_option")]
    #[doc(alias = "get_option")]
    pub fn option(&self, key: &str) -> Option<glib::GString> {
        unsafe {
            from_glib_none(ffi::gdk_pixbuf_get_option(
                self.to_glib_none().0,
                key.to_glib_none().0,
            ))
        }
    }

    //#[doc(alias = "gdk_pixbuf_get_options")]
    //#[doc(alias = "get_options")]
    //pub fn options(&self) -> /*Unknown conversion*//*Unimplemented*/HashTable TypeId { ns_id: 0, id: 28 }/TypeId { ns_id: 0, id: 28 } {
    //    unsafe { TODO: call ffi:gdk_pixbuf_get_options() }
    //}

    /// Queries the rowstride of a pixbuf, which is the number of bytes between
    /// the start of a row and the start of the next row.
    ///
    /// # Returns
    ///
    /// Distance between row starts.
    #[doc(alias = "gdk_pixbuf_get_rowstride")]
    #[doc(alias = "get_rowstride")]
    pub fn rowstride(&self) -> i32 {
        unsafe { ffi::gdk_pixbuf_get_rowstride(self.to_glib_none().0) }
    }

    /// Queries the width of a pixbuf.
    ///
    /// # Returns
    ///
    /// Width in pixels.
    #[doc(alias = "gdk_pixbuf_get_width")]
    #[doc(alias = "get_width")]
    pub fn width(&self) -> i32 {
        unsafe { ffi::gdk_pixbuf_get_width(self.to_glib_none().0) }
    }

    /// Creates a new pixbuf which represents a sub-region of `src_pixbuf`.
    ///
    /// The new pixbuf shares its pixels with the original pixbuf, so
    /// writing to one affects both.  The new pixbuf holds a reference to
    /// `src_pixbuf`, so `src_pixbuf` will not be finalized until the new
    /// pixbuf is finalized.
    ///
    /// Note that if `src_pixbuf` is read-only, this function will force it
    /// to be mutable.
    /// ## `src_x`
    /// X coord in @self
    /// ## `src_y`
    /// Y coord in @self
    /// ## `width`
    /// width of region in @self
    /// ## `height`
    /// height of region in @self
    ///
    /// # Returns
    ///
    /// a new pixbuf
    #[doc(alias = "gdk_pixbuf_new_subpixbuf")]
    #[must_use]
    pub fn new_subpixbuf(&self, src_x: i32, src_y: i32, width: i32, height: i32) -> Option<Pixbuf> {
        unsafe {
            from_glib_full(ffi::gdk_pixbuf_new_subpixbuf(
                self.to_glib_none().0,
                src_x,
                src_y,
                width,
                height,
            ))
        }
    }

    /// Provides a #GBytes buffer containing the raw pixel data; the data
    /// must not be modified.
    ///
    /// This function allows skipping the implicit copy that must be made
    /// if gdk_pixbuf_get_pixels() is called on a read-only pixbuf.
    ///
    /// # Returns
    ///
    /// A new reference to a read-only copy of
    ///   the pixel data.  Note that for mutable pixbufs, this function will
    ///   incur a one-time copy of the pixel data for conversion into the
    ///   returned #GBytes.
    #[doc(alias = "gdk_pixbuf_read_pixel_bytes")]
    pub fn read_pixel_bytes(&self) -> Option<glib::Bytes> {
        unsafe { from_glib_full(ffi::gdk_pixbuf_read_pixel_bytes(self.to_glib_none().0)) }
    }

    /// Removes the key/value pair option attached to a [`Pixbuf`][crate::Pixbuf].
    /// ## `key`
    /// a nul-terminated string representing the key to remove.
    ///
    /// # Returns
    ///
    /// `TRUE` if an option was removed, `FALSE` if not.
    #[cfg(any(feature = "v2_36", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_36")))]
    #[doc(alias = "gdk_pixbuf_remove_option")]
    pub fn remove_option(&self, key: &str) -> bool {
        unsafe {
            from_glib(ffi::gdk_pixbuf_remove_option(
                self.to_glib_none().0,
                key.to_glib_none().0,
            ))
        }
    }

    /// Rotates a pixbuf by a multiple of 90 degrees, and returns the
    /// result in a new pixbuf.
    ///
    /// If `angle` is 0, this function will return a copy of `src`.
    /// ## `angle`
    /// the angle to rotate by
    ///
    /// # Returns
    ///
    /// the new pixbuf
    #[doc(alias = "gdk_pixbuf_rotate_simple")]
    #[must_use]
    pub fn rotate_simple(&self, angle: PixbufRotation) -> Option<Pixbuf> {
        unsafe {
            from_glib_full(ffi::gdk_pixbuf_rotate_simple(
                self.to_glib_none().0,
                angle.into_glib(),
            ))
        }
    }

    /// Modifies saturation and optionally pixelates `src`, placing the result in
    /// `dest`.
    ///
    /// The `src` and `dest` pixbufs must have the same image format, size, and
    /// rowstride.
    ///
    /// The `src` and `dest` arguments may be the same pixbuf with no ill effects.
    ///
    /// If `saturation` is 1.0 then saturation is not changed. If it's less than 1.0,
    /// saturation is reduced (the image turns toward grayscale); if greater than
    /// 1.0, saturation is increased (the image gets more vivid colors).
    ///
    /// If `pixelate` is `TRUE`, then pixels are faded in a checkerboard pattern to
    /// create a pixelated image.
    /// ## `dest`
    /// place to write modified version of @self
    /// ## `saturation`
    /// saturation factor
    /// ## `pixelate`
    /// whether to pixelate
    #[doc(alias = "gdk_pixbuf_saturate_and_pixelate")]
    pub fn saturate_and_pixelate(&self, dest: &Pixbuf, saturation: f32, pixelate: bool) {
        unsafe {
            ffi::gdk_pixbuf_saturate_and_pixelate(
                self.to_glib_none().0,
                dest.to_glib_none().0,
                saturation,
                pixelate.into_glib(),
            );
        }
    }

    //#[doc(alias = "gdk_pixbuf_save")]
    //pub fn save(&self, filename: impl AsRef<std::path::Path>, type_: &str, error: Option<&mut glib::Error>, : /*Unknown conversion*//*Unimplemented*/Fundamental: VarArgs) -> bool {
    //    unsafe { TODO: call ffi:gdk_pixbuf_save() }
    //}

    //#[doc(alias = "gdk_pixbuf_save_to_buffer")]
    //pub fn save_to_buffer(&self, type_: &str, error: Option<&mut glib::Error>, : /*Unknown conversion*//*Unimplemented*/Fundamental: VarArgs) -> Option<Vec<u8>> {
    //    unsafe { TODO: call ffi:gdk_pixbuf_save_to_buffer() }
    //}

    //#[doc(alias = "gdk_pixbuf_save_to_callback")]
    //pub fn save_to_callback<P: FnMut(&Vec<u8>, usize, &glib::Error) -> bool>(&self, save_func: P, type_: &str, error: Option<&mut glib::Error>, : /*Unknown conversion*//*Unimplemented*/Fundamental: VarArgs) -> bool {
    //    unsafe { TODO: call ffi:gdk_pixbuf_save_to_callback() }
    //}

    //#[doc(alias = "gdk_pixbuf_save_to_callbackv")]
    //pub fn save_to_callbackv<P: FnMut(&Vec<u8>, usize, &glib::Error) -> bool>(&self, save_func: P, type_: &str, option_keys: &[&str], option_values: &[&str]) -> Result<(), glib::Error> {
    //    unsafe { TODO: call ffi:gdk_pixbuf_save_to_callbackv() }
    //}

    //#[doc(alias = "gdk_pixbuf_save_to_stream")]
    //pub fn save_to_stream(&self, stream: &impl IsA<gio::OutputStream>, type_: &str, cancellable: Option<&impl IsA<gio::Cancellable>>, error: Option<&mut glib::Error>, : /*Unknown conversion*//*Unimplemented*/Fundamental: VarArgs) -> bool {
    //    unsafe { TODO: call ffi:gdk_pixbuf_save_to_stream() }
    //}

    //#[doc(alias = "gdk_pixbuf_save_to_stream_async")]
    //pub fn save_to_stream_async<P: FnOnce(Result<(), glib::Error>) + 'static>(&self, stream: &impl IsA<gio::OutputStream>, type_: &str, cancellable: Option<&impl IsA<gio::Cancellable>>, callback: P, : /*Unknown conversion*//*Unimplemented*/Fundamental: VarArgs) {
    //    unsafe { TODO: call ffi:gdk_pixbuf_save_to_stream_async() }
    //}

    //
    //pub fn save_to_stream_future(&self, stream: &(impl IsA<gio::OutputStream> + Clone + 'static), type_: &str, : /*Unknown conversion*//*Unimplemented*/Fundamental: VarArgs) -> Pin<Box_<dyn std::future::Future<Output = Result<(), glib::Error>> + 'static>> {

    //let stream = stream.clone();
    //let type_ = String::from(type_);
    //Box_::pin(gio::GioFuture::new(self, move |obj, cancellable, send| {
    //    obj.save_to_stream_async(
    //        &stream,
    //        &type_,
    //        Some(cancellable),
    //        ,
    //        move |res| {
    //            send.resolve(res);
    //        },
    //    );
    //}))
    //}

    /// Creates a transformation of the source image @self by scaling by
    /// @scale_x and @scale_y then translating by @offset_x and @offset_y,
    /// then renders the rectangle (@dest_x, @dest_y, @dest_width,
    /// @dest_height) of the resulting image onto the destination image
    /// replacing the previous contents.
    ///
    /// Try to use gdk_pixbuf_scale_simple() first; this function is
    /// the industrial-strength power tool you can fall back to, if
    /// gdk_pixbuf_scale_simple() isn't powerful enough.
    ///
    /// If the source rectangle overlaps the destination rectangle on the
    /// same pixbuf, it will be overwritten during the scaling which
    /// results in rendering artifacts.
    /// ## `dest`
    /// the #GdkPixbuf into which to render the results
    /// ## `dest_x`
    /// the left coordinate for region to render
    /// ## `dest_y`
    /// the top coordinate for region to render
    /// ## `dest_width`
    /// the width of the region to render
    /// ## `dest_height`
    /// the height of the region to render
    /// ## `offset_x`
    /// the offset in the X direction (currently rounded to an integer)
    /// ## `offset_y`
    /// the offset in the Y direction (currently rounded to an integer)
    /// ## `scale_x`
    /// the scale factor in the X direction
    /// ## `scale_y`
    /// the scale factor in the Y direction
    /// ## `interp_type`
    /// the interpolation type for the transformation.
    #[doc(alias = "gdk_pixbuf_scale")]
    pub fn scale(
        &self,
        dest: &Pixbuf,
        dest_x: i32,
        dest_y: i32,
        dest_width: i32,
        dest_height: i32,
        offset_x: f64,
        offset_y: f64,
        scale_x: f64,
        scale_y: f64,
        interp_type: InterpType,
    ) {
        unsafe {
            ffi::gdk_pixbuf_scale(
                self.to_glib_none().0,
                dest.to_glib_none().0,
                dest_x,
                dest_y,
                dest_width,
                dest_height,
                offset_x,
                offset_y,
                scale_x,
                scale_y,
                interp_type.into_glib(),
            );
        }
    }

    /// Create a new pixbuf containing a copy of `src` scaled to
    /// `dest_width` x `dest_height`.
    ///
    /// This function leaves `src` unaffected.
    ///
    /// The `interp_type` should be `GDK_INTERP_NEAREST` if you want maximum
    /// speed (but when scaling down `GDK_INTERP_NEAREST` is usually unusably
    /// ugly). The default `interp_type` should be `GDK_INTERP_BILINEAR` which
    /// offers reasonable quality and speed.
    ///
    /// You can scale a sub-portion of `src` by creating a sub-pixbuf
    /// pointing into `src`; see [`new_subpixbuf()`][Self::new_subpixbuf()].
    ///
    /// If `dest_width` and `dest_height` are equal to the width and height of
    /// `src`, this function will return an unscaled copy of `src`.
    ///
    /// For more complicated scaling/alpha blending see [`scale()`][Self::scale()]
    /// and [`composite()`][Self::composite()].
    /// ## `dest_width`
    /// the width of destination image
    /// ## `dest_height`
    /// the height of destination image
    /// ## `interp_type`
    /// the interpolation type for the transformation.
    ///
    /// # Returns
    ///
    /// the new pixbuf
    #[doc(alias = "gdk_pixbuf_scale_simple")]
    #[must_use]
    pub fn scale_simple(
        &self,
        dest_width: i32,
        dest_height: i32,
        interp_type: InterpType,
    ) -> Option<Pixbuf> {
        unsafe {
            from_glib_full(ffi::gdk_pixbuf_scale_simple(
                self.to_glib_none().0,
                dest_width,
                dest_height,
                interp_type.into_glib(),
            ))
        }
    }

    /// Attaches a key/value pair as an option to a [`Pixbuf`][crate::Pixbuf].
    ///
    /// If `key` already exists in the list of options attached to the `pixbuf`,
    /// the new value is ignored and `FALSE` is returned.
    /// ## `key`
    /// a nul-terminated string.
    /// ## `value`
    /// a nul-terminated string.
    ///
    /// # Returns
    ///
    /// `TRUE` on success
    #[doc(alias = "gdk_pixbuf_set_option")]
    pub fn set_option(&self, key: &str, value: &str) -> bool {
        unsafe {
            from_glib(ffi::gdk_pixbuf_set_option(
                self.to_glib_none().0,
                key.to_glib_none().0,
                value.to_glib_none().0,
            ))
        }
    }

    #[doc(alias = "pixel-bytes")]
    pub fn pixel_bytes(&self) -> Option<glib::Bytes> {
        glib::ObjectExt::property(self, "pixel-bytes")
    }

    /// Calculates the rowstride that an image created with those values would
    /// have.
    ///
    /// This function is useful for front-ends and backends that want to check
    /// image values without needing to create a [`Pixbuf`][crate::Pixbuf].
    /// ## `colorspace`
    /// Color space for image
    /// ## `has_alpha`
    /// Whether the image should have transparency information
    /// ## `bits_per_sample`
    /// Number of bits per color sample
    /// ## `width`
    /// Width of image in pixels, must be > 0
    /// ## `height`
    /// Height of image in pixels, must be > 0
    ///
    /// # Returns
    ///
    /// the rowstride for the given values, or -1 in case of error.
    #[cfg(any(feature = "v2_36_8", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_36_8")))]
    #[doc(alias = "gdk_pixbuf_calculate_rowstride")]
    pub fn calculate_rowstride(
        colorspace: Colorspace,
        has_alpha: bool,
        bits_per_sample: i32,
        width: i32,
        height: i32,
    ) -> i32 {
        unsafe {
            ffi::gdk_pixbuf_calculate_rowstride(
                colorspace.into_glib(),
                has_alpha.into_glib(),
                bits_per_sample,
                width,
                height,
            )
        }
    }

    /// Obtains the available information about the image formats supported
    /// by GdkPixbuf.
    ///
    /// # Returns
    ///
    /// A list of
    ///   support image formats.
    #[doc(alias = "gdk_pixbuf_get_formats")]
    #[doc(alias = "get_formats")]
    pub fn formats() -> Vec<PixbufFormat> {
        unsafe { FromGlibPtrContainer::from_glib_container(ffi::gdk_pixbuf_get_formats()) }
    }

    /// Initalizes the gdk-pixbuf loader modules referenced by the `loaders.cache`
    /// file present inside that directory.
    ///
    /// This is to be used by applications that want to ship certain loaders
    /// in a different location from the system ones.
    ///
    /// This is needed when the OS or runtime ships a minimal number of loaders
    /// so as to reduce the potential attack surface of carefully crafted image
    /// files, especially for uncommon file types. Applications that require
    /// broader image file types coverage, such as image viewers, would be
    /// expected to ship the gdk-pixbuf modules in a separate location, bundled
    /// with the application in a separate directory from the OS or runtime-
    /// provided modules.
    /// ## `path`
    /// Path to directory where the `loaders.cache` is installed
    #[cfg(any(feature = "v2_40", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_40")))]
    #[doc(alias = "gdk_pixbuf_init_modules")]
    pub fn init_modules(path: &str) -> Result<(), glib::Error> {
        unsafe {
            let mut error = ptr::null_mut();
            let is_ok = ffi::gdk_pixbuf_init_modules(path.to_glib_none().0, &mut error);
            assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }
}

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