1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160

// This file was generated by gir (https://github.com/gtk-rs/gir)
// from gir-files (https://github.com/gtk-rs/gir-files.git)
// DO NOT EDIT

use crate::RenderNodeType;
use glib::translate::*;
use glib::StaticType;
use std::fmt;
use std::ptr;

glib::wrapper! {
    /// [`RenderNode`][crate::RenderNode] is the basic block in a scene graph to be
    /// rendered using [`Renderer`][crate::Renderer].
    ///
    /// Each node has a parent, except the top-level node; each node may have
    /// children nodes.
    ///
    /// Each node has an associated drawing surface, which has the size of
    /// the rectangle set when creating it.
    ///
    /// Render nodes are meant to be transient; once they have been associated
    /// to a [`Renderer`][crate::Renderer] it's safe to release any reference you have on
    /// them. All [`RenderNode`][crate::RenderNode]s are immutable, you can only specify their
    /// properties during construction.
    ///
    /// This is an Abstract Base Class, you cannot instantiate it.
    #[doc(alias = "GskRenderNode")]
    pub struct RenderNode(Shared<ffi::GskRenderNode>);

    match fn {
        ref => |ptr| ffi::gsk_render_node_ref(ptr),
        unref => |ptr| ffi::gsk_render_node_unref(ptr),
    }
}

impl glib::StaticType for RenderNode {
    fn static_type() -> glib::Type {
        unsafe { from_glib(ffi::gsk_render_node_get_type()) }
    }
}

impl RenderNode {
    pub const NONE: Option<&'static RenderNode> = None;

    /// Draw the contents of @self to the given cairo context.
    ///
    /// Typically, you'll use this function to implement fallback rendering
    /// of [`RenderNode`][crate::RenderNode]s on an intermediate Cairo context, instead of using
    /// the drawing context associated to a [`gdk::Surface`][crate::gdk::Surface]'s rendering buffer.
    ///
    /// For advanced nodes that cannot be supported using Cairo, in particular
    /// for nodes doing 3D operations, this function may fail.
    /// ## `cr`
    /// cairo context to draw to
    #[doc(alias = "gsk_render_node_draw")]
    pub fn draw(&self, cr: &cairo::Context) {
        unsafe {
            ffi::gsk_render_node_draw(
                self.as_ref().to_glib_none().0,
                mut_override(cr.to_glib_none().0),
            );
        }
    }

    /// Retrieves the boundaries of the @self.
    ///
    /// The node will not draw outside of its boundaries.
    ///
    /// # Returns
    ///
    ///
    /// ## `bounds`
    /// return location for the boundaries
    #[doc(alias = "gsk_render_node_get_bounds")]
    #[doc(alias = "get_bounds")]
    pub fn bounds(&self) -> graphene::Rect {
        unsafe {
            let mut bounds = graphene::Rect::uninitialized();
            ffi::gsk_render_node_get_bounds(
                self.as_ref().to_glib_none().0,
                bounds.to_glib_none_mut().0,
            );
            bounds
        }
    }

    /// Returns the type of the @self.
    ///
    /// # Returns
    ///
    /// the type of the [`RenderNode`][crate::RenderNode]
    #[doc(alias = "gsk_render_node_get_node_type")]
    #[doc(alias = "get_node_type")]
    pub fn node_type(&self) -> RenderNodeType {
        unsafe {
            from_glib(ffi::gsk_render_node_get_node_type(const_override(
                self.as_ref().to_glib_none().0,
            )))
        }
    }

    /// Serializes the @self for later deserialization via
    /// gsk_render_node_deserialize(). No guarantees are made about the format
    /// used other than that the same version of GTK will be able to deserialize
    /// the result of a call to gsk_render_node_serialize() and
    /// gsk_render_node_deserialize() will correctly reject files it cannot open
    /// that were created with previous versions of GTK.
    ///
    /// The intended use of this functions is testing, benchmarking and debugging.
    /// The format is not meant as a permanent storage format.
    ///
    /// # Returns
    ///
    /// a `GBytes` representing the node.
    #[doc(alias = "gsk_render_node_serialize")]
    pub fn serialize(&self) -> glib::Bytes {
        unsafe {
            from_glib_full(ffi::gsk_render_node_serialize(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// This function is equivalent to calling [`serialize()`][Self::serialize()]
    /// followed by `file_set_contents()`.
    ///
    /// See those two functions for details on the arguments.
    ///
    /// It is mostly intended for use inside a debugger to quickly dump a render
    /// node to a file for later inspection.
    /// ## `filename`
    /// the file to save it to.
    ///
    /// # Returns
    ///
    /// [`true`] if saving was successful
    #[doc(alias = "gsk_render_node_write_to_file")]
    pub fn write_to_file(&self, filename: impl AsRef<std::path::Path>) -> Result<(), glib::Error> {
        unsafe {
            let mut error = ptr::null_mut();
            let is_ok = ffi::gsk_render_node_write_to_file(
                self.as_ref().to_glib_none().0,
                filename.as_ref().to_glib_none().0,
                &mut error,
            );
            assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }
}

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