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.

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,
                             GError **error);

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_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,
                        const graphene_matrix_t *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_peek_transform ()

const graphene_matrix_t *
gsk_transform_node_peek_transform (GskRenderNode *node);

gsk_offset_node_new ()

GskRenderNode *
gsk_offset_node_new (GskRenderNode *child,
                     double x_offset,
                     double y_offset);

Creates a GskRenderNode that will offset the given child with the given x_offset and y_offset .

This is a common special case of the matrix transform achieved by gsk_transform_node_new().

gsk_offset_node_get_child ()

GskRenderNode *
gsk_offset_node_get_child (GskRenderNode *node);

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

gsk_offset_node_get_x_offset ()

double
gsk_offset_node_get_x_offset (GskRenderNode *node);

gsk_offset_node_get_y_offset ()

double
gsk_offset_node_get_y_offset (GskRenderNode *node);

gsk_opacity_node_new ()

GskRenderNode *
gsk_opacity_node_new (GskRenderNode *child,
                      double 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 ()

double
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_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,
                         double 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 ()

double
gsk_cross_fade_node_get_progress (GskRenderNode *node);

gsk_text_node_new ()

GskRenderNode *
gsk_text_node_new (PangoFont *font,
                   PangoGlyphString *glyphs,
                   const GdkRGBA *color,
                   double x,
                   double y);

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 ()

const PangoFont *
gsk_text_node_peek_font (GskRenderNode *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_x ()

float
gsk_text_node_get_x (GskRenderNode *node);

gsk_text_node_get_y ()

float
gsk_text_node_get_y (GskRenderNode *node);

gsk_blur_node_new ()

GskRenderNode *
gsk_blur_node_new (GskRenderNode *child,
                   double 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 ()

double
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

enum GskRenderNodeType

The type of a node determines what the node is rendering.

enum GskSerializationError

Errors that can happen during (de)serialization.

enum GskScalingFilter

The filters used when scaling texture data.

The actual implementation of each filter is deferred to the rendering pipeline.

struct GskShadow

struct GskShadow {
  GdkRGBA color;
  float dx;
  float dy;
  float radius;
};

enum GskBlendMode

The blend modes available for render nodes.

The implementation of each blend mode is deferred to the rendering pipeline.