gdk4_win32/auto/

d3d12_texture_builder.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

use crate::ffi;
use glib::{
    prelude::*,
    signal::{connect_raw, SignalHandlerId},
    translate::*,
};
use std::boxed::Box as Box_;

glib::wrapper! {
    /// [`D3D12TextureBuilder`][crate::D3D12TextureBuilder] is a builder used to construct [`gdk::Texture`][crate::gdk::Texture]
    /// objects from [ID3D12Resources](https://learn.microsoft.com/en-us/windows/win32/api/d3d12/nn-d3d12-id3d12resource).
    ///
    /// The operation of [`D3D12TextureBuilder`][crate::D3D12TextureBuilder] is quite simple: Create a texture builder,
    /// set all the necessary properties, and then call `Gdk::D3d12TextureBuilder::build()`
    /// to create the new texture.
    ///
    /// Not all `D3D12Resources` can be used. You have to use a texture resource for a [`gdk::Texture`][crate::gdk::Texture].
    /// GDK will attempt to detect invalid resources and fail to create the texture in that case.
    ///
    /// [`D3D12TextureBuilder`][crate::D3D12TextureBuilder] can be used for quick one-shot construction of
    /// textures as well as kept around and reused to construct multiple textures.
    ///
    /// ## Properties
    ///
    ///
    /// #### `color-state`
    ///  The color state of the texture.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `fence`
    ///  The optional `ID3D12Fence` to wait on before using the resource.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `fence-wait`
    ///  The value the fence should wait on
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `premultiplied`
    ///  Whether the alpha channel is premultiplied into the others.
    ///
    /// Only relevant if the format has alpha.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `resource`
    ///  The `ID3D12Resource`
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `update-region`
    ///  The update region for [`update-texture`][struct@crate::Gdk::D3d12TextureBuilder#update-texture].
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `update-texture`
    ///  The texture [`update-region`][struct@crate::Gdk::D3d12TextureBuilder#update-region] is an update for.
    ///
    /// Readable | Writeable
    #[doc(alias = "GdkD3D12TextureBuilder")]
    pub struct D3D12TextureBuilder(Object<ffi::GdkD3D12TextureBuilder, ffi::GdkD3D12TextureBuilderClass>);

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

impl D3D12TextureBuilder {
    /// Creates a new texture builder.
    ///
    /// # Returns
    ///
    /// the new `GdkTextureBuilder`
    #[doc(alias = "gdk_d3d12_texture_builder_new")]
    pub fn new() -> D3D12TextureBuilder {
        assert_initialized_main_thread!();
        unsafe { from_glib_full(ffi::gdk_d3d12_texture_builder_new()) }
    }

    //#[doc(alias = "gdk_d3d12_texture_builder_build")]
    //pub fn build(&self, data: /*Unimplemented*/Option<Basic: Pointer>) -> Result<Option<gdk::Texture>, glib::Error> {
    //    unsafe { TODO: call ffi:gdk_d3d12_texture_builder_build() }
    //}

    /// Gets the color state previously set via gdk_d3d12_texture_builder_set_color_state().
    ///
    /// # Returns
    ///
    /// the color state
    #[doc(alias = "gdk_d3d12_texture_builder_get_color_state")]
    #[doc(alias = "get_color_state")]
    #[doc(alias = "color-state")]
    pub fn color_state(&self) -> Option<gdk::ColorState> {
        unsafe {
            from_glib_none(ffi::gdk_d3d12_texture_builder_get_color_state(
                self.to_glib_none().0,
            ))
        }
    }

    //#[doc(alias = "gdk_d3d12_texture_builder_get_fence")]
    //#[doc(alias = "get_fence")]
    //pub fn fence(&self) -> /*Unimplemented*/Option<Basic: Pointer> {
    //    unsafe { TODO: call ffi:gdk_d3d12_texture_builder_get_fence() }
    //}

    /// Returns the value that GTK should wait for on the fence
    /// before using the resource.
    ///
    /// # Returns
    ///
    /// the fence wait value
    #[doc(alias = "gdk_d3d12_texture_builder_get_fence_wait")]
    #[doc(alias = "get_fence_wait")]
    #[doc(alias = "fence-wait")]
    pub fn fence_wait(&self) -> u64 {
        unsafe { ffi::gdk_d3d12_texture_builder_get_fence_wait(self.to_glib_none().0) }
    }

    /// Whether the data is premultiplied.
    ///
    /// # Returns
    ///
    /// whether the data is premultiplied
    #[doc(alias = "gdk_d3d12_texture_builder_get_premultiplied")]
    #[doc(alias = "get_premultiplied")]
    #[doc(alias = "premultiplied")]
    pub fn is_premultiplied(&self) -> bool {
        unsafe {
            from_glib(ffi::gdk_d3d12_texture_builder_get_premultiplied(
                self.to_glib_none().0,
            ))
        }
    }

    //#[doc(alias = "gdk_d3d12_texture_builder_get_resource")]
    //#[doc(alias = "get_resource")]
    //pub fn resource(&self) -> /*Unimplemented*/Option<Basic: Pointer> {
    //    unsafe { TODO: call ffi:gdk_d3d12_texture_builder_get_resource() }
    //}

    /// Gets the region previously set via gdk_d3d12_texture_builder_set_update_region() or
    /// [`None`] if none was set.
    ///
    /// # Returns
    ///
    /// The region
    #[doc(alias = "gdk_d3d12_texture_builder_get_update_region")]
    #[doc(alias = "get_update_region")]
    #[doc(alias = "update-region")]
    pub fn update_region(&self) -> Option<cairo::Region> {
        unsafe {
            from_glib_none(ffi::gdk_d3d12_texture_builder_get_update_region(
                self.to_glib_none().0,
            ))
        }
    }

    /// Gets the texture previously set via gdk_d3d12_texture_builder_set_update_texture() or
    /// [`None`] if none was set.
    ///
    /// # Returns
    ///
    /// The texture
    #[doc(alias = "gdk_d3d12_texture_builder_get_update_texture")]
    #[doc(alias = "get_update_texture")]
    #[doc(alias = "update-texture")]
    pub fn update_texture(&self) -> Option<gdk::Texture> {
        unsafe {
            from_glib_none(ffi::gdk_d3d12_texture_builder_get_update_texture(
                self.to_glib_none().0,
            ))
        }
    }

    /// Sets the color state for the texture.
    ///
    /// By default, the colorstate is `NULL`. In that case, GTK will choose the
    /// correct colorstate based on the format.
    /// If you don't know what colorstates are, this is probably the right thing.
    /// ## `color_state`
    /// a [`gdk::ColorState`][crate::gdk::ColorState] or `NULL` to unset the colorstate.
    #[doc(alias = "gdk_d3d12_texture_builder_set_color_state")]
    #[doc(alias = "color-state")]
    pub fn set_color_state(&self, color_state: Option<&gdk::ColorState>) {
        unsafe {
            ffi::gdk_d3d12_texture_builder_set_color_state(
                self.to_glib_none().0,
                color_state.to_glib_none().0,
            );
        }
    }

    //#[doc(alias = "gdk_d3d12_texture_builder_set_fence")]
    //#[doc(alias = "fence")]
    //pub fn set_fence(&self, fence: /*Unimplemented*/Basic: Pointer) {
    //    unsafe { TODO: call ffi:gdk_d3d12_texture_builder_set_fence() }
    //}

    /// Sets the value that GTK should wait on on the given fence before using the
    /// resource.
    ///
    /// When no fence is set, this value has no effect.
    /// ## `fence_wait`
    /// the value to wait on
    #[doc(alias = "gdk_d3d12_texture_builder_set_fence_wait")]
    #[doc(alias = "fence-wait")]
    pub fn set_fence_wait(&self, fence_wait: u64) {
        unsafe {
            ffi::gdk_d3d12_texture_builder_set_fence_wait(self.to_glib_none().0, fence_wait);
        }
    }

    /// Sets whether the data is premultiplied.
    ///
    /// Unless otherwise specified, all formats including alpha channels are assumed
    /// to be premultiplied.
    /// ## `premultiplied`
    /// whether the data is premultiplied
    #[doc(alias = "gdk_d3d12_texture_builder_set_premultiplied")]
    #[doc(alias = "premultiplied")]
    pub fn set_premultiplied(&self, premultiplied: bool) {
        unsafe {
            ffi::gdk_d3d12_texture_builder_set_premultiplied(
                self.to_glib_none().0,
                premultiplied.into_glib(),
            );
        }
    }

    //#[doc(alias = "gdk_d3d12_texture_builder_set_resource")]
    //#[doc(alias = "resource")]
    //pub fn set_resource(&self, resource: /*Unimplemented*/Basic: Pointer) {
    //    unsafe { TODO: call ffi:gdk_d3d12_texture_builder_set_resource() }
    //}

    /// Sets the region to be updated by this texture. Together with
    /// [`update-texture`][struct@crate::Gdk::D3d12TextureBuilder#update-texture] this describes an
    /// update of a previous texture.
    ///
    /// When rendering animations of large textures, it is possible that
    /// consecutive textures are only updating contents in parts of the texture.
    /// It is then possible to describe this update via these two properties,
    /// so that GTK can avoid rerendering parts that did not change.
    ///
    /// An example would be a screen recording where only the mouse pointer moves.
    /// ## `region`
    /// the region to update
    #[doc(alias = "gdk_d3d12_texture_builder_set_update_region")]
    #[doc(alias = "update-region")]
    pub fn set_update_region(&self, region: Option<&cairo::Region>) {
        unsafe {
            ffi::gdk_d3d12_texture_builder_set_update_region(
                self.to_glib_none().0,
                mut_override(region.to_glib_none().0),
            );
        }
    }

    /// Sets the texture to be updated by this texture. See
    /// `Gdk::D3d12TextureBuilder::set_update_region()` for an explanation.
    /// ## `texture`
    /// the texture to update
    #[doc(alias = "gdk_d3d12_texture_builder_set_update_texture")]
    #[doc(alias = "update-texture")]
    pub fn set_update_texture(&self, texture: Option<&impl IsA<gdk::Texture>>) {
        unsafe {
            ffi::gdk_d3d12_texture_builder_set_update_texture(
                self.to_glib_none().0,
                texture.map(|p| p.as_ref()).to_glib_none().0,
            );
        }
    }

    #[cfg(feature = "v4_20")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
    #[doc(alias = "color-state")]
    pub fn connect_color_state_notify<F: Fn(&Self) + Send + Sync + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_color_state_trampoline<
            F: Fn(&D3D12TextureBuilder) + Send + Sync + 'static,
        >(
            this: *mut ffi::GdkD3D12TextureBuilder,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::color-state".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_color_state_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[cfg(feature = "v4_20")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
    #[doc(alias = "fence")]
    pub fn connect_fence_notify<F: Fn(&Self) + Send + Sync + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_fence_trampoline<
            F: Fn(&D3D12TextureBuilder) + Send + Sync + 'static,
        >(
            this: *mut ffi::GdkD3D12TextureBuilder,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::fence".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_fence_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[cfg(feature = "v4_20")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
    #[doc(alias = "fence-wait")]
    pub fn connect_fence_wait_notify<F: Fn(&Self) + Send + Sync + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_fence_wait_trampoline<
            F: Fn(&D3D12TextureBuilder) + Send + Sync + 'static,
        >(
            this: *mut ffi::GdkD3D12TextureBuilder,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::fence-wait".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_fence_wait_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[cfg(feature = "v4_20")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
    #[doc(alias = "premultiplied")]
    pub fn connect_premultiplied_notify<F: Fn(&Self) + Send + Sync + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_premultiplied_trampoline<
            F: Fn(&D3D12TextureBuilder) + Send + Sync + 'static,
        >(
            this: *mut ffi::GdkD3D12TextureBuilder,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::premultiplied".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_premultiplied_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[cfg(feature = "v4_20")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
    #[doc(alias = "resource")]
    pub fn connect_resource_notify<F: Fn(&Self) + Send + Sync + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_resource_trampoline<
            F: Fn(&D3D12TextureBuilder) + Send + Sync + 'static,
        >(
            this: *mut ffi::GdkD3D12TextureBuilder,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::resource".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_resource_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[cfg(feature = "v4_20")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
    #[doc(alias = "update-region")]
    pub fn connect_update_region_notify<F: Fn(&Self) + Send + Sync + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_update_region_trampoline<
            F: Fn(&D3D12TextureBuilder) + Send + Sync + 'static,
        >(
            this: *mut ffi::GdkD3D12TextureBuilder,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::update-region".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_update_region_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[cfg(feature = "v4_20")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
    #[doc(alias = "update-texture")]
    pub fn connect_update_texture_notify<F: Fn(&Self) + Send + Sync + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_update_texture_trampoline<
            F: Fn(&D3D12TextureBuilder) + Send + Sync + 'static,
        >(
            this: *mut ffi::GdkD3D12TextureBuilder,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::update-texture".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_update_texture_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}

#[cfg(feature = "v4_20")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
impl Default for D3D12TextureBuilder {
    fn default() -> Self {
        Self::new()
    }
}

unsafe impl Send for D3D12TextureBuilder {}
unsafe impl Sync for D3D12TextureBuilder {}