// 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! {
    /// This is the main structure in the gdk-pixbuf library. It is
    /// used to represent images. It contains information about the
    /// 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).
    ///
    /// # 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. 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 [`Pixbuf`][crate::Pixbuf] with a reference count of 1, or
    /// [`None`] if not enough memory could be allocated for the image 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 [`Pixbuf`][crate::Pixbuf] out of in-memory readonly image data.
    /// Currently only RGB images with 8 bits per sample are supported.
    /// This is the [`glib::Bytes`][crate::glib::Bytes] variant of `gdk_pixbuf_new_from_data()`.
    /// ## `data`
    /// Image data in 8-bit/sample packed format inside a [`glib::Bytes`][crate::glib::Bytes]
    /// ## `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`][crate::Pixbuf] structure with a reference count of 1.
    #[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 [`None`] is returned, then
    /// `error` will be set.
    /// ## `resource_path`
    /// the path of the resource file
    ///
    /// # 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_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 [`None`] 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, 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_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 [`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_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<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 [`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 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 [`gio::InputStream`][crate::gio::InputStream] 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 [`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_new_from_stream_at_scale")]
    #[doc(alias = "new_from_stream_at_scale")]
    pub fn from_stream_at_scale<P: IsA<gio::InputStream>, Q: IsA<gio::Cancellable>>(
        stream: &P,
        width: i32,
        height: i32,
        preserve_aspect_ratio: bool,
        cancellable: Option<&Q>,
    ) -> 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 with a reference count of 1.
    #[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 (`r`, `g`, `b`) will be
    /// assigned zero opacity. That is, if you pass (255, 255, 255) for the
    /// substitute color, all white pixels will become fully transparent.
    /// ## `substitute_color`
    /// Whether to set a color to zero opacity. If this
    /// is [`false`], then the (`r`, `g`, `b`) arguments will be ignored.
    /// ## `r`
    /// Red value to substitute.
    /// ## `g`
    /// Green value to substitute.
    /// ## `b`
    /// Blue value to substitute.
    ///
    /// # Returns
    ///
    /// A newly-created pixbuf with a reference count of 1.
    #[doc(alias = "gdk_pixbuf_add_alpha")]
    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, which 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, [`None`] if
    /// not enough memory could be allocated for it, or a reference to the
    /// input pixbuf (with an increased reference count).
    #[doc(alias = "gdk_pixbuf_apply_embedded_orientation")]
    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 [`Pixbuf`][crate::Pixbuf] 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 [`composite_color_simple()`][Self::composite_color_simple()] for a simpler variant of this
    /// function suitable for many tasks.
    /// ## `dest`
    /// the [`Pixbuf`][crate::Pixbuf] 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`][crate::Pixbuf] by scaling `self` 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`][crate::Pixbuf], or [`None`] if not enough memory could be
    /// allocated for it.
    #[doc(alias = "gdk_pixbuf_composite_color_simple")]
    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,
            ))
        }
    }

    /// Creates a new [`Pixbuf`][crate::Pixbuf] with a copy of the information in the specified
    /// `self`. Note that this does not copy the options set on the original [`Pixbuf`][crate::Pixbuf],
    /// use [`copy_options()`][Self::copy_options()] for this.
    ///
    /// # Returns
    ///
    /// A newly-created pixbuf with a reference count of 1, or [`None`] if
    /// not enough memory could be allocated.
    #[doc(alias = "gdk_pixbuf_copy")]
    pub fn copy(&self) -> Option<Pixbuf> {
        unsafe { from_glib_full(ffi::gdk_pixbuf_copy(self.to_glib_none().0)) }
    }

    /// Copies a rectangular area from `self` 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,
            );
        }
    }

    /// Copy the key/value pair options attached to a [`Pixbuf`][crate::Pixbuf] to another.
    /// 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 [`Pixbuf`][crate::Pixbuf] to copy options to
    ///
    /// # 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 will be ignored if the pixbuf
    /// doesn't have an alpha channel.
    /// ## `pixel`
    /// RGBA pixel to clear to
    ///  (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`][crate::Pixbuf], or [`None`]
    /// if not enough memory could be allocated for it.
    #[doc(alias = "gdk_pixbuf_flip")]
    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 [`set_option()`][Self::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`. This is a nul-terminated
    /// string that should not be freed or [`None`] if `key` was not found.
    #[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 `self`.
    /// The new pixbuf shares its pixels with the original pixbuf, so
    /// writing to one affects both. The new pixbuf holds a reference to
    /// `self`, so `self` will not be finalized until the new
    /// pixbuf is finalized.
    ///
    /// Note that if `self` 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")]
    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 [`glib::Bytes`][crate::glib::Bytes] buffer containing the raw pixel data; the data
    /// must not be modified. This function allows skipping the implicit
    /// copy that must be made if [`pixels()`][Self::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 [`glib::Bytes`][crate::glib::Bytes].
    #[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)) }
    }

    /// Remove 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, a copy of `self` is returned, avoiding any rotation.
    /// ## `angle`
    /// the angle to rotate by
    ///
    /// # Returns
    ///
    /// the new [`Pixbuf`][crate::Pixbuf], or [`None`]
    /// if not enough memory could be allocated for it.
    #[doc(alias = "gdk_pixbuf_rotate_simple")]
    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 `self`, placing the result in
    /// `dest`. `self` and `dest` 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. `self` and `dest` must have the same image format, size, and
    /// rowstride.
    /// ## `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<P: AsRef<std::path::Path>>(&self, filename: P, 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<P: IsA<gio::OutputStream>, Q: IsA<gio::Cancellable>>(&self, stream: &P, type_: &str, cancellable: Option<&Q>, 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: IsA<gio::OutputStream>, Q: IsA<gio::Cancellable>, R: FnOnce(Result<(), glib::Error>) + Send + 'static>(&self, stream: &P, type_: &str, cancellable: Option<&Q>, callback: R, : /*Unknown conversion*//*Unimplemented*/Fundamental: VarArgs) {
    //    unsafe { TODO: call ffi:gdk_pixbuf_save_to_stream_async() }
    //}

    //
    //pub fn save_to_stream_async_future<P: IsA<gio::OutputStream> + Clone + 'static>(&self, stream: &P, 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 [`scale_simple()`][Self::scale_simple()] first, this function is
    /// the industrial-strength power tool you can fall back to if
    /// [`scale_simple()`][Self::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 [`Pixbuf`][crate::Pixbuf] 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`][crate::Pixbuf] containing a copy of `self` scaled to
    /// `dest_width` x `dest_height`. Leaves `self` unaffected. `interp_type`
    /// should be [`InterpType::Nearest`][crate::InterpType::Nearest] if you want maximum speed (but when
    /// scaling down [`InterpType::Nearest`][crate::InterpType::Nearest] is usually unusably ugly). The
    /// default `interp_type` should be [`InterpType::Bilinear`][crate::InterpType::Bilinear] which offers
    /// reasonable quality and speed.
    ///
    /// You can scale a sub-portion of `self` by creating a sub-pixbuf
    /// pointing into `self`; see [`new_subpixbuf()`][Self::new_subpixbuf()].
    ///
    /// If `dest_width` and `dest_height` are equal to the `self` width and height, a
    /// copy of `self` is returned, avoiding any scaling.
    ///
    /// 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`][crate::Pixbuf], or [`None`] if not enough memory could be
    /// allocated for it.
    #[doc(alias = "gdk_pixbuf_scale_simple")]
    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 `self`, 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> {
        unsafe {
            let mut value = glib::Value::from_type(<glib::Bytes as StaticType>::static_type());
            glib::gobject_ffi::g_object_get_property(
                self.as_ptr() as *mut glib::gobject_ffi::GObject,
                b"pixel-bytes\0".as_ptr() as *const _,
                value.to_glib_none_mut().0,
            );
            value
                .get()
                .expect("Return Value for property `pixel-bytes` getter")
        }
    }

    /// Calculates the rowstride that an image created with those values would
    /// have. This is useful for front-ends and backends that want to sanity
    /// check image values without needing to create them.
    /// ## `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
    /// `GdkPixbufFormats` describing the supported image formats. The list should
    /// be freed when it is no longer needed, but the structures themselves are
    /// owned by [`Pixbuf`][crate::Pixbuf] and should not be freed.
    #[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 _ = ffi::gdk_pixbuf_init_modules(path.to_glib_none().0, &mut error);
            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")
    }
}