gdk4/

cairo_interaction.rs

// Take a look at the license at the top of the repository in the LICENSE file.

use cairo::{Context, Region};
use gdk_pixbuf::Pixbuf;
use glib::translate::*;

use crate::{RGBA, Rectangle, Surface, ffi};

// rustdoc-stripper-ignore-next
/// Trait containing integration methods with [`cairo::Surface`].
pub trait GdkCairoSurfaceExt {
    /// Creates region that covers the area where the given
    /// @surface is more than 50% opaque.
    ///
    /// This function takes into account device offsets that might be
    /// set with cairo_surface_set_device_offset().
    /// ## `surface`
    /// a cairo surface
    ///
    /// # Returns
    ///
    /// A [`cairo::Region`][crate::cairo::Region]
    #[doc(alias = "gdk_cairo_region_create_from_surface")]
    fn create_region(&self) -> Region;
}

impl GdkCairoSurfaceExt for cairo::Surface {
    fn create_region(&self) -> Region {
        unsafe {
            from_glib_full(ffi::gdk_cairo_region_create_from_surface(
                self.to_glib_none().0,
            ))
        }
    }
}

// rustdoc-stripper-ignore-next
/// Trait containing integration methods with [`cairo::Context`].
pub trait GdkCairoContextExt: sealed::Sealed {
    // rustdoc-stripper-ignore-next
    /// # Safety
    ///
    /// It's the responsibility of the caller to ensure that source
    /// is a valid GL resource.
    // rustdoc-stripper-ignore-next-stop
    /// Draws GL content onto a cairo context.
    ///
    /// It takes a render buffer ID (@source_type == GL_RENDERBUFFER) or a texture
    /// id (@source_type == GL_TEXTURE) and draws it onto @cr with an OVER operation,
    /// respecting the current clip. The top left corner of the rectangle specified
    /// by @x, @y, @width and @height will be drawn at the current (0,0) position of
    /// the [`cairo::Context`][crate::cairo::Context].
    ///
    /// This will work for *all* [`cairo::Context`][crate::cairo::Context], as long as @surface is realized, but the
    /// fallback implementation that reads back the pixels from the buffer may be
    /// used in the general case. In the case of direct drawing to a surface with
    /// no special effects applied to @cr it will however use a more efficient
    /// approach.
    ///
    /// For GL_RENDERBUFFER the code will always fall back to software for buffers
    /// with alpha components, so make sure you use GL_TEXTURE if using alpha.
    ///
    /// Calling this may change the current GL context.
    ///
    /// # Deprecated since 4.6
    ///
    /// The function is overly complex and produces broken output
    ///   in various combinations of arguments. If you want to draw with GL textures
    ///   in GTK, use [`GLTexture::new()`][crate::GLTexture::new()]; if you want to use that texture in
    ///   Cairo, use [`TextureExtManual::download()`][crate::prelude::TextureExtManual::download()] to download the data into a Cairo
    ///   image surface.
    /// ## `cr`
    /// a cairo context
    /// ## `surface`
    /// The surface we're rendering for (not necessarily into)
    /// ## `source`
    /// The GL ID of the source buffer
    /// ## `source_type`
    /// The type of the @source
    /// ## `buffer_scale`
    /// The scale-factor that the @source buffer is allocated for
    /// ## `x`
    /// The source x position in @source to start copying from in GL coordinates
    /// ## `y`
    /// The source y position in @source to start copying from in GL coordinates
    /// ## `width`
    /// The width of the region to draw
    /// ## `height`
    /// The height of the region to draw
    #[doc(alias = "gdk_cairo_draw_from_gl")]
    #[allow(clippy::too_many_arguments)]
    unsafe fn draw_from_gl(
        &self,
        surface: &Surface,
        source: i32,
        source_type: i32,
        buffer_scale: i32,
        x: i32,
        y: i32,
        width: i32,
        height: i32,
    ) {
        unsafe {
            skip_assert_initialized!();
            ffi::gdk_cairo_draw_from_gl(
                self.to_raw(),
                surface.to_glib_none().0,
                source,
                source_type,
                buffer_scale,
                x,
                y,
                width,
                height,
            );
        }
    }

    /// Sets the specified [`RGBA`][crate::RGBA] as the source color of @cr.
    /// ## `cr`
    /// a cairo context
    /// ## `rgba`
    /// a [`RGBA`][crate::RGBA]
    #[doc(alias = "gdk_cairo_set_source_rgba")]
    #[doc(alias = "set_source_rgba")]
    fn set_source_color(&self, rgba: &RGBA) {
        unsafe {
            ffi::gdk_cairo_set_source_rgba(self.to_raw(), rgba.to_glib_none().0);
        }
    }

    /// Sets the given pixbuf as the source pattern for @cr.
    ///
    /// The pattern has an extend mode of `CAIRO_EXTEND_NONE` and is aligned
    /// so that the origin of @pixbuf is @pixbuf_x, @pixbuf_y.
    ///
    /// # Deprecated since 4.20
    ///
    /// Use cairo_set_source_surface() and gdk_texture_download()
    /// ## `cr`
    /// a cairo context
    /// ## `pixbuf`
    /// a [`gdk_pixbuf::Pixbuf`][crate::gdk_pixbuf::Pixbuf]
    /// ## `pixbuf_x`
    /// X coordinate of location to place upper left corner of @pixbuf
    /// ## `pixbuf_y`
    /// Y coordinate of location to place upper left corner of @pixbuf
    #[doc(alias = "gdk_cairo_set_source_pixbuf")]
    fn set_source_pixbuf(&self, pixbuf: &Pixbuf, x: f64, y: f64) {
        unsafe {
            ffi::gdk_cairo_set_source_pixbuf(self.to_raw(), pixbuf.to_glib_none().0, x, y);
        }
    }

    /// Adds the given rectangle to the current path of @cr.
    /// ## `cr`
    /// a cairo context
    /// ## `rectangle`
    /// a [`Rectangle`][crate::Rectangle]
    #[doc(alias = "gdk_cairo_rectangle")]
    fn add_rectangle(&self, rectangle: &Rectangle) {
        unsafe {
            ffi::gdk_cairo_rectangle(self.to_raw(), rectangle.to_glib_none().0);
        }
    }

    /// Adds the given region to the current path of @cr.
    /// ## `cr`
    /// a cairo context
    /// ## `region`
    /// a [`cairo::Region`][crate::cairo::Region]
    #[doc(alias = "gdk_cairo_region")]
    fn add_region(&self, region: &Region) {
        unsafe {
            ffi::gdk_cairo_region(self.to_raw(), region.to_glib_none().0);
        }
    }
}

impl GdkCairoContextExt for Context {}

mod sealed {
    use cairo::{Context, ffi::cairo_t};

    pub trait Sealed {
        fn to_raw(&self) -> *mut cairo_t;
    }

    impl Sealed for Context {
        fn to_raw(&self) -> *mut cairo_t {
            self.to_raw_none()
        }
    }
}