| 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.
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,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.
Parameters
bytes |
the bytes containing the data |
 |
error |
location to store error or |
[allow-none] |
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_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_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);
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 |
 |
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);
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_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_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 ()
const 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.
Parameters
children |
The children of the node. |
[array length=n_children][transfer none] |
n_children |
Number of children in the |
 |
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,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_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
.
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] |
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_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.
Parameters
child |
The node to draw |
 |
shadows |
The shadows to apply. |
[array length=n_shadows] |
n_shadows |
number of entries in the |
 |
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.
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_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_text_node_new ()
GskRenderNode * gsk_text_node_new (PangoFont *font,PangoGlyphString *glyphs,const GdkRGBA *color,float x,float 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 |
 |
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.
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
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 |
 | |
| Â | Â |
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.
| 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_matrix_with_category () |
| 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 () |
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 | | x0 y0 | | 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
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
.
Parameters
next |
Transform to apply |
[allow-none][transfer full] |
other |
Transform to apply. |
[allow-none] |
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_matrix_with_category ()
GskTransform * gsk_transform_matrix_with_category (GskTransform *next,const graphene_matrix_t *matrix,GskTransformCategory category);
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().
Parameters
next |
the next transform. |
[allow-none] |
angle |
the rotation angle, in degrees (clockwise) |
 |
axis |
The rotation axis |
 |
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.
Parameters
next |
the next transform. |
[allow-none] |
factor_x |
scaling factor on the X axis |
 |
factor_y |
scaling factor on the Y axis |
 |
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.
Parameters
next |
the next transform. |
[allow-none] |
factor_x |
scaling factor on the X axis |
 |
factor_y |
scaling factor on the Y axis |
 |
factor_z |
scaling factor on the Z axis |
 |
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.
Parameters
next |
the next transform. |
[allow-none] |
depth |
distance of the z=0 plane. Lower values give a more flattened pyramid and therefore a more pronounced perspective effect. |
 |
gsk_transform_equal ()
gboolean gsk_transform_equal (GskTransform *first,GskTransform *second);
Checks two matrices for equality. Note that matrices need to be literally
identical in their operations, it is not enough that they return the
same result in gsk_transform_to_matrix().
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 matrix m
. The
result is the bounding box containing the coplanar quad.
Parameters
self |
 | |
rect |
a graphene_rect_t |
 |
out_rect |
return location for the bounds of the transformed rectangle. |
[out caller-allocates] |
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.96.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
- GskRoundedRect — A rounded rectangle
- GskTransform — A description for transform operations
- Index of all symbols
|
 |
|
 |
B
C
D
G
I
L
O
R
S
T
V
| 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 GdkRenderer |
 |
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 gdk_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.
Flags: Read
Default value: FALSE
The “surface†property
“surface†GdkSurface *
The surface associated to the renderer.
Flags: Read
|
|
|
|
Table of Contents
- GskRenderer — Renders a scene
- GskRenderNode — Simple scene graph element
- GskRoundedRect — A rounded rectangle
- GskTransform — A description for transform operations
| 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 rectanlge 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 rectanlge 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.