| Top |  |
 |
 |
 |
Functions
Types and Values
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.
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);
Retrieves the color of the given 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);
Retrieves the GdkTexture used when creating this GskRenderNode.
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 |
gsk_linear_gradient_node_peek_start ()
const graphene_point_t *
gsk_linear_gradient_node_peek_start (GskRenderNode *node);
Retrieves the initial point of the linear gradient.
gsk_linear_gradient_node_peek_end ()
const graphene_point_t *
gsk_linear_gradient_node_peek_end (GskRenderNode *node);
Retrieves the final point of the linear gradient.
gsk_linear_gradient_node_get_n_color_stops ()
gsize
gsk_linear_gradient_node_get_n_color_stops
(GskRenderNode *node);
Retrieves the number of color stops in the gradient.
gsk_linear_gradient_node_peek_color_stops ()
const GskColorStop * gsk_linear_gradient_node_peek_color_stops (GskRenderNode *node,gsize *n_stops);
Retrieves the color stops in the gradient.
Parameters
node |
a GskRenderNode for a linear gradient. |
[type GskLinearGradientNode] |
n_stops |
the number of color stops in the returned array. |
[out][optional] |
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 |
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. |
[array fixed-size=4] |
border_color |
the color used on the top, right, bottom and left side. |
[array fixed-size=4] |
gsk_border_node_peek_outline ()
const GskRoundedRect *
gsk_border_node_peek_outline (GskRenderNode *node);
Retrieves the outline of the border.
gsk_border_node_peek_widths ()
const float *
gsk_border_node_peek_widths (GskRenderNode *node);
Retrieves the stroke widths of the border.
gsk_border_node_peek_colors ()
const GdkRGBA *
gsk_border_node_peek_colors (GskRenderNode *node);
Retrieves the colors of the border.
Returns
an array of 4 GdkRGBA structs for the top, right, bottom and left color of the border.
[transfer none]
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);
Retrieves the outline rectangle of the inset shadow.
gsk_inset_shadow_node_peek_color ()
const GdkRGBA *
gsk_inset_shadow_node_peek_color (GskRenderNode *node);
Retrieves the color of the inset shadow.
gsk_inset_shadow_node_get_dx ()
float
gsk_inset_shadow_node_get_dx (GskRenderNode *node);
Retrieves the horizontal offset of the inset shadow.
gsk_inset_shadow_node_get_dy ()
float
gsk_inset_shadow_node_get_dy (GskRenderNode *node);
Retrieves the vertical offset of the inset shadow.
gsk_inset_shadow_node_get_spread ()
float
gsk_inset_shadow_node_get_spread (GskRenderNode *node);
Retrieves how much the shadow spreads inwards.
gsk_inset_shadow_node_get_blur_radius ()
float
gsk_inset_shadow_node_get_blur_radius (GskRenderNode *node);
Retrieves the blur radius to apply to the shadow.
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);
Retrieves the outline rectangle of the outset shadow.
gsk_outset_shadow_node_peek_color ()
const GdkRGBA *
gsk_outset_shadow_node_peek_color (GskRenderNode *node);
Retrieves the color of the outset shadow.
gsk_outset_shadow_node_get_dx ()
float
gsk_outset_shadow_node_get_dx (GskRenderNode *node);
Retrieves the horizontal offset of the outset shadow.
gsk_outset_shadow_node_get_dy ()
float
gsk_outset_shadow_node_get_dy (GskRenderNode *node);
Retrieves the vertical offset of the outset shadow.
gsk_outset_shadow_node_get_spread ()
float
gsk_outset_shadow_node_get_spread (GskRenderNode *node);
Retrieves how much the shadow spreads outwards.
gsk_outset_shadow_node_get_blur_radius ()
float
gsk_outset_shadow_node_get_blur_radius
(GskRenderNode *node);
Retrieves the blur radius of the shadow.
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);
Retrieves the Cairo surface used by the render 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
.
Parameters
node |
a container GskRenderNode. |
[type GskContainerNode] |
idx |
the position of the child to get |
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);
Retrieves the GskTransform used by the 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);
Gets the transparency factor for an opacity 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
1 |
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);
Retrieves the color matrix used by the node
.
gsk_color_matrix_node_peek_color_offset ()
const graphene_vec4_t *
gsk_color_matrix_node_peek_color_offset
(GskRenderNode *node);
Retrieves the color offset used by the 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);
Retrieves the child of node
.
gsk_repeat_node_peek_child_bounds ()
const graphene_rect_t *
gsk_repeat_node_peek_child_bounds (GskRenderNode *node);
Retrieves the bounding rectangle of the child of 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);
Retrieves the clip rectangle for 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);
Retrievs the rounded rectangle used to clip the contents of the 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);
Retrieves the shadow data at the given index i
.
gsk_shadow_node_get_n_shadows ()
gsize
gsk_shadow_node_get_n_shadows (GskRenderNode *node);
Retrieves the number of shadows in the node
.
gsk_shadow_node_get_child ()
GskRenderNode *
gsk_shadow_node_get_child (GskRenderNode *node);
Retrieves the child GskRenderNode of the shadow 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);
Retrieves the bottom GskRenderNode child of the node
.
gsk_blend_node_get_top_child ()
GskRenderNode *
gsk_blend_node_get_top_child (GskRenderNode *node);
Retrieves the top GskRenderNode child of the node
.
gsk_blend_node_get_blend_mode ()
GskBlendMode
gsk_blend_node_get_blend_mode (GskRenderNode *node);
Retrieves the blend mode used by 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);
Retrieves the child GskRenderNode at the beginning of the cross-fade.
gsk_cross_fade_node_get_end_child ()
GskRenderNode *
gsk_cross_fade_node_get_end_child (GskRenderNode *node);
Retrieves the child GskRenderNode at the end of the cross-fade.
gsk_cross_fade_node_get_progress ()
float
gsk_cross_fade_node_get_progress (GskRenderNode *node);
Retrieves the progress value of the cross fade.
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.
Parameters
font |
the PangoFont containing the glyphs |
|
glyphs |
the PangoGlyphString to render |
|
color |
the foreground color to render with |
|
offset |
offset of the baseline |
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,guint *n_glyphs);
Retrieves the glyph information in the node
.
Parameters
node |
a text GskRenderNode. |
[type GskTextNode] |
n_glyphs |
the number of glyphs returned. |
[out][optional] |
gsk_text_node_peek_color ()
const GdkRGBA *
gsk_text_node_peek_color (GskRenderNode *node);
Retrieves the color used by the text node
.
gsk_text_node_has_color_glyphs ()
gboolean
gsk_text_node_has_color_glyphs (GskRenderNode *node);
Checks whether the text node
has color glyphs.
gsk_text_node_get_num_glyphs ()
guint
gsk_text_node_get_num_glyphs (GskRenderNode *node);
Retrieves the number of glyphs in the text node.
gsk_text_node_get_offset ()
const graphene_point_t *
gsk_text_node_get_offset (GskRenderNode *node);
Retrieves the offset applied to the text.
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);
Retrieves the child GskRenderNode of the blur node
.
gsk_blur_node_get_radius ()
float
gsk_blur_node_get_radius (GskRenderNode *node);
Retrieves the blur radius of the 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 drawn 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
Types and Values
GskRepeatingLinearGradientNode
typedef struct _GskRepeatingLinearGradientNode GskRepeatingLinearGradientNode;
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 |
||
|
Debug information that does not affect the rendering |
enum GskScalingFilter
The filters used when scaling texture data.
The actual implementation of each filter is deferred to the rendering pipeline.
enum GskBlendMode
The blend modes available for render nodes.
The implementation of each blend mode is deferred to the rendering pipeline.
See https://www.w3.org/TR/compositing-1/blending for more information on blending and blend modes.
Members
|
The default blend mode, which specifies no blending |
||
|
The source color is multiplied by the destination and replaces the destination |
||
|
Multiplies the complements of the destination and source color values, then complements the result. |
||
|
Multiplies or screens the colors, depending on the destination color value. This is the inverse of hard-list |
||
|
Selects the darker of the destination and source colors |
||
|
Selects the lighter of the destination and source colors |
||
|
Brightens the destination color to reflect the source color |
||
|
Darkens the destination color to reflect the source color |
||
|
Multiplies or screens the colors, depending on the source color value |
||
|
Darkens or lightens the colors, depending on the source color value |
||
|
Subtracts the darker of the two constituent colors from the lighter color |
||
|
Produces an effect similar to that of the difference mode but lower in contrast |
||
|
Creates a color with the hue and saturation of the source color and the luminosity of the destination color |
||
|
Creates a color with the hue of the source color and the saturation and luminosity of the destination color |
||
|
Creates a color with the saturation of the source color and the hue and luminosity of the destination color |
||
|
Creates a color with the luminosity of the source color and the hue and saturation of the destination color |
| Top | |
|
|
|
Functions
| GdkSurface * | gsk_renderer_get_surface () |
| gboolean | gsk_renderer_realize () |
| void | gsk_renderer_unrealize () |
| gboolean | gsk_renderer_is_realized () |
| void | gsk_renderer_render () |
| GdkTexture * | gsk_renderer_render_texture () |
| GskRenderer * | gsk_renderer_new_for_surface () |
| GskRenderer * | gsk_gl_renderer_new () |
| GskRenderer * | gsk_cairo_renderer_new () |
| GskRenderer * | gsk_vulkan_renderer_new () |
| GskRenderer * | gsk_broadway_renderer_new () |
Description
GskRenderer is a class that renders a scene graph defined via a tree of GskRenderNode instances.
Typically you will use a GskRenderer instance to repeatedly call
gsk_renderer_render() to update the contents of its associated GdkSurface.
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_get_surface ()
GdkSurface *
gsk_renderer_get_surface (GskRenderer *renderer);
Retrieves the GdkSurface set using gsk_renderer_realize(). If the renderer
has not been realized yet, NULL will be returned.
gsk_renderer_realize ()
gboolean gsk_renderer_realize (GskRenderer *renderer,GdkSurface *surface,GError **error);
Creates the resources needed by the renderer
to render the scene
graph.
Parameters
renderer |
||
surface |
the GdkSurface renderer will be used on |
|
error |
return location for an error |
gsk_renderer_unrealize ()
void
gsk_renderer_unrealize (GskRenderer *renderer);
Releases all the resources created by gsk_renderer_realize().
gsk_renderer_is_realized ()
gboolean
gsk_renderer_is_realized (GskRenderer *renderer);
Checks whether the renderer
is realized or not.
gsk_renderer_render ()
void gsk_renderer_render (GskRenderer *renderer,GskRenderNode *root,const cairo_region_t *region);
Renders the scene graph, described by a tree of GskRenderNode instances,
ensuring that the given region
gets redrawn.
Renderers must ensure that changes of the contents given by the root
node as well as the area given by region
are redrawn. They are however
free to not redraw any pixel outside of region
if they can guarantee that
it didn't change.
The renderer
will acquire a reference on the GskRenderNode tree while
the rendering is in progress.
Parameters
renderer |
||
root |
||
region |
the cairo_region_t that must be redrawn or |
[nullable] |
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.
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 GskRenderer |
|
root |
||
viewport |
the section to draw or |
[allow-none] |
gsk_renderer_new_for_surface ()
GskRenderer *
gsk_renderer_new_for_surface (GdkSurface *surface);
Creates an appropriate GskRenderer instance for the given surface
.
The renderer will be realized when it is returned.
gsk_gl_renderer_new ()
GskRenderer *
gsk_gl_renderer_new (void);
Creates a new GskRenderer using OpenGL. This is the default renderer used by GTK.
gsk_cairo_renderer_new ()
GskRenderer *
gsk_cairo_renderer_new (void);
Creates a new Cairo renderer.
The Cairo renderer is the fallback renderer drawing in ways similar to how GTK 3 drew its content. Its primary use is as comparison tool.
The Cairo renderer is incomplete. It cannot render 3D transformed content and will instead render an error marker. Its usage should be avoided.
gsk_vulkan_renderer_new ()
GskRenderer *
gsk_vulkan_renderer_new (void);
Creates a new Vulkan renderer.
The Vulkan renderer is a renderer that uses the Vulkan library for rendering.
This function is only available when GTK was compiled with Vulkan support.
gsk_broadway_renderer_new ()
GskRenderer *
gsk_broadway_renderer_new (void);
Creates a new Broadway renderer.
The Broadway renderer is the default renderer for the broadway backend.
It will only work with broadway surfaces, otherwise it will fail the
call to gsk_renderer_realize().
This function is only available when GTK was compiled with Broadway support.
Property Details
The “realized” property
“realized” gboolean
The renderer has been associated with a surface.
Owner: GskRenderer
Flags: Read
Default value: FALSE
The “surface” property
“surface” GdkSurface *
The surface associated to the renderer.
Owner: GskRenderer
Flags: Read
|
 |
|
 |
A
NULL is OK, both for passing and for returning.
Parameter points to an array of items.
C
This parameter is a 'user_data', for callbacks; many bindings can pass NULL here.
N
NULL may be passed as the value in, out, in-out; or as a return value.
O
NULL may be passed instead of a pointer to a location.
Parameter for returning results. Default is transfer full.
Out parameter, where caller must allocate storage.
S
The callback is valid only during the call to the method.
T
Free data after the code is done.
Don't free data after the code is done.
Override the parsed C type with given type.
|
|
|
|
B
C
D
G
I
L
O
P
R
S
T
V
| Top | |
|
|
|
Functions
| #define | GSK_ROUNDED_RECT_INIT() |
| GskRoundedRect * | gsk_rounded_rect_init () |
| GskRoundedRect * | gsk_rounded_rect_init_copy () |
| GskRoundedRect * | gsk_rounded_rect_init_from_rect () |
| GskRoundedRect * | gsk_rounded_rect_normalize () |
| GskRoundedRect * | gsk_rounded_rect_offset () |
| GskRoundedRect * | gsk_rounded_rect_shrink () |
| gboolean | gsk_rounded_rect_is_rectilinear () |
| gboolean | gsk_rounded_rect_contains_point () |
| gboolean | gsk_rounded_rect_contains_rect () |
| gboolean | gsk_rounded_rect_intersects_rect () |
Description
GskRoundedRect defines a rectangle with rounded corners, as is commonly used in drawing.
Operations on a GskRoundedRect will normalize the rectangle, to ensure that the bounds are normalized and that the corner sizes don't exceed the size of the rectangle. The algorithm used for normalizing corner sizes is described in the CSS specification.
Functions
GSK_ROUNDED_RECT_INIT()
#define GSK_ROUNDED_RECT_INIT(_x,_y,_w,_h)
Initializes a GskRoundedRect when declaring it. All corner sizes will be initialized to 0.
gsk_rounded_rect_init ()
GskRoundedRect * gsk_rounded_rect_init (GskRoundedRect *self,const graphene_rect_t *bounds,const graphene_size_t *top_left,const graphene_size_t *top_right,const graphene_size_t *bottom_right,const graphene_size_t *bottom_left);
Initializes the given GskRoundedRect with the given values.
This function will implicitly normalize the GskRoundedRect before returning.
Parameters
self |
The GskRoundedRect to initialize |
|
bounds |
a graphene_rect_t describing the bounds |
|
top_left |
the rounding radius of the top left corner |
|
top_right |
the rounding radius of the top right corner |
|
bottom_right |
the rounding radius of the bottom right corner |
|
bottom_left |
the rounding radius of the bottom left corner |
gsk_rounded_rect_init_copy ()
GskRoundedRect * gsk_rounded_rect_init_copy (GskRoundedRect *self,const GskRoundedRect *src);
Initializes self
using the given src
rectangle.
This function will not normalize the GskRoundedRect, so make sure the source is normalized.
gsk_rounded_rect_init_from_rect ()
GskRoundedRect * gsk_rounded_rect_init_from_rect (GskRoundedRect *self,const graphene_rect_t *bounds,float radius);
Initializes self
to the given bounds
and sets the radius of all
four corners to radius
.
gsk_rounded_rect_normalize ()
GskRoundedRect *
gsk_rounded_rect_normalize (GskRoundedRect *self);
Normalizes the passed rectangle.
this function will ensure that the bounds of the rectangle are normalized and ensure that the corner values are positive and the corners do not overlap.
gsk_rounded_rect_offset ()
GskRoundedRect * gsk_rounded_rect_offset (GskRoundedRect *self,float dx,float dy);
Offsets the bound's origin by dx
and dy
.
The size and corners of the rectangle are unchanged.
gsk_rounded_rect_shrink ()
GskRoundedRect * gsk_rounded_rect_shrink (GskRoundedRect *self,float top,float right,float bottom,float left);
Shrinks (or grows) the given rectangle by moving the 4 sides according to the offsets given. The corner radii will be changed in a way that tries to keep the center of the corner circle intact. This emulates CSS behavior.
This function also works for growing rectangles if you pass
negative values for the top
, right
, bottom
or left
.
Parameters
self |
The GskRoundedRect to shrink or grow |
|
top |
How far to move the top side downwards |
|
right |
How far to move the right side to the left |
|
bottom |
How far to move the bottom side upwards |
|
left |
How far to move the left side to the right |
gsk_rounded_rect_is_rectilinear ()
gboolean
gsk_rounded_rect_is_rectilinear (const GskRoundedRect *self);
Checks if all corners of self
are right angles and the
rectangle covers all of its bounds.
This information can be used to decide if gsk_clip_node_new()
or gsk_rounded_clip_node_new() should be called.
gsk_rounded_rect_contains_point ()
gboolean gsk_rounded_rect_contains_point (const GskRoundedRect *self,const graphene_point_t *point);
Checks if the given point
is inside the rounded rectangle. This function
returns FALSE if the point is in the rounded corner areas.
gsk_rounded_rect_contains_rect ()
gboolean gsk_rounded_rect_contains_rect (const GskRoundedRect *self,const graphene_rect_t *rect);
Checks if the given rect
is contained inside the rounded rectangle.
This function returns FALSE if rect
extends into one of the rounded
corner areas.
gsk_rounded_rect_intersects_rect ()
gboolean gsk_rounded_rect_intersects_rect (const GskRoundedRect *self,const graphene_rect_t *rect);
Checks if part of the given rect
is contained inside the rounded rectangle.
This function returns FALSE if rect
only extends into one of the rounded
corner areas but not into the rounded rectangle itself.
Types and Values
struct GskRoundedRect
struct GskRoundedRect {
graphene_rect_t bounds;
graphene_size_t corner[4];
};
A rectangular region with rounded corners.
Application code should normalize rectangles using gsk_rounded_rect_normalize();
this function will ensure that the bounds of the rectangle are normalized
and ensure that the corner values are positive and the corners do not overlap.
All functions taking a GskRoundedRect as an argument will internally operate on
a normalized copy; all functions returning a GskRoundedRect will always return
a normalized one.
Members
graphene_rect_t |
the bounds of the rectangle |
|
graphene_size_t |
the size of the 4 rounded corners |
| Top | |
|
|
|
Functions
| GskTransform * | gsk_transform_ref () |
| void | gsk_transform_unref () |
| GskTransformCategory | gsk_transform_get_category () |
| void | gsk_transform_print () |
| char * | gsk_transform_to_string () |
| gboolean | gsk_transform_parse () |
| void | gsk_transform_to_matrix () |
| void | gsk_transform_to_2d () |
| void | gsk_transform_to_affine () |
| void | gsk_transform_to_translate () |
| GskTransform * | gsk_transform_transform () |
| GskTransform * | gsk_transform_invert () |
| GskTransform * | gsk_transform_matrix () |
| GskTransform * | gsk_transform_translate () |
| GskTransform * | gsk_transform_translate_3d () |
| GskTransform * | gsk_transform_rotate () |
| GskTransform * | gsk_transform_rotate_3d () |
| GskTransform * | gsk_transform_scale () |
| GskTransform * | gsk_transform_scale_3d () |
| GskTransform * | gsk_transform_perspective () |
| gboolean | gsk_transform_equal () |
| void | gsk_transform_transform_bounds () |
| void | gsk_transform_transform_point () |
Description
GskTransform is an object to describe transform matrices. Unlike graphene_matrix_t, GskTransform retains the steps in how a transform was constructed, and allows inspecting them. It is modeled after the way CSS describes transforms.
GskTransform objects are immutable and cannot be changed after creation. This means code can safely expose them as properties of objects without having to worry about others changing them.
Functions
gsk_transform_ref ()
GskTransform *
gsk_transform_ref (GskTransform *self);
Acquires a reference on the given GskTransform.
gsk_transform_unref ()
void
gsk_transform_unref (GskTransform *self);
Releases a reference on the given GskTransform.
If the reference was the last, the resources associated to the self
are
freed.
gsk_transform_get_category ()
GskTransformCategory
gsk_transform_get_category (GskTransform *self);
Returns the category this transform belongs to.
gsk_transform_print ()
void gsk_transform_print (GskTransform *self,GString *string);
Converts self
into a human-readable string representation suitable
for printing that can later be parsed with gsk_transform_parse().
gsk_transform_to_string ()
char *
gsk_transform_to_string (GskTransform *self);
Converts a matrix into a string that is suitable for
printing and can later be parsed with gsk_transform_parse().
This is a wrapper around gsk_transform_print(), see that function
for details.
gsk_transform_parse ()
gboolean gsk_transform_parse (const char *string,GskTransform **out_transform);
Parses the given string
into a transform and puts it in
out_transform
. Strings printed via gsk_transform_to_string()
can be read in again successfully using this function.
If string
does not describe a valid transform, FALSE is
returned and NULL is put in out_transform
.
gsk_transform_to_matrix ()
void gsk_transform_to_matrix (GskTransform *self,graphene_matrix_t *out_matrix);
Computes the actual value of self
and stores it in out_matrix
.
The previous value of out_matrix
will be ignored.
gsk_transform_to_2d ()
void gsk_transform_to_2d (GskTransform *self,float *out_xx,float *out_yx,float *out_xy,float *out_yy,float *out_dx,float *out_dy);
Converts a GskTransform to a 2D transformation
matrix.
self
must be a 2D transformation. If you are not
sure, use gsk_transform_get_category() >=
GSK_TRANSFORM_CATEGORY_2D to check.
The returned values have the following layout:
1 2 3 |
| xx yx | | a b 0 | | xy yy | = | c d 0 | | dx dy | | tx ty 1 | |
This function can be used to convert between a GskTransform and a matrix type from other 2D drawing libraries, in particular Cairo.
Parameters
self |
a 2D GskTransform |
|
out_xx |
return location for the xx member. |
[out] |
out_yx |
return location for the yx member. |
[out] |
out_xy |
return location for the xy member. |
[out] |
out_yy |
return location for the yy member. |
[out] |
out_dx |
return location for the x0 member. |
[out] |
out_dy |
return location for the y0 member. |
[out] |
gsk_transform_to_affine ()
void gsk_transform_to_affine (GskTransform *self,float *out_scale_x,float *out_scale_y,float *out_dx,float *out_dy);
Converts a GskTransform to 2D affine transformation
factors.
self
must be a 2D transformation. If you are not
sure, use gsk_transform_get_category() >=
GSK_TRANSFORM_CATEGORY_2D_AFFINE to check.
Parameters
self |
||
out_scale_x |
return location for the scale factor in the x direction. |
[out] |
out_scale_y |
return location for the scale factor in the y direction. |
[out] |
out_dx |
return location for the translation in the x direction. |
[out] |
out_dy |
return location for the translation in the y direction. |
[out] |
gsk_transform_to_translate ()
void gsk_transform_to_translate (GskTransform *self,float *out_dx,float *out_dy);
Converts a GskTransform to a translation operation.
self
must be a 2D transformation. If you are not
sure, use gsk_transform_get_category() >=
GSK_TRANSFORM_CATEGORY_2D_TRANSLATE to check.
gsk_transform_transform ()
GskTransform * gsk_transform_transform (GskTransform *next,GskTransform *other);
Applies all the operations from other
to next
.
gsk_transform_invert ()
GskTransform *
gsk_transform_invert (GskTransform *self);
Inverts the given transform.
If self
is not invertible, NULL is returned.
Note that inverting NULL also returns NULL, which is
the correct inverse of NULL. If you need to differentiate
between those cases, you should check self
is not NULL
before calling this function.
gsk_transform_matrix ()
GskTransform * gsk_transform_matrix (GskTransform *next,const graphene_matrix_t *matrix);
Multiplies next
with the given matrix
.
gsk_transform_translate ()
GskTransform * gsk_transform_translate (GskTransform *next,const graphene_point_t *point);
Translates next
in 2dimensional space by point
.
gsk_transform_translate_3d ()
GskTransform * gsk_transform_translate_3d (GskTransform *next,const graphene_point3d_t *point);
Translates next
by point
.
gsk_transform_rotate ()
GskTransform * gsk_transform_rotate (GskTransform *next,float angle);
Rotates next
angle
degrees in 2D - or in 3Dspeak, around the z axis.
gsk_transform_rotate_3d ()
GskTransform * gsk_transform_rotate_3d (GskTransform *next,float angle,const graphene_vec3_t *axis);
Rotates next
angle
degrees around axis
.
For a rotation in 2D space, use gsk_transform_rotate().
gsk_transform_scale ()
GskTransform * gsk_transform_scale (GskTransform *next,float factor_x,float factor_y);
Scales next
in 2-dimensional space by the given factors.
Use gsk_transform_scale_3d() to scale in all 3 dimensions.
gsk_transform_scale_3d ()
GskTransform * gsk_transform_scale_3d (GskTransform *next,float factor_x,float factor_y,float factor_z);
Scales next
by the given factors.
gsk_transform_perspective ()
GskTransform * gsk_transform_perspective (GskTransform *next,float depth);
Applies a perspective projection transform. This transform scales points in X and Y based on their Z value, scaling points with positive Z values away from the origin, and those with negative Z values towards the origin. Points on the z=0 plane are unchanged.
gsk_transform_equal ()
gboolean gsk_transform_equal (GskTransform *first,GskTransform *second);
Checks two transforms for equality.
gsk_transform_transform_bounds ()
void gsk_transform_transform_bounds (GskTransform *self,const graphene_rect_t *rect,graphene_rect_t *out_rect);
Transforms a graphene_rect_t using the given transform self
.
The result is the bounding box containing the coplanar quad.
gsk_transform_transform_point ()
void gsk_transform_transform_point (GskTransform *self,const graphene_point_t *point,graphene_point_t *out_point);
Transforms a graphene_point_t using the given transform self
.
Types and Values
GskTransform
typedef struct _GskTransform GskTransform;
The GskTransform structure contains only private data.
enum GskTransformCategory
The categories of matrices relevant for GSK and GTK. Note that any
category includes matrices of all later categories. So if you want
to for example check if a matrix is a 2D matrix,
category >= GSK_TRANSFORM_CATEGORY_2D is the way to do this.
Also keep in mind that rounding errors may cause matrices to not
conform to their categories. Otherwise, matrix operations done via
mutliplication will not worsen categories. So for the matrix
multiplication C = A * B, category(C) = MIN (category(A), category(B)).
Members
|
The category of the matrix has not been determined. |
||
|
Analyzing the matrix concluded that it does not fit in any other category. |
||
|
The matrix is a 3D matrix. This means that the w column (the last column) has the values (0, 0, 0, 1). |
||
|
The matrix is a 2D matrix. This is equivalent
to |
||
|
The matrix is a combination of 2D scale and 2D translation operations. In particular, this means that any rectangle can be transformed exactly using this matrix. |
||
|
The matrix is a 2D translation. |
||
|
The matrix is the identity matrix. |
GSK 4 Reference Manual |
|---|
This document is for the GSK 4 library, version 3.99.1 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
- GskRoundedRect — A rounded rectangle
- GskTransform — A description for transform operations
- Index of all symbols
- Annotation Glossary
|
|
|
|
Table of Contents
- GskRenderer — Renders a scene
- GskRenderNode — Simple scene graph element
- GskRoundedRect — A rounded rectangle
- GskTransform — A description for transform operations