// 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::ByteOrder;
use crate::Screen;
use crate::VisualType;
use glib::translate::*;
use std::fmt;
use std::mem;

glib::wrapper! {
    /// A [`Visual`][crate::Visual] contains information about
    /// a particular visual.
    #[doc(alias = "GdkVisual")]
    pub struct Visual(Object<ffi::GdkVisual>);

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

impl Visual {
    /// Returns the number of significant bits per red, green and blue value.
    ///
    /// Not all GDK backend provide a meaningful value for this function.
    ///
    /// # Deprecated since 3.22
    ///
    /// Use [`red_pixel_details()`][Self::red_pixel_details()] and its variants to
    ///  learn about the pixel layout of TrueColor and DirectColor visuals
    ///
    /// # Returns
    ///
    /// The number of significant bits per color value for `self`.
    #[cfg_attr(feature = "v3_22", deprecated = "Since 3.22")]
    #[doc(alias = "gdk_visual_get_bits_per_rgb")]
    #[doc(alias = "get_bits_per_rgb")]
    pub fn bits_per_rgb(&self) -> i32 {
        unsafe { ffi::gdk_visual_get_bits_per_rgb(self.to_glib_none().0) }
    }

    /// Obtains values that are needed to calculate blue pixel values in TrueColor
    /// and DirectColor. The “mask” is the significant bits within the pixel.
    /// The “shift” is the number of bits left we must shift a primary for it
    /// to be in position (according to the "mask"). Finally, "precision" refers
    /// to how much precision the pixel value contains for a particular primary.
    ///
    /// # Returns
    ///
    ///
    /// ## `mask`
    /// A pointer to a `guint32` to be filled in, or [`None`]
    ///
    /// ## `shift`
    /// A pointer to a `gint` to be filled in, or [`None`]
    ///
    /// ## `precision`
    /// A pointer to a `gint` to be filled in, or [`None`]
    #[doc(alias = "gdk_visual_get_blue_pixel_details")]
    #[doc(alias = "get_blue_pixel_details")]
    pub fn blue_pixel_details(&self) -> (u32, i32, i32) {
        unsafe {
            let mut mask = mem::MaybeUninit::uninit();
            let mut shift = mem::MaybeUninit::uninit();
            let mut precision = mem::MaybeUninit::uninit();
            ffi::gdk_visual_get_blue_pixel_details(
                self.to_glib_none().0,
                mask.as_mut_ptr(),
                shift.as_mut_ptr(),
                precision.as_mut_ptr(),
            );
            let mask = mask.assume_init();
            let shift = shift.assume_init();
            let precision = precision.assume_init();
            (mask, shift, precision)
        }
    }

    /// Returns the byte order of this visual.
    ///
    /// The information returned by this function is only relevant
    /// when working with XImages, and not all backends return
    /// meaningful information for this.
    ///
    /// # Deprecated since 3.22
    ///
    /// This information is not useful
    ///
    /// # Returns
    ///
    /// A [`ByteOrder`][crate::ByteOrder] stating the byte order of `self`.
    #[cfg_attr(feature = "v3_22", deprecated = "Since 3.22")]
    #[doc(alias = "gdk_visual_get_byte_order")]
    #[doc(alias = "get_byte_order")]
    pub fn byte_order(&self) -> ByteOrder {
        unsafe { from_glib(ffi::gdk_visual_get_byte_order(self.to_glib_none().0)) }
    }

    /// Returns the size of a colormap for this visual.
    ///
    /// You have to use platform-specific APIs to manipulate colormaps.
    ///
    /// # Deprecated since 3.22
    ///
    /// This information is not useful, since GDK does not
    ///  provide APIs to operate on colormaps.
    ///
    /// # Returns
    ///
    /// The size of a colormap that is suitable for `self`.
    #[cfg_attr(feature = "v3_22", deprecated = "Since 3.22")]
    #[doc(alias = "gdk_visual_get_colormap_size")]
    #[doc(alias = "get_colormap_size")]
    pub fn colormap_size(&self) -> i32 {
        unsafe { ffi::gdk_visual_get_colormap_size(self.to_glib_none().0) }
    }

    /// Returns the bit depth of this visual.
    ///
    /// # Returns
    ///
    /// The bit depth of this visual.
    #[doc(alias = "gdk_visual_get_depth")]
    #[doc(alias = "get_depth")]
    pub fn depth(&self) -> i32 {
        unsafe { ffi::gdk_visual_get_depth(self.to_glib_none().0) }
    }

    /// Obtains values that are needed to calculate green pixel values in TrueColor
    /// and DirectColor. The “mask” is the significant bits within the pixel.
    /// The “shift” is the number of bits left we must shift a primary for it
    /// to be in position (according to the "mask"). Finally, "precision" refers
    /// to how much precision the pixel value contains for a particular primary.
    ///
    /// # Returns
    ///
    ///
    /// ## `mask`
    /// A pointer to a `guint32` to be filled in, or [`None`]
    ///
    /// ## `shift`
    /// A pointer to a `gint` to be filled in, or [`None`]
    ///
    /// ## `precision`
    /// A pointer to a `gint` to be filled in, or [`None`]
    #[doc(alias = "gdk_visual_get_green_pixel_details")]
    #[doc(alias = "get_green_pixel_details")]
    pub fn green_pixel_details(&self) -> (u32, i32, i32) {
        unsafe {
            let mut mask = mem::MaybeUninit::uninit();
            let mut shift = mem::MaybeUninit::uninit();
            let mut precision = mem::MaybeUninit::uninit();
            ffi::gdk_visual_get_green_pixel_details(
                self.to_glib_none().0,
                mask.as_mut_ptr(),
                shift.as_mut_ptr(),
                precision.as_mut_ptr(),
            );
            let mask = mask.assume_init();
            let shift = shift.assume_init();
            let precision = precision.assume_init();
            (mask, shift, precision)
        }
    }

    /// Obtains values that are needed to calculate red pixel values in TrueColor
    /// and DirectColor. The “mask” is the significant bits within the pixel.
    /// The “shift” is the number of bits left we must shift a primary for it
    /// to be in position (according to the "mask"). Finally, "precision" refers
    /// to how much precision the pixel value contains for a particular primary.
    ///
    /// # Returns
    ///
    ///
    /// ## `mask`
    /// A pointer to a `guint32` to be filled in, or [`None`]
    ///
    /// ## `shift`
    /// A pointer to a `gint` to be filled in, or [`None`]
    ///
    /// ## `precision`
    /// A pointer to a `gint` to be filled in, or [`None`]
    #[doc(alias = "gdk_visual_get_red_pixel_details")]
    #[doc(alias = "get_red_pixel_details")]
    pub fn red_pixel_details(&self) -> (u32, i32, i32) {
        unsafe {
            let mut mask = mem::MaybeUninit::uninit();
            let mut shift = mem::MaybeUninit::uninit();
            let mut precision = mem::MaybeUninit::uninit();
            ffi::gdk_visual_get_red_pixel_details(
                self.to_glib_none().0,
                mask.as_mut_ptr(),
                shift.as_mut_ptr(),
                precision.as_mut_ptr(),
            );
            let mask = mask.assume_init();
            let shift = shift.assume_init();
            let precision = precision.assume_init();
            (mask, shift, precision)
        }
    }

    /// Gets the screen to which this visual belongs
    ///
    /// # Returns
    ///
    /// the screen to which this visual belongs.
    #[doc(alias = "gdk_visual_get_screen")]
    #[doc(alias = "get_screen")]
    pub fn screen(&self) -> Screen {
        unsafe { from_glib_none(ffi::gdk_visual_get_screen(self.to_glib_none().0)) }
    }

    /// Returns the type of visual this is (PseudoColor, TrueColor, etc).
    ///
    /// # Returns
    ///
    /// A [`VisualType`][crate::VisualType] stating the type of `self`.
    #[doc(alias = "gdk_visual_get_visual_type")]
    #[doc(alias = "get_visual_type")]
    pub fn visual_type(&self) -> VisualType {
        unsafe { from_glib(ffi::gdk_visual_get_visual_type(self.to_glib_none().0)) }
    }

    /// Get the visual with the most available colors for the default
    /// GDK screen. The return value should not be freed.
    ///
    /// # Deprecated since 3.22
    ///
    /// Visual selection should be done using
    ///  [`Screen::system_visual()`][crate::Screen::system_visual()] and [`Screen::rgba_visual()`][crate::Screen::rgba_visual()]
    ///
    /// # Returns
    ///
    /// best visual
    #[cfg_attr(feature = "v3_22", deprecated = "Since 3.22")]
    #[doc(alias = "gdk_visual_get_best")]
    #[doc(alias = "get_best")]
    pub fn best() -> Visual {
        assert_initialized_main_thread!();
        unsafe { from_glib_none(ffi::gdk_visual_get_best()) }
    }

    /// Get the best available depth for the default GDK screen. “Best”
    /// means “largest,” i.e. 32 preferred over 24 preferred over 8 bits
    /// per pixel.
    ///
    /// # Deprecated since 3.22
    ///
    /// Visual selection should be done using
    ///  [`Screen::system_visual()`][crate::Screen::system_visual()] and [`Screen::rgba_visual()`][crate::Screen::rgba_visual()]
    ///
    /// # Returns
    ///
    /// best available depth
    #[cfg_attr(feature = "v3_22", deprecated = "Since 3.22")]
    #[doc(alias = "gdk_visual_get_best_depth")]
    #[doc(alias = "get_best_depth")]
    pub fn best_depth() -> i32 {
        assert_initialized_main_thread!();
        unsafe { ffi::gdk_visual_get_best_depth() }
    }

    /// Return the best available visual type for the default GDK screen.
    ///
    /// # Deprecated since 3.22
    ///
    /// Visual selection should be done using
    ///  [`Screen::system_visual()`][crate::Screen::system_visual()] and [`Screen::rgba_visual()`][crate::Screen::rgba_visual()]
    ///
    /// # Returns
    ///
    /// best visual type
    #[cfg_attr(feature = "v3_22", deprecated = "Since 3.22")]
    #[doc(alias = "gdk_visual_get_best_type")]
    #[doc(alias = "get_best_type")]
    pub fn best_type() -> VisualType {
        assert_initialized_main_thread!();
        unsafe { from_glib(ffi::gdk_visual_get_best_type()) }
    }

    /// Combines [`best_with_depth()`][Self::best_with_depth()] and
    /// [`best_with_type()`][Self::best_with_type()].
    ///
    /// # Deprecated since 3.22
    ///
    /// Visual selection should be done using
    ///  [`Screen::system_visual()`][crate::Screen::system_visual()] and [`Screen::rgba_visual()`][crate::Screen::rgba_visual()]
    /// ## `depth`
    /// a bit depth
    /// ## `visual_type`
    /// a visual type
    ///
    /// # Returns
    ///
    /// best visual with both `depth`
    ///  and `visual_type`, or [`None`] if none
    #[cfg_attr(feature = "v3_22", deprecated = "Since 3.22")]
    #[doc(alias = "gdk_visual_get_best_with_both")]
    #[doc(alias = "get_best_with_both")]
    pub fn best_with_both(depth: i32, visual_type: VisualType) -> Option<Visual> {
        assert_initialized_main_thread!();
        unsafe {
            from_glib_none(ffi::gdk_visual_get_best_with_both(
                depth,
                visual_type.into_glib(),
            ))
        }
    }

    /// Get the best visual with depth `depth` for the default GDK screen.
    /// Color visuals and visuals with mutable colormaps are preferred
    /// over grayscale or fixed-colormap visuals. The return value should
    /// not be freed. [`None`] may be returned if no visual supports `depth`.
    ///
    /// # Deprecated since 3.22
    ///
    /// Visual selection should be done using
    ///  [`Screen::system_visual()`][crate::Screen::system_visual()] and [`Screen::rgba_visual()`][crate::Screen::rgba_visual()]
    /// ## `depth`
    /// a bit depth
    ///
    /// # Returns
    ///
    /// best visual for the given depth
    #[cfg_attr(feature = "v3_22", deprecated = "Since 3.22")]
    #[doc(alias = "gdk_visual_get_best_with_depth")]
    #[doc(alias = "get_best_with_depth")]
    pub fn best_with_depth(depth: i32) -> Option<Visual> {
        assert_initialized_main_thread!();
        unsafe { from_glib_none(ffi::gdk_visual_get_best_with_depth(depth)) }
    }

    /// Get the best visual of the given `visual_type` for the default GDK screen.
    /// Visuals with higher color depths are considered better. The return value
    /// should not be freed. [`None`] may be returned if no visual has type
    /// `visual_type`.
    ///
    /// # Deprecated since 3.22
    ///
    /// Visual selection should be done using
    ///  [`Screen::system_visual()`][crate::Screen::system_visual()] and [`Screen::rgba_visual()`][crate::Screen::rgba_visual()]
    /// ## `visual_type`
    /// a visual type
    ///
    /// # Returns
    ///
    /// best visual of the given type
    #[cfg_attr(feature = "v3_22", deprecated = "Since 3.22")]
    #[doc(alias = "gdk_visual_get_best_with_type")]
    #[doc(alias = "get_best_with_type")]
    pub fn best_with_type(visual_type: VisualType) -> Option<Visual> {
        assert_initialized_main_thread!();
        unsafe { from_glib_none(ffi::gdk_visual_get_best_with_type(visual_type.into_glib())) }
    }

    /// Get the system’s default visual for the default GDK screen.
    /// This is the visual for the root window of the display.
    /// The return value should not be freed.
    ///
    /// # Deprecated since 3.22
    ///
    /// Use gdk_screen_get_system_visual (gdk_screen_get_default ()).
    ///
    /// # Returns
    ///
    /// system visual
    #[cfg_attr(feature = "v3_22", deprecated = "Since 3.22")]
    #[doc(alias = "gdk_visual_get_system")]
    #[doc(alias = "get_system")]
    pub fn system() -> Visual {
        assert_initialized_main_thread!();
        unsafe { from_glib_none(ffi::gdk_visual_get_system()) }
    }
}

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