| Top |  |
 |
 |
 |
Functions
Types and Values
| enum | GskRenderNodeType |
| enum | GskSerializationError |
| enum | GskScalingFilter |
| struct | GskShadow |
| enum | GskBlendMode |
Description
GskRenderNode is the basic block in a scene graph to be rendered using GskRenderer.
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 using gsk_render_node_set_bounds().
Render nodes are meant to be transient; once they have been associated to a GskRenderer it's safe to release any reference you have on them. All GskRenderNodes are immutable, you can only specify their properties during construction.
Functions
gsk_render_node_ref ()
GskRenderNode *
gsk_render_node_ref (GskRenderNode *node);
Acquires a reference on the given GskRenderNode.
Since: 3.90
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.
Since: 3.90
gsk_render_node_get_node_type ()
GskRenderNodeType
gsk_render_node_get_node_type (GskRenderNode *node);
Returns the type of the node
.
Since: 3.90
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 GdkWindow'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_set_name ()
void gsk_render_node_set_name (GskRenderNode *node,const char *name);
Sets the name of the node.
A name is generally useful for debugging purposes.
Since: 3.90
gsk_render_node_get_name ()
const char *
gsk_render_node_get_name (GskRenderNode *node);
Retrieves the name previously set via gsk_render_node_set_name().
If no name has been set, NULL is returned.
Since: 3.90
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.
Since: 3.90
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
.
Since: 3.90
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
.
Since: 3.90
gsk_texture_node_get_texture ()
GdkTexture *
gsk_texture_node_get_texture (GskRenderNode *node);
Since: 3.94
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
.
Parameters
bounds |
the rectangle to render the linear gradient into |
|
start |
the point at which the linear gradient will begin |
|
end |
the point at which the linear gradient will finish |
|
color_stops |
a pointer to an array of GskColorStop defining the gradient. |
[array length=n_color_stops] |
n_color_stops |
the number of elements in |
Since: 3.90
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
.
Parameters
bounds |
the rectangle to render the linear gradient into |
|
start |
the point at which the linear gradient will begin |
|
end |
the point at which the linear gradient will finish |
|
color_stops |
a pointer to an array of GskColorStop defining the gradient. |
[array length=n_color_stops] |
n_color_stops |
the number of elements in |
Since: 3.90
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.
Parameters
outline |
a GskRoundedRect describing the outline of the border |
|
border_width |
the stroke width of the border on the top, right, bottom and left side respectively. |
|
border_color |
the color used on the top, right, bottom and left side. |
Since: 3.90
gsk_border_node_peek_outline ()
const GskRoundedRect *
gsk_border_node_peek_outline (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
.
Parameters
outline |
outline of the region containing the shadow |
|
color |
color of the shadow |
|
dx |
horizontal offset of shadow |
|
dy |
vertical offset of shadow |
|
spread |
how far the shadow spreads towards the inside |
|
blur_radius |
how much blur to apply to the shadow |
Since: 3.90
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_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
.
Parameters
outline |
outline of the region surrounded by shadow |
|
color |
color of the shadow |
|
dx |
horizontal offset of shadow |
|
dy |
vertical offset of shadow |
|
spread |
how far the shadow spreads towards the inside |
|
blur_radius |
how much blur to apply to the shadow |
Since: 3.90
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_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()
Since: 3.90
gsk_cairo_node_get_draw_context ()
cairo_t * gsk_cairo_node_get_draw_context (GskRenderNode *node,GskRenderer *renderer);
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
.
Since: 3.90
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.
Parameters
children |
The children of the node. |
[array length=n_children][transfer none] |
n_children |
Number of children in the |
Since: 3.90
gsk_container_node_get_n_children ()
guint
gsk_container_node_get_n_children (GskRenderNode *node);
Retrieves the number of direct children of node
.
Since: 3.90
gsk_container_node_get_child ()
GskRenderNode * gsk_container_node_get_child (GskRenderNode *node,guint idx);
Gets one of the children of container
.
Since: 3.90
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
.
Since: 3.90
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_opacity_node_new ()
GskRenderNode * gsk_opacity_node_new (GskRenderNode *child,double opacity);
Creates a GskRenderNode that will drawn the child
with reduced
opacity
.
Since: 3.90
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_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.
Parameters
child |
The node to draw |
|
color_matrix |
The matrix to apply |
|
color_offset |
Values to add to the color |
Since: 3.90
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
.
Parameters
bounds |
The bounds of the area to be painted |
|
child |
The child to repeat |
|
child_bounds |
The area of the child to repeat or |
[allow-none] |
Since: 3.90
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
.
Since: 3.90
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_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
.
Since: 3.90
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.
Parameters
child |
The node to draw |
|
shadows |
The shadows to apply. |
[array length=n_shadows] |
n_shadows |
number of entries in the |
Since: 3.90
gsk_shadow_node_peek_shadow ()
const GskShadow * gsk_shadow_node_peek_shadow (GskRenderNode *node,gsize i);
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.
Parameters
bottom |
The bottom node to be drawn |
|
top |
The node to be blended onto the |
|
blend_mode |
The blend mode to use |
Since: 3.90
gsk_blend_node_get_bottom_child ()
GskRenderNode *
gsk_blend_node_get_bottom_child (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
.
Parameters
start |
The start node to be drawn |
|
end |
The node to be cross_fadeed onto the |
|
progress |
How far the fade has progressed from start to end. The value will be clamped to the range [0 ... 1] |
Since: 3.90
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_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.
Parameters
font |
the PangoFont containing the glyphs |
|
glyphs |
the PangoGlyphString to render |
|
color |
the foreground color to render with |
|
x |
the x coordinate at which to put the baseline |
|
y |
the y coordinate at wihch to put the baseline |
Since: 3.92
gsk_text_node_peek_glyphs ()
const PangoGlyphInfo *
gsk_text_node_peek_glyphs (GskRenderNode *node);
gsk_blur_node_new ()
GskRenderNode * gsk_blur_node_new (GskRenderNode *child,double radius);
Creates a render node that blurs the child.
Since: 3.92
Types and Values
enum GskRenderNodeType
The type of a node determines what the node is rendering.
Members
|
Error type. No node will ever have this type. |
||
|
A node containing a stack of children |
||
|
A node drawing a cairo_surface_t |
||
|
A node drawing a single color rectangle |
||
|
A node drawing a linear gradient |
||
|
A node drawing a repeating linear gradient |
||
|
A node stroking a border around an area |
||
|
A node drawing a GdkTexture |
||
|
A node drawing an inset shadow |
||
|
A node drawing an outset shadow |
||
|
A node that renders its child after applying a matrix transform |
||
|
A node that changes the opacity of its child |
||
|
A node that applies a color matrix to every pixel |
||
|
A node that repeats the child's contents |
||
|
A node that clips its child to a rectangular area |
||
|
A node that clips its child to a rounded rectangle |
||
|
A node that draws a shadow below its child |
||
|
A node that blends two children together |
||
|
A node that cross-fades between two children |
||
|
A node containing a glyph string |
||
|
A node that applies a blur |
Since: 3.90
enum GskScalingFilter
The filters used when scaling texture data.
The actual implementation of each filter is deferred to the rendering pipeline.
Since: 3.90
enum GskBlendMode
The blend modes available for render nodes.
The implementation of each blend mode is deferred to the rendering pipeline.
Members
|
The default blend mode, which specifies no blending |
||
|
The source color is multiplied by the destination and replaces the destination |
||
|
... |
||
|
... |
||
|
... |
||
|
... |
||
|
... |
||
|
... |
||
|
... |
||
|
... |
||
|
... |
||
|
... |
||
|
... |
||
|
... |
||
|
... |
||
|
... |
Since: 3.90
GSK 4 Reference Manual |
|---|
This document is for the GSK 4 library, version 3.93.0 The latest versions can be found online at https://developer.gnome.org/gsk4/.
- I. API Reference
- GskRenderer — Renders a scene
- GskRenderNode — Simple scene graph element
- Index of all symbols
|
 |
|
 |
B
C
I
L
O
R
S
T
| Top | |
|
|
|
Functions
Properties
| GdkDisplay * | display | Read / Write / Construct Only |
| GdkDrawingContext * | drawing-context | Read |
| GdkWindow * | window | Read |
Description
GskRenderer is a class that renders a scene graph defined via a tree of GskRenderNode instances.
Typically you will use a GskRenderer instance with a GdkDrawingContext
associated to a GdkWindow, and call gsk_renderer_render() with the
drawing context and the scene to be rendered.
It is necessary to realize a GskRenderer instance using gsk_renderer_realize()
before calling gsk_renderer_render(), in order to create the appropriate
windowing system resources needed to render the scene.
Functions
gsk_renderer_new_for_window ()
GskRenderer *
gsk_renderer_new_for_window (GdkWindow *window);
Creates an appropriate GskRenderer instance for the given window
.
The renderer will be realized when it is returned.
Since: 3.90
gsk_renderer_get_window ()
GdkWindow *
gsk_renderer_get_window (GskRenderer *renderer);
Retrieves the GdkWindow set using gsk_renderer_realize(). If the renderer
has not been realized yet, NULL will be returned.
Since: 3.90
gsk_renderer_get_display ()
GdkDisplay *
gsk_renderer_get_display (GskRenderer *renderer);
Retrieves the GdkDisplay used when creating the GskRenderer.
Since: 3.90
gsk_renderer_realize ()
gboolean gsk_renderer_realize (GskRenderer *renderer,GdkWindow *window,GError **error);
Creates the resources needed by the renderer
to render the scene
graph.
Parameters
renderer |
||
window |
the GdkWindow renderer will be used on |
|
error |
return location for an error |
Since: 3.90
gsk_renderer_unrealize ()
void
gsk_renderer_unrealize (GskRenderer *renderer);
Releases all the resources created by gsk_renderer_realize().
Since: 3.90
gsk_renderer_begin_draw_frame ()
GdkDrawingContext * gsk_renderer_begin_draw_frame (GskRenderer *renderer,const cairo_region_t *region);
Indicates that you are beginning the process of redrawing region
using
renderer
, and provides you with a GdkDrawingContext to use for this.
Returns
a GdkDrawingContext context that should be used to
draw the contents of the renderer
. This context is owned by GDK.
Since: 3.90
gsk_renderer_end_draw_frame ()
void gsk_renderer_end_draw_frame (GskRenderer *renderer,GdkDrawingContext *context);
Release the drawning context returned by gsk_renderer_begin_draw_frame().
Calls to gsk_renderer_begin_draw_frame() and gsk_renderer_end_draw_frame()
must be paired.
Parameters
renderer |
||
context |
the drawing context returned by the matching call to
|
Since: 3.90
gsk_renderer_render ()
void gsk_renderer_render (GskRenderer *renderer,GskRenderNode *root,GdkDrawingContext *context);
Renders the scene graph, described by a tree of GskRenderNode instances, using the given GdkDrawingContext.
The renderer
will acquire a reference on the GskRenderNode tree while
the rendering is in progress.
Since: 3.90
gsk_renderer_render_texture ()
GdkTexture * gsk_renderer_render_texture (GskRenderer *renderer,GskRenderNode *root,const graphene_rect_t *viewport);
Renders the scene graph, described by a tree of GskRenderNode instances, to a GdkTexture.
The renderer
will acquire a reference on the GskRenderNode tree while
the rendering is in progress, and will make the tree immutable.
If you want to apply any transformations to root
, you should put it into a
transform node and pass that node instead.
Parameters
renderer |
a realized GdkRenderer |
|
root |
||
viewport |
the section to draw or |
[allow-none] |
Since: 3.90
Property Details
The “display” property
“display” GdkDisplay *
The GdkDisplay used by the GskRenderer.
Flags: Read / Write / Construct Only
Since: 3.90
The “drawing-context” property
“drawing-context” GdkDrawingContext *
The drawing context used when rendering.
Flags: Read
Since: 3.90
|
|
|
|
Table of Contents
- GskRenderer — Renders a scene
- GskRenderNode — Simple scene graph element