gsk_render_node_ref ()

GskRenderNode *
gsk_render_node_ref (GskRenderNode *node);

Acquires a reference on the given GskRenderNode.

gsk_render_node_unref ()

void
gsk_render_node_unref (GskRenderNode *node);

Releases a reference on the given GskRenderNode.

If the reference was the last, the resources associated to the node are freed.

gsk_render_node_get_node_type ()

GskRenderNodeType
gsk_render_node_get_node_type (GskRenderNode *node);

Returns the type of the node .

gsk_render_node_draw ()

void
gsk_render_node_draw (GskRenderNode *node,
                      cairo_t *cr);

Draw the contents of node to the given cairo context.

Typically, you'll use this function to implement fallback rendering of GskRenderNodes on an intermediate Cairo context, instead of using the drawing context associated to a GdkSurface's rendering buffer.

For advanced nodes that cannot be supported using Cairo, in particular for nodes doing 3D operations, this function may fail.

GskParseErrorFunc ()

void
(*GskParseErrorFunc) (const GtkCssSection *section,
                      const GError *error,
                      gpointer user_data);

The type of callback that is called when a parse error occurs during deserialization of node data.

gsk_render_node_serialize ()

GBytes *
gsk_render_node_serialize (GskRenderNode *node);

Serializes the node 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.

gsk_render_node_deserialize ()

GskRenderNode *
gsk_render_node_deserialize (GBytes *bytes,
                             GskParseErrorFunc error_func,
                             gpointer user_data);

Loads data previously created via gsk_render_node_serialize(). For a discussion of the supported format, see that function.

gsk_render_node_write_to_file ()

gboolean
gsk_render_node_write_to_file (GskRenderNode *node,
                               const char *filename,
                               GError **error);

This function is equivalent to calling gsk_render_node_serialize() followed by g_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.

gsk_render_node_get_bounds ()

void
gsk_render_node_get_bounds (GskRenderNode *node,
                            graphene_rect_t *bounds);

Retrieves the boundaries of the node . The node will not draw outside of its boundaries.

gsk_color_node_new ()

GskRenderNode *
gsk_color_node_new (const GdkRGBA *rgba,
                    const graphene_rect_t *bounds);

Creates a GskRenderNode that will render the color specified by rgba into the area given by bounds .

gsk_color_node_peek_color ()

const GdkRGBA *
gsk_color_node_peek_color (GskRenderNode *node);

gsk_texture_node_new ()

GskRenderNode *
gsk_texture_node_new (GdkTexture *texture,
                      const graphene_rect_t *bounds);

Creates a GskRenderNode that will render the given texture into the area given by bounds .

gsk_texture_node_get_texture ()

GdkTexture *
gsk_texture_node_get_texture (GskRenderNode *node);

gsk_linear_gradient_node_new ()

GskRenderNode *
gsk_linear_gradient_node_new (const graphene_rect_t *bounds,
                              const graphene_point_t *start,
                              const graphene_point_t *end,
                              const GskColorStop *color_stops,
                              gsize n_color_stops);

Creates a GskRenderNode that will create a linear gradient from the given points and color stops, and render that into the area given by bounds .

gsk_linear_gradient_node_peek_start ()

const graphene_point_t *
gsk_linear_gradient_node_peek_start (GskRenderNode *node);

gsk_linear_gradient_node_peek_end ()

const graphene_point_t *
gsk_linear_gradient_node_peek_end (GskRenderNode *node);

gsk_linear_gradient_node_get_n_color_stops ()

gsize
gsk_linear_gradient_node_get_n_color_stops
                               (GskRenderNode *node);

gsk_linear_gradient_node_peek_color_stops ()

const GskColorStop *
gsk_linear_gradient_node_peek_color_stops
                               (GskRenderNode *node);

gsk_repeating_linear_gradient_node_new ()

GskRenderNode *
gsk_repeating_linear_gradient_node_new
                               (const graphene_rect_t *bounds,
                                const graphene_point_t *start,
                                const graphene_point_t *end,
                                const GskColorStop *color_stops,
                                gsize n_color_stops);

Creates a GskRenderNode that will create a repeating linear gradient from the given points and color stops, and render that into the area given by bounds .

gsk_border_node_new ()

GskRenderNode *
gsk_border_node_new (const GskRoundedRect *outline,
                     const float border_width[4],
                     const GdkRGBA border_color[4]);

Creates a GskRenderNode that will stroke a border rectangle inside the given outline . The 4 sides of the border can have different widths and colors.

gsk_border_node_peek_outline ()

const GskRoundedRect *
gsk_border_node_peek_outline (GskRenderNode *node);

gsk_border_node_peek_widths ()

const float *
gsk_border_node_peek_widths (GskRenderNode *node);

gsk_border_node_peek_colors ()

const GdkRGBA *
gsk_border_node_peek_colors (GskRenderNode *node);

gsk_inset_shadow_node_new ()

GskRenderNode *
gsk_inset_shadow_node_new (const GskRoundedRect *outline,
                           const GdkRGBA *color,
                           float dx,
                           float dy,
                           float spread,
                           float blur_radius);

Creates a GskRenderNode that will render an inset shadow into the box given by outline .

gsk_inset_shadow_node_peek_outline ()

const GskRoundedRect *
gsk_inset_shadow_node_peek_outline (GskRenderNode *node);

gsk_inset_shadow_node_peek_color ()

const GdkRGBA *
gsk_inset_shadow_node_peek_color (GskRenderNode *node);

gsk_inset_shadow_node_get_dx ()

float
gsk_inset_shadow_node_get_dx (GskRenderNode *node);

gsk_inset_shadow_node_get_dy ()

float
gsk_inset_shadow_node_get_dy (GskRenderNode *node);

gsk_inset_shadow_node_get_spread ()

float
gsk_inset_shadow_node_get_spread (GskRenderNode *node);

gsk_inset_shadow_node_get_blur_radius ()

float
gsk_inset_shadow_node_get_blur_radius (GskRenderNode *node);

gsk_outset_shadow_node_new ()

GskRenderNode *
gsk_outset_shadow_node_new (const GskRoundedRect *outline,
                            const GdkRGBA *color,
                            float dx,
                            float dy,
                            float spread,
                            float blur_radius);

Creates a GskRenderNode that will render an outset shadow around the box given by outline .

gsk_outset_shadow_node_peek_outline ()

const GskRoundedRect *
gsk_outset_shadow_node_peek_outline (GskRenderNode *node);

gsk_outset_shadow_node_peek_color ()

const GdkRGBA *
gsk_outset_shadow_node_peek_color (GskRenderNode *node);

gsk_outset_shadow_node_get_dx ()

float
gsk_outset_shadow_node_get_dx (GskRenderNode *node);

gsk_outset_shadow_node_get_dy ()

float
gsk_outset_shadow_node_get_dy (GskRenderNode *node);

gsk_outset_shadow_node_get_spread ()

float
gsk_outset_shadow_node_get_spread (GskRenderNode *node);

gsk_outset_shadow_node_get_blur_radius ()

float
gsk_outset_shadow_node_get_blur_radius
                               (GskRenderNode *node);

gsk_cairo_node_new ()

GskRenderNode *
gsk_cairo_node_new (const graphene_rect_t *bounds);

Creates a GskRenderNode that will render a cairo surface into the area given by bounds . You can draw to the cairo surface using gsk_cairo_node_get_draw_context()

gsk_cairo_node_get_draw_context ()

cairo_t *
gsk_cairo_node_get_draw_context (GskRenderNode *node);

Creates a Cairo context for drawing using the surface associated to the render node. If no surface exists yet, a surface will be created optimized for rendering to renderer .

gsk_cairo_node_peek_surface ()

cairo_surface_t *
gsk_cairo_node_peek_surface (GskRenderNode *node);

gsk_container_node_new ()

GskRenderNode *
gsk_container_node_new (GskRenderNode **children,
                        guint n_children);

Creates a new GskRenderNode instance for holding the given children . The new node will acquire a reference to each of the children.

gsk_container_node_get_n_children ()

guint
gsk_container_node_get_n_children (GskRenderNode *node);

Retrieves the number of direct children of node .

gsk_container_node_get_child ()

GskRenderNode *
gsk_container_node_get_child (GskRenderNode *node,
                              guint idx);

Gets one of the children of container .

gsk_transform_node_new ()

GskRenderNode *
gsk_transform_node_new (GskRenderNode *child,
                        GskTransform *transform);

Creates a GskRenderNode that will transform the given child with the given transform .

gsk_transform_node_get_child ()

GskRenderNode *
gsk_transform_node_get_child (GskRenderNode *node);

Gets the child node that is getting transformed by the given node .

gsk_transform_node_get_transform ()

GskTransform *
gsk_transform_node_get_transform (GskRenderNode *node);

gsk_opacity_node_new ()

GskRenderNode *
gsk_opacity_node_new (GskRenderNode *child,
                      float opacity);

Creates a GskRenderNode that will drawn the child with reduced opacity .

gsk_opacity_node_get_child ()

GskRenderNode *
gsk_opacity_node_get_child (GskRenderNode *node);

Gets the child node that is getting opacityed by the given node .

gsk_opacity_node_get_opacity ()

float
gsk_opacity_node_get_opacity (GskRenderNode *node);

gsk_color_matrix_node_new ()

GskRenderNode *
gsk_color_matrix_node_new (GskRenderNode *child,
                           const graphene_matrix_t *color_matrix,
                           const graphene_vec4_t *color_offset);

Creates a GskRenderNode that will drawn the child with reduced color_matrix .

In particular, the node will transform the operation pixel = color_matrix * pixel + color_offset for every pixel.

gsk_color_matrix_node_get_child ()

GskRenderNode *
gsk_color_matrix_node_get_child (GskRenderNode *node);

Gets the child node that is getting its colors modified by the given node .

gsk_color_matrix_node_peek_color_matrix ()

const graphene_matrix_t *
gsk_color_matrix_node_peek_color_matrix
                               (GskRenderNode *node);

gsk_color_matrix_node_peek_color_offset ()

const graphene_vec4_t *
gsk_color_matrix_node_peek_color_offset
                               (GskRenderNode *node);

gsk_repeat_node_new ()

GskRenderNode *
gsk_repeat_node_new (const graphene_rect_t *bounds,
                     GskRenderNode *child,
                     const graphene_rect_t *child_bounds);

Creates a GskRenderNode that will repeat the drawing of child across the given bounds .

gsk_repeat_node_get_child ()

GskRenderNode *
gsk_repeat_node_get_child (GskRenderNode *node);

gsk_repeat_node_peek_child_bounds ()

const graphene_rect_t *
gsk_repeat_node_peek_child_bounds (GskRenderNode *node);

gsk_clip_node_new ()

GskRenderNode *
gsk_clip_node_new (GskRenderNode *child,
                   const graphene_rect_t *clip);

Creates a GskRenderNode that will clip the child to the area given by clip .

gsk_clip_node_get_child ()

GskRenderNode *
gsk_clip_node_get_child (GskRenderNode *node);

Gets the child node that is getting clipped by the given node .

gsk_clip_node_peek_clip ()

const graphene_rect_t *
gsk_clip_node_peek_clip (GskRenderNode *node);

gsk_rounded_clip_node_new ()

GskRenderNode *
gsk_rounded_clip_node_new (GskRenderNode *child,
                           const GskRoundedRect *clip);

Creates a GskRenderNode that will clip the child to the area given by clip .

gsk_rounded_clip_node_get_child ()

GskRenderNode *
gsk_rounded_clip_node_get_child (GskRenderNode *node);

Gets the child node that is getting clipped by the given node .

gsk_rounded_clip_node_peek_clip ()

const GskRoundedRect *
gsk_rounded_clip_node_peek_clip (GskRenderNode *node);

gsk_shadow_node_new ()

GskRenderNode *
gsk_shadow_node_new (GskRenderNode *child,
                     const GskShadow *shadows,
                     gsize n_shadows);

Creates a GskRenderNode that will draw a child with the given shadows below it.

gsk_shadow_node_peek_shadow ()

const GskShadow *
gsk_shadow_node_peek_shadow (GskRenderNode *node,
                             gsize i);

gsk_shadow_node_get_n_shadows ()

gsize
gsk_shadow_node_get_n_shadows (GskRenderNode *node);

gsk_shadow_node_get_child ()

GskRenderNode *
gsk_shadow_node_get_child (GskRenderNode *node);

gsk_blend_node_new ()

GskRenderNode *
gsk_blend_node_new (GskRenderNode *bottom,
                    GskRenderNode *top,
                    GskBlendMode blend_mode);

Creates a GskRenderNode that will use blend_mode to blend the top node onto the bottom node.

gsk_blend_node_get_bottom_child ()

GskRenderNode *
gsk_blend_node_get_bottom_child (GskRenderNode *node);

gsk_blend_node_get_top_child ()

GskRenderNode *
gsk_blend_node_get_top_child (GskRenderNode *node);

gsk_blend_node_get_blend_mode ()

GskBlendMode
gsk_blend_node_get_blend_mode (GskRenderNode *node);

gsk_cross_fade_node_new ()

GskRenderNode *
gsk_cross_fade_node_new (GskRenderNode *start,
                         GskRenderNode *end,
                         float progress);

Creates a GskRenderNode that will do a cross-fade between start and end .

gsk_cross_fade_node_get_start_child ()

GskRenderNode *
gsk_cross_fade_node_get_start_child (GskRenderNode *node);

gsk_cross_fade_node_get_end_child ()

GskRenderNode *
gsk_cross_fade_node_get_end_child (GskRenderNode *node);

gsk_cross_fade_node_get_progress ()

float
gsk_cross_fade_node_get_progress (GskRenderNode *node);

gsk_text_node_new ()

GskRenderNode *
gsk_text_node_new (PangoFont *font,
                   PangoGlyphString *glyphs,
                   const GdkRGBA *color,
                   const graphene_point_t *offset);

Creates a render node that renders the given glyphs, Note that color may not be used if the font contains color glyphs.

gsk_text_node_peek_font ()

PangoFont *
gsk_text_node_peek_font (GskRenderNode *node);

Returns the font used by the text node.

gsk_text_node_peek_glyphs ()

const PangoGlyphInfo *
gsk_text_node_peek_glyphs (GskRenderNode *node);

gsk_text_node_peek_color ()

const GdkRGBA *
gsk_text_node_peek_color (GskRenderNode *node);

gsk_text_node_get_num_glyphs ()

guint
gsk_text_node_get_num_glyphs (GskRenderNode *node);

gsk_text_node_get_offset ()

const graphene_point_t *
gsk_text_node_get_offset (GskRenderNode *node);

gsk_blur_node_new ()

GskRenderNode *
gsk_blur_node_new (GskRenderNode *child,
                   float radius);

Creates a render node that blurs the child.

gsk_blur_node_get_child ()

GskRenderNode *
gsk_blur_node_get_child (GskRenderNode *node);

gsk_blur_node_get_radius ()

float
gsk_blur_node_get_radius (GskRenderNode *node);

gsk_debug_node_new ()

GskRenderNode *
gsk_debug_node_new (GskRenderNode *child,
                    char *message);

Creates a GskRenderNode that will add debug information about the given child .

Adding this node has no visual effect.

gsk_debug_node_get_child ()

GskRenderNode *
gsk_debug_node_get_child (GskRenderNode *node);

Gets the child node that is getting debug by the given node .

gsk_debug_node_get_message ()

const char *
gsk_debug_node_get_message (GskRenderNode *node);

Gets the debug message that was set on this node