gsk4/auto/

render_replay.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::{RenderNode, ffi};
use glib::{prelude::*, translate::*};
use std::boxed::Box as Box_;

glib::wrapper! {
    /// A facility to replay a [`RenderNode`][crate::RenderNode] and its children, potentially
    /// modifying them.
    ///
    /// This is a utility tool to walk a rendernode tree. The most powerful way
    /// is to provide a function via [`set_node_filter()`][Self::set_node_filter()]
    /// to filter each individual node and then run
    /// [`filter_node()`][Self::filter_node()] on the nodes you want to filter.
    ///
    /// If you want to just walk the node tree and extract information
    /// without any modifications, you can also use [`RenderNode::children()`][crate::RenderNode::children()].
    ///
    /// Here is a little example application that redacts text in a node file:
    ///
    /// ```text
    /// #include <gtk/gtk.h>
    ///
    /// static GskRenderNode *
    /// redact_nodes (GskRenderReplay *replay,
    ///               GskRenderNode   *node,
    ///               gpointer         user_data)
    /// {
    ///   GskRenderNode *result;
    ///
    ///   if (gsk_render_node_get_node_type (node) == GSK_TEXT_NODE)
    ///     {
    ///       graphene_rect_t bounds;
    ///       const GdkRGBA *color;
    ///
    ///       gsk_render_node_get_bounds (node, &bounds);
    ///       color = gsk_text_node_get_color (node);
    ///
    ///       result = gsk_color_node_new (color, &bounds);
    ///     }
    ///   else
    ///     {
    ///       result = gsk_render_replay_default (replay, node);
    ///     }
    ///
    ///   return result;
    /// }
    ///
    /// int
    /// main (int argc, char *argv[])
    /// {
    ///   GFile *file;
    ///   GBytes *bytes;
    ///   GskRenderNode *result, *node;
    ///   GskRenderReplay *replay;
    ///
    ///   gtk_init ();
    ///
    ///   if (argc != 3)
    ///     {
    ///       g_print ("usage: %s INFILE OUTFILE\n", argv[0]);
    ///       return 0;
    ///     }
    ///
    ///   file = g_file_new_for_commandline_arg (argv[1]);
    ///   bytes = g_file_load_bytes (file, NULL, NULL, NULL);
    ///   g_object_unref (file);
    ///   if (bytes == NULL)
    ///     return 1;
    ///
    ///   node = gsk_render_node_deserialize (bytes, NULL, NULL);
    ///   g_bytes_unref (bytes);
    ///   if (node == NULL)
    ///     return 1;
    ///
    ///   replay = gsk_render_replay_new ();
    ///   gsk_render_replay_set_node_filter (replay, redact_nodes, NULL, NULL);
    ///   result = gsk_render_replay_filter_node (replay, node);
    ///   gsk_render_replay_free (replay);
    ///
    ///   if (!gsk_render_node_write_to_file (result, argv[2], NULL))
    ///     return 1;
    ///
    ///   gsk_render_node_unref (result);
    ///   gsk_render_node_unref (node);
    ///
    ///   return 0;
    /// }
    /// ```
    #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct RenderReplay(Boxed<ffi::GskRenderReplay>);

    match fn {
        copy => |ptr| glib::gobject_ffi::g_boxed_copy(ffi::gsk_render_replay_get_type(), ptr as *mut _) as *mut ffi::GskRenderReplay,
        free => |ptr| glib::gobject_ffi::g_boxed_free(ffi::gsk_render_replay_get_type(), ptr as *mut _),
        type_ => || ffi::gsk_render_replay_get_type(),
    }
}

impl RenderReplay {
    /// Creates a new replay object to replay nodes.
    ///
    /// # Returns
    ///
    /// A new replay object to replay nodes
    #[doc(alias = "gsk_render_replay_new")]
    pub fn new() -> RenderReplay {
        assert_initialized_main_thread!();
        unsafe { from_glib_full(ffi::gsk_render_replay_new()) }
    }

    /// Replays the node using the default method.
    ///
    /// The default method calls [`filter_node()`][Self::filter_node()]
    /// on all its child nodes and the filter functions for all its
    /// properties. If none of them are changed, it returns the passed
    /// in node. Otherwise it constructs a new node with the changed
    /// children and properties.
    ///
    /// It may not be possible to construct a new node when any of the
    /// callbacks return NULL. In that case, this function will return
    /// NULL, too.
    /// ## `node`
    /// the node to replay
    ///
    /// # Returns
    ///
    /// The replayed node
    #[doc(alias = "gsk_render_replay_default")]
    #[allow(clippy::should_implement_trait)]
    pub fn default(&mut self, node: impl AsRef<RenderNode>) -> Option<RenderNode> {
        unsafe {
            from_glib_full(ffi::gsk_render_replay_default(
                self.to_glib_none_mut().0,
                node.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Filters a font using the current filter function.
    /// ## `font`
    /// The font to filter
    ///
    /// # Returns
    ///
    /// the filtered font
    #[doc(alias = "gsk_render_replay_filter_font")]
    pub fn filter_font(&mut self, font: &impl IsA<pango::Font>) -> pango::Font {
        unsafe {
            from_glib_full(ffi::gsk_render_replay_filter_font(
                self.to_glib_none_mut().0,
                font.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Replays a node using the replay's filter function.
    ///
    /// After the replay the node may be unchanged, or it may be
    /// removed, which will result in [`None`] being returned.
    ///
    /// If no filter node is set, [`default()`][Self::default()] is
    /// called instead.
    /// ## `node`
    /// the node to replay
    ///
    /// # Returns
    ///
    /// The replayed node
    #[doc(alias = "gsk_render_replay_filter_node")]
    pub fn filter_node(&mut self, node: impl AsRef<RenderNode>) -> Option<RenderNode> {
        unsafe {
            from_glib_full(ffi::gsk_render_replay_filter_node(
                self.to_glib_none_mut().0,
                node.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Filters a texture using the current filter function.
    /// ## `texture`
    /// The texture to filter
    ///
    /// # Returns
    ///
    /// the filtered texture
    #[doc(alias = "gsk_render_replay_filter_texture")]
    pub fn filter_texture(&mut self, texture: &impl IsA<gdk::Texture>) -> gdk::Texture {
        unsafe {
            from_glib_full(ffi::gsk_render_replay_filter_texture(
                self.to_glib_none_mut().0,
                texture.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Sets a filter function to be called by [`default()`][Self::default()]
    /// for nodes that contain fonts.
    ///
    /// You can call `GskRenderReplay::filter_font()` to filter
    /// a font yourself.
    /// ## `filter`
    ///
    ///   the font filter function
    #[doc(alias = "gsk_render_replay_set_font_filter")]
    pub fn set_font_filter(
        &mut self,
        filter: Option<Box_<dyn Fn(&RenderReplay, &pango::Font) -> pango::Font + 'static>>,
    ) {
        let filter_data: Box_<
            Option<Box_<dyn Fn(&RenderReplay, &pango::Font) -> pango::Font + 'static>>,
        > = Box_::new(filter);
        unsafe extern "C" fn filter_func(
            replay: *mut ffi::GskRenderReplay,
            font: *mut pango::ffi::PangoFont,
            user_data: glib::ffi::gpointer,
        ) -> *mut pango::ffi::PangoFont {
            unsafe {
                let replay = from_glib_borrow(replay);
                let font = from_glib_borrow(font);
                let callback = &*(user_data
                    as *mut Option<
                        Box_<dyn Fn(&RenderReplay, &pango::Font) -> pango::Font + 'static>,
                    >);
                if let Some(ref callback) = *callback {
                    callback(&replay, &font)
                } else {
                    panic!("cannot get closure...")
                }
                .to_glib_full()
            }
        }
        let filter = if filter_data.is_some() {
            Some(filter_func as _)
        } else {
            None
        };
        unsafe extern "C" fn user_destroy_func(data: glib::ffi::gpointer) {
            unsafe {
                let _callback = Box_::from_raw(
                    data as *mut Option<
                        Box_<dyn Fn(&RenderReplay, &pango::Font) -> pango::Font + 'static>,
                    >,
                );
            }
        }
        let destroy_call3 = Some(user_destroy_func as _);
        let super_callback0: Box_<
            Option<Box_<dyn Fn(&RenderReplay, &pango::Font) -> pango::Font + 'static>>,
        > = filter_data;
        unsafe {
            ffi::gsk_render_replay_set_font_filter(
                self.to_glib_none_mut().0,
                filter,
                Box_::into_raw(super_callback0) as *mut _,
                destroy_call3,
            );
        }
    }

    /// Sets the function to use as a node filter.
    ///
    /// This is the most complex function to use for replaying nodes.
    /// It can either:
    ///
    /// * keep the node and just return it unchanged
    ///
    /// * create a replacement node and return that
    ///
    /// * discard the node by returning `NULL`
    ///
    /// * call [`default()`][Self::default()] to have the default handler
    ///   run for this node, which calls your function on its children
    /// ## `filter`
    ///
    ///   the function to call to replay nodes
    #[doc(alias = "gsk_render_replay_set_node_filter")]
    pub fn set_node_filter(
        &mut self,
        filter: Option<Box_<dyn Fn(&RenderReplay, &RenderNode) -> Option<RenderNode> + 'static>>,
    ) {
        let filter_data: Box_<
            Option<Box_<dyn Fn(&RenderReplay, &RenderNode) -> Option<RenderNode> + 'static>>,
        > = Box_::new(filter);
        unsafe extern "C" fn filter_func(
            replay: *mut ffi::GskRenderReplay,
            node: *mut ffi::GskRenderNode,
            user_data: glib::ffi::gpointer,
        ) -> *mut ffi::GskRenderNode {
            unsafe {
                let replay = from_glib_borrow(replay);
                let node = from_glib_borrow(node);
                let callback = &*(user_data
                    as *mut Option<
                        Box_<dyn Fn(&RenderReplay, &RenderNode) -> Option<RenderNode> + 'static>,
                    >);
                if let Some(ref callback) = *callback {
                    callback(&replay, &node)
                } else {
                    panic!("cannot get closure...")
                }
                .to_glib_full()
            }
        }
        let filter = if filter_data.is_some() {
            Some(filter_func as _)
        } else {
            None
        };
        unsafe extern "C" fn user_destroy_func(data: glib::ffi::gpointer) {
            unsafe {
                let _callback = Box_::from_raw(
                    data as *mut Option<
                        Box_<dyn Fn(&RenderReplay, &RenderNode) -> Option<RenderNode> + 'static>,
                    >,
                );
            }
        }
        let destroy_call3 = Some(user_destroy_func as _);
        let super_callback0: Box_<
            Option<Box_<dyn Fn(&RenderReplay, &RenderNode) -> Option<RenderNode> + 'static>>,
        > = filter_data;
        unsafe {
            ffi::gsk_render_replay_set_node_filter(
                self.to_glib_none_mut().0,
                filter,
                Box_::into_raw(super_callback0) as *mut _,
                destroy_call3,
            );
        }
    }

    /// Sets a filter function to be called by [`default()`][Self::default()]
    /// for nodes that contain textures.
    ///
    /// You can call `GskRenderReplay::filter_texture()` to filter
    /// a texture yourself.
    /// ## `filter`
    ///
    ///   the texture filter function
    #[doc(alias = "gsk_render_replay_set_texture_filter")]
    pub fn set_texture_filter(
        &mut self,
        filter: Option<Box_<dyn Fn(&RenderReplay, &gdk::Texture) -> gdk::Texture + 'static>>,
    ) {
        let filter_data: Box_<
            Option<Box_<dyn Fn(&RenderReplay, &gdk::Texture) -> gdk::Texture + 'static>>,
        > = Box_::new(filter);
        unsafe extern "C" fn filter_func(
            replay: *mut ffi::GskRenderReplay,
            texture: *mut gdk::ffi::GdkTexture,
            user_data: glib::ffi::gpointer,
        ) -> *mut gdk::ffi::GdkTexture {
            unsafe {
                let replay = from_glib_borrow(replay);
                let texture = from_glib_borrow(texture);
                let callback = &*(user_data
                    as *mut Option<
                        Box_<dyn Fn(&RenderReplay, &gdk::Texture) -> gdk::Texture + 'static>,
                    >);
                if let Some(ref callback) = *callback {
                    callback(&replay, &texture)
                } else {
                    panic!("cannot get closure...")
                }
                .to_glib_full()
            }
        }
        let filter = if filter_data.is_some() {
            Some(filter_func as _)
        } else {
            None
        };
        unsafe extern "C" fn user_destroy_func(data: glib::ffi::gpointer) {
            unsafe {
                let _callback = Box_::from_raw(
                    data as *mut Option<
                        Box_<dyn Fn(&RenderReplay, &gdk::Texture) -> gdk::Texture + 'static>,
                    >,
                );
            }
        }
        let destroy_call3 = Some(user_destroy_func as _);
        let super_callback0: Box_<
            Option<Box_<dyn Fn(&RenderReplay, &gdk::Texture) -> gdk::Texture + 'static>>,
        > = filter_data;
        unsafe {
            ffi::gsk_render_replay_set_texture_filter(
                self.to_glib_none_mut().0,
                filter,
                Box_::into_raw(super_callback0) as *mut _,
                destroy_call3,
            );
        }
    }
}

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