gdk4/auto/

texture_downloader.rs

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

#[cfg(feature = "v4_16")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_16")))]
use crate::ColorState;
use crate::{ffi, MemoryFormat, Texture};
use glib::{prelude::*, translate::*};

glib::wrapper! {
    /// Used to download the contents of a [`Texture`][crate::Texture].
    ///
    /// It is intended to be created as a short-term object for a single download,
    /// but can be used for multiple downloads of different textures or with different
    /// settings.
    ///
    /// [`TextureDownloader`][crate::TextureDownloader] can be used to convert data between different formats.
    /// Create a [`Texture`][crate::Texture] for the existing format and then download it in a
    /// different format.
    #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct TextureDownloader(Boxed<ffi::GdkTextureDownloader>);

    match fn {
        copy => |ptr| ffi::gdk_texture_downloader_copy(ptr),
        free => |ptr| ffi::gdk_texture_downloader_free(ptr),
        type_ => || ffi::gdk_texture_downloader_get_type(),
    }
}

impl TextureDownloader {
    /// Creates a new texture downloader for @texture.
    ///
    /// By default, the downloader will convert the data to
    /// the default memory format, and to the sRGB color state.
    /// ## `texture`
    /// texture to download
    ///
    /// # Returns
    ///
    /// A new texture downloader
    #[doc(alias = "gdk_texture_downloader_new")]
    pub fn new(texture: &impl IsA<Texture>) -> TextureDownloader {
        skip_assert_initialized!();
        unsafe {
            from_glib_full(ffi::gdk_texture_downloader_new(
                texture.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Downloads the given texture pixels into a `GBytes`. The rowstride will
    /// be stored in the stride value.
    ///
    /// This function will abort if it tries to download a large texture and
    /// fails to allocate memory. If you think that may happen, you should handle
    /// memory allocation yourself and use `Gdk::TextureDownloader::download_into()`
    /// once allocation succeeded.
    ///
    /// # Returns
    ///
    /// The downloaded pixels
    ///
    /// ## `out_stride`
    /// The stride of the resulting data in bytes
    #[doc(alias = "gdk_texture_downloader_download_bytes")]
    pub fn download_bytes(&self) -> (glib::Bytes, usize) {
        unsafe {
            let mut out_stride = std::mem::MaybeUninit::uninit();
            let ret = from_glib_full(ffi::gdk_texture_downloader_download_bytes(
                self.to_glib_none().0,
                out_stride.as_mut_ptr(),
            ));
            (ret, out_stride.assume_init())
        }
    }

    //#[doc(alias = "gdk_texture_downloader_download_into")]
    //pub fn download_into(&self, data: &[u8], stride: usize) {
    //    unsafe { TODO: call ffi:gdk_texture_downloader_download_into() }
    //}

    /// Gets the color state that the data will be downloaded in.
    ///
    /// # Returns
    ///
    /// The color state of the download
    #[cfg(feature = "v4_16")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_16")))]
    #[doc(alias = "gdk_texture_downloader_get_color_state")]
    #[doc(alias = "get_color_state")]
    pub fn color_state(&self) -> ColorState {
        unsafe {
            from_glib_full(ffi::gdk_texture_downloader_get_color_state(
                self.to_glib_none().0,
            ))
        }
    }

    /// Gets the format that the data will be downloaded in.
    ///
    /// # Returns
    ///
    /// The format of the download
    #[doc(alias = "gdk_texture_downloader_get_format")]
    #[doc(alias = "get_format")]
    pub fn format(&self) -> MemoryFormat {
        unsafe {
            from_glib(ffi::gdk_texture_downloader_get_format(
                self.to_glib_none().0,
            ))
        }
    }

    /// Gets the texture that the downloader will download.
    ///
    /// # Returns
    ///
    /// The texture to download
    #[doc(alias = "gdk_texture_downloader_get_texture")]
    #[doc(alias = "get_texture")]
    pub fn texture(&self) -> Texture {
        unsafe {
            from_glib_none(ffi::gdk_texture_downloader_get_texture(
                self.to_glib_none().0,
            ))
        }
    }

    /// Sets the color state the downloader will convert the data to.
    ///
    /// By default, the sRGB colorstate returned by `get_srgb()`
    /// is used.
    /// ## `color_state`
    /// the color state to use
    #[cfg(feature = "v4_16")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_16")))]
    #[doc(alias = "gdk_texture_downloader_set_color_state")]
    pub fn set_color_state(&mut self, color_state: &ColorState) {
        unsafe {
            ffi::gdk_texture_downloader_set_color_state(
                self.to_glib_none_mut().0,
                color_state.to_glib_none().0,
            );
        }
    }

    /// Sets the format the downloader will download.
    ///
    /// By default, GDK_MEMORY_DEFAULT is set.
    /// ## `format`
    /// the format to use
    #[doc(alias = "gdk_texture_downloader_set_format")]
    pub fn set_format(&mut self, format: MemoryFormat) {
        unsafe {
            ffi::gdk_texture_downloader_set_format(self.to_glib_none_mut().0, format.into_glib());
        }
    }

    /// Changes the texture the downloader will download.
    /// ## `texture`
    /// the new texture to download
    #[doc(alias = "gdk_texture_downloader_set_texture")]
    pub fn set_texture(&mut self, texture: &impl IsA<Texture>) {
        unsafe {
            ffi::gdk_texture_downloader_set_texture(
                self.to_glib_none_mut().0,
                texture.as_ref().to_glib_none().0,
            );
        }
    }
}