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. 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 A render node applying a blending function between its two child nodes. Creates a `GskRenderNode` that will use @blend_mode to blend the @top node onto the @bottom node. A new `GskRenderNode` The bottom node to be drawn The node to be blended onto the @bottom node The blend mode to use Retrieves the blend mode used by @node. the blend mode a blending `GskRenderNode` Retrieves the bottom `GskRenderNode` child of the @node. the bottom child node a blending `GskRenderNode` Retrieves the top `GskRenderNode` child of the @node. the top child node a blending `GskRenderNode` A render node applying a blur effect to its single child. Creates a render node that blurs the child. a new `GskRenderNode` the child node to blur the blur radius. Must be positive Retrieves the child `GskRenderNode` of the blur @node. the blurred child node a blur `GskRenderNode` Retrieves the blur radius of the @node. the blur radius a blur `GskRenderNode` A render node for a border. 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. A new `GskRenderNode` a `GskRoundedRect` describing the outline of the border the stroke width of the border on the top, right, bottom and left side respectively. the color used on the top, right, bottom and left side. Retrieves the colors of the border. an array of 4 `GdkRGBA` structs for the top, right, bottom and left color of the border a `GskRenderNode` for a border Retrieves the outline of the border. the outline of the border a `GskRenderNode` for a border Retrieves the stroke widths of the border. an array of 4 floats for the top, right, bottom and left stroke width of the border, respectively a `GskRenderNode` for a border 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. a new Broadway renderer. A render node for a Cairo surface. Creates a `GskRenderNode` that will render a cairo surface into the area given by @bounds. You can draw to the cairo surface using [method@Gsk.CairoNode.get_draw_context]. A new `GskRenderNode` the rectangle to render to 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. a Cairo context used for drawing; use cairo_destroy() when done drawing a `GskRenderNode` for a Cairo surface Retrieves the Cairo surface used by the render node. a Cairo surface a `GskRenderNode` for a Cairo surface A GSK renderer that is using cairo. Since it is using cairo, this renderer cannot support 3D transformations. 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. a new Cairo renderer. A render node applying a rectangular clip to its single child node. Creates a `GskRenderNode` that will clip the @child to the area given by @clip. A new `GskRenderNode` The node to draw The clip to apply Gets the child node that is getting clipped by the given @node. The child that is getting clipped a clip @GskRenderNode Retrieves the clip rectangle for @node. a clip rectangle a `GskClipNode` A render node controlling the color matrix of its single child node. Creates a `GskRenderNode` that will drawn the @child with @color_matrix. In particular, the node will transform the operation pixel = color_matrix * pixel + color_offset for every pixel. A new `GskRenderNode` The node to draw The matrix to apply Values to add to the color Gets the child node that is getting its colors modified by the given @node. The child that is getting its colors modified a color matrix `GskRenderNode` Retrieves the color matrix used by the @node. a 4x4 color matrix a color matrix `GskRenderNode` Retrieves the color offset used by the @node. a color vector a color matrix `GskRenderNode` A render node for a solid color. Creates a `GskRenderNode` that will render the color specified by @rgba into the area given by @bounds. A new `GskRenderNode` a `GdkRGBA` specifying a color the rectangle to render the color into Retrieves the color of the given @node. the color of the node a `GskRenderNode` A color stop in a gradient node. the offset of the color stop the color at the given offset A render node for a conic gradient. Creates a `GskRenderNode` that draws a conic gradient. The conic gradient starts around @center in the direction of @rotation. A rotation of 0 means that the gradient points up. Color stops are then added clockwise. A new `GskRenderNode` the bounds of the node the center of the gradient the rotation of the gradient in degrees a pointer to an array of `GskColorStop` defining the gradient. The offsets of all color stops must be increasing. The first stop's offset must be >= 0 and the last stop's offset must be <= 1. the number of elements in @color_stops Retrieves the angle for the gradient in radians, normalized in [0, 2 * PI]. The angle is starting at the top and going clockwise, as expressed in the css specification: angle = 90 - gsk_conic_gradient_node_get_rotation() the angle for the gradient a `GskRenderNode` for a conic gradient Retrieves the center pointer for the gradient. the center point for the gradient a `GskRenderNode` for a conic gradient Retrieves the color stops in the gradient. the color stops in the gradient a `GskRenderNode` for a conic gradient the number of color stops in the returned array Retrieves the number of color stops in the gradient. the number of color stops a `GskRenderNode` for a conic gradient Retrieves the rotation for the gradient in degrees. the rotation for the gradient a `GskRenderNode` for a conic gradient A render node that can contain other render nodes. Creates a new `GskRenderNode` instance for holding the given @children. The new node will acquire a reference to each of the children. the new `GskRenderNode` The children of the node Number of children in the @children array Gets one of the children of @container. the @idx'th child of @container a container `GskRenderNode` the position of the child to get Retrieves the number of direct children of @node. the number of children of the `GskRenderNode` a container `GskRenderNode` The corner indices used by `GskRoundedRect`. The top left corner The top right corner The bottom right corner The bottom left corner A render node cross fading between two child nodes. Creates a `GskRenderNode` that will do a cross-fade between @start and @end. A new `GskRenderNode` The start node to be drawn The node to be cross_fadeed onto the @start node How far the fade has progressed from start to end. The value will be clamped to the range [0 ... 1] Retrieves the child `GskRenderNode` at the end of the cross-fade. a `GskRenderNode` a cross-fading `GskRenderNode` Retrieves the progress value of the cross fade. the progress value, between 0 and 1 a cross-fading `GskRenderNode` Retrieves the child `GskRenderNode` at the beginning of the cross-fade. a `GskRenderNode` a cross-fading `GskRenderNode` A render node that emits a debugging message when drawing its child node. Creates a `GskRenderNode` that will add debug information about the given @child. Adding this node has no visual effect. A new `GskRenderNode` The child to add debug info for The debug message Gets the child node that is getting drawn by the given @node. the child `GskRenderNode` a debug `GskRenderNode` Gets the debug message that was set on this node The debug message a debug `GskRenderNode` Creates a new `GskRenderer` using the new OpenGL renderer. a new GL renderer A `GskGLShader` is a snippet of GLSL that is meant to run in the fragment shader of the rendering pipeline. A fragment shader gets the coordinates being rendered as input and produces the pixel values for that particular pixel. Additionally, the shader can declare a set of other input arguments, called uniforms (as they are uniform over all the calls to your shader in each instance of use). A shader can also receive up to 4 textures that it can use as input when producing the pixel data. `GskGLShader` is usually used with gtk_snapshot_push_gl_shader() to produce a [class@Gsk.GLShaderNode] in the rendering hierarchy, and then its input textures are constructed by rendering the child nodes to textures before rendering the shader node itself. (You can pass texture nodes as children if you want to directly use a texture as input). The actual shader code is GLSL code that gets combined with some other code into the fragment shader. Since the exact capabilities of the GPU driver differs between different OpenGL drivers and hardware, GTK adds some defines that you can use to ensure your GLSL code runs on as many drivers as it can. If the OpenGL driver is GLES, then the shader language version is set to 100, and GSK_GLES will be defined in the shader. Otherwise, if the OpenGL driver does not support the 3.2 core profile, then the shader will run with language version 110 for GL2 and 130 for GL3, and GSK_LEGACY will be defined in the shader. If the OpenGL driver supports the 3.2 code profile, it will be used, the shader language version is set to 150, and GSK_GL3 will be defined in the shader. The main function the shader must implement is: ```glsl void mainImage(out vec4 fragColor, in vec2 fragCoord, in vec2 resolution, in vec2 uv) ``` Where the input @fragCoord is the coordinate of the pixel we're currently rendering, relative to the boundary rectangle that was specified in the `GskGLShaderNode`, and @resolution is the width and height of that rectangle. This is in the typical GTK coordinate system with the origin in the top left. @uv contains the u and v coordinates that can be used to index a texture at the corresponding point. These coordinates are in the [0..1]x[0..1] region, with 0, 0 being in the lower left corder (which is typical for OpenGL). The output @fragColor should be a RGBA color (with premultiplied alpha) that will be used as the output for the specified pixel location. Note that this output will be automatically clipped to the clip region of the glshader node. In addition to the function arguments the shader can define up to 4 uniforms for textures which must be called u_textureN (i.e. u_texture1 to u_texture4) as well as any custom uniforms you want of types int, uint, bool, float, vec2, vec3 or vec4. All textures sources contain premultiplied alpha colors, but if some there are outer sources of colors there is a gsk_premultiply() helper to compute premultiplication when needed. Note that GTK parses the uniform declarations, so each uniform has to be on a line by itself with no other code, like so: ```glsl uniform float u_time; uniform vec3 u_color; uniform sampler2D u_texture1; uniform sampler2D u_texture2; ``` GTK uses the "gsk" namespace in the symbols it uses in the shader, so your code should not use any symbols with the prefix gsk or GSK. There are some helper functions declared that you can use: ```glsl vec4 GskTexture(sampler2D sampler, vec2 texCoords); ``` This samples a texture (e.g. u_texture1) at the specified coordinates, and containes some helper ifdefs to ensure that it works on all OpenGL versions. You can compile the shader yourself using [method@Gsk.GLShader.compile], otherwise the GSK renderer will do it when it handling the glshader node. If errors occurs, the returned @error will include the glsl sources, so you can see what GSK was passing to the compiler. You can also set GSK_DEBUG=shaders in the environment to see the sources and other relevant information about all shaders that GSK is handling. # An example shader ```glsl uniform float position; uniform sampler2D u_texture1; uniform sampler2D u_texture2; void mainImage(out vec4 fragColor, in vec2 fragCoord, in vec2 resolution, in vec2 uv) { vec4 source1 = GskTexture(u_texture1, uv); vec4 source2 = GskTexture(u_texture2, uv); fragColor = position * source1 + (1.0 - position) * source2; } ``` Creates a `GskGLShader` that will render pixels using the specified code. A new `GskGLShader` GLSL sourcecode for the shader, as a `GBytes` Creates a `GskGLShader` that will render pixels using the specified code. A new `GskGLShader` path to a resource that contains the GLSL sourcecode for the shader Tries to compile the @shader for the given @renderer. If there is a problem, this function returns %FALSE and reports an error. You should use this function before relying on the shader for rendering and use a fallback with a simpler shader or without shaders if it fails. Note that this will modify the rendering state (for example change the current GL context) and requires the renderer to be set up. This means that the widget has to be realized. Commonly you want to call this from the realize signal of a widget, or during widget snapshot. %TRUE on success, %FALSE if an error occurred a `GskGLShader` a `GskRenderer` Looks for a uniform by the name @name, and returns the index of the uniform, or -1 if it was not found. The index of the uniform, or -1 a `GskGLShader` uniform name Formats the uniform data as needed for feeding the named uniforms values into the shader. The argument list is a list of pairs of names, and values for the types that match the declared uniforms (i.e. double/int/guint/gboolean for primitive values and `graphene_vecN_t *` for vecN uniforms). Any uniforms of the shader that are not included in the argument list are zero-initialized. A newly allocated block of data which can be passed to [ctor@Gsk.GLShaderNode.new]. a `GskGLShader` name-Value pairs for the uniforms of @shader, ending with a %NULL name Formats the uniform data as needed for feeding the named uniforms values into the shader. The argument list is a list of pairs of names, and values for the types that match the declared uniforms (i.e. double/int/guint/gboolean for primitive values and `graphene_vecN_t *` for vecN uniforms). It is an error to pass a uniform name that is not declared by the shader. Any uniforms of the shader that are not included in the argument list are zero-initialized. A newly allocated block of data which can be passed to [ctor@Gsk.GLShaderNode.new]. a `GskGLShader` name-Value pairs for the uniforms of @shader, ending with a %NULL name Gets the value of the uniform @idx in the @args block. The uniform must be of bool type. The value a `GskGLShader` uniform arguments index of the uniform Gets the value of the uniform @idx in the @args block. The uniform must be of float type. The value a `GskGLShader` uniform arguments index of the uniform Gets the value of the uniform @idx in the @args block. The uniform must be of int type. The value a `GskGLShader` uniform arguments index of the uniform Gets the value of the uniform @idx in the @args block. The uniform must be of uint type. The value a `GskGLShader` uniform arguments index of the uniform Gets the value of the uniform @idx in the @args block. The uniform must be of vec2 type. a `GskGLShader` uniform arguments index of the uniform location to store the uniform value in Gets the value of the uniform @idx in the @args block. The uniform must be of vec3 type. a `GskGLShader` uniform arguments index of the uniform location to store the uniform value in Gets the value of the uniform @idx in the @args block. The uniform must be of vec4 type. a `GskGLShader` uniform arguments index of the uniform location to store set the uniform value in Get the size of the data block used to specify arguments for this shader. The size of the data block a `GskGLShader` Returns the number of textures that the shader requires. This can be used to check that the a passed shader works in your usecase. It is determined by looking at the highest u_textureN value that the shader defines. The number of texture inputs required by @shader a `GskGLShader` Get the number of declared uniforms for this shader. The number of declared uniforms a `GskGLShader` Gets the resource path for the GLSL sourcecode being used to render this shader. The resource path for the shader a `GskGLShader` Gets the GLSL sourcecode being used to render this shader. The source code for the shader a `GskGLShader` Get the name of the declared uniform for this shader at index @idx. The name of the declared uniform a `GskGLShader` index of the uniform Get the offset into the data block where data for this uniforms is stored. The data offset a `GskGLShader` index of the uniform Get the type of the declared uniform for this shader at index @idx. The type of the declared uniform a `GskGLShader` index of the uniform Resource containing the source code for the shader. If the shader source is not coming from a resource, this will be %NULL. A render node using a GL shader when drawing its children nodes. Creates a `GskRenderNode` that will render the given @shader into the area given by @bounds. The @args is a block of data to use for uniform input, as per types and offsets defined by the @shader. Normally this is generated by [method@Gsk.GLShader.format_args] or [struct@Gsk.ShaderArgsBuilder]. See [class@Gsk.GLShader] for details about how the shader should be written. All the children will be rendered into textures (if they aren't already `GskTextureNodes`, which will be used directly). These textures will be sent as input to the shader. If the renderer doesn't support GL shaders, or if there is any problem when compiling the shader, then the node will draw pink. You should use [method@Gsk.GLShader.compile] to ensure the @shader will work for the renderer before using it. A new `GskRenderNode` the `GskGLShader` the rectangle to render the shader into Arguments for the uniforms array of child nodes, these will be rendered to textures and used as input. Length of @children (currenly the GL backend supports up to 4 children) Gets args for the node. A `GBytes` with the uniform arguments a `GskRenderNode` for a gl shader Gets one of the children. the @idx'th child of @node a `GskRenderNode` for a gl shader the position of the child to get Returns the number of children The number of children a `GskRenderNode` for a gl shader Gets shader code for the node. the `GskGLShader` shader a `GskRenderNode` for a gl shader This defines the types of the uniforms that `GskGLShaders` declare. It defines both what the type is called in the GLSL shader code, and what the corresponding C type is on the Gtk side. No type, used for uninitialized or unspecified values. A float uniform A GLSL int / gint32 uniform A GLSL uint / guint32 uniform A GLSL bool / gboolean uniform A GLSL vec2 / graphene_vec2_t uniform A GLSL vec3 / graphene_vec3_t uniform A GLSL vec4 / graphene_vec4_t uniform A render node for an inset shadow. Creates a `GskRenderNode` that will render an inset shadow into the box given by @outline. A new `GskRenderNode` outline of the region containing the shadow color of the shadow horizontal offset of shadow vertical offset of shadow how far the shadow spreads towards the inside how much blur to apply to the shadow Retrieves the blur radius to apply to the shadow. the blur radius, in pixels a `GskRenderNode` for an inset shadow Retrieves the color of the inset shadow. the color of the shadow a `GskRenderNode` for an inset shadow Retrieves the horizontal offset of the inset shadow. an offset, in pixels a `GskRenderNode` for an inset shadow Retrieves the vertical offset of the inset shadow. an offset, in pixels a `GskRenderNode` for an inset shadow Retrieves the outline rectangle of the inset shadow. a rounded rectangle a `GskRenderNode` for an inset shadow Retrieves how much the shadow spreads inwards. the size of the shadow, in pixels a `GskRenderNode` for an inset shadow A render node for a linear gradient. 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. A new `GskRenderNode` the rectangle to render the linear gradient into the point at which the linear gradient will begin the point at which the linear gradient will finish a pointer to an array of `GskColorStop` defining the gradient. The offsets of all color stops must be increasing. The first stop's offset must be >= 0 and the last stop's offset must be <= 1. the number of elements in @color_stops Retrieves the color stops in the gradient. the color stops in the gradient a `GskRenderNode` for a linear gradient the number of color stops in the returned array Retrieves the final point of the linear gradient. the final point a `GskRenderNode` for a linear gradient Retrieves the number of color stops in the gradient. the number of color stops a `GskRenderNode` for a linear gradient Retrieves the initial point of the linear gradient. the initial point a `GskRenderNode` for a linear gradient Same as gsk_gl_renderer_new(). Use gsk_gl_renderer_new() a new GL renderer A render node controlling the opacity of its single child node. Creates a `GskRenderNode` that will drawn the @child with reduced @opacity. A new `GskRenderNode` The node to draw The opacity to apply Gets the child node that is getting opacityed by the given @node. The child that is getting opacityed a `GskRenderNode` for an opacity Gets the transparency factor for an opacity node. the opacity factor a `GskRenderNode` for an opacity A render node for an outset shadow. Creates a `GskRenderNode` that will render an outset shadow around the box given by @outline. A new `GskRenderNode` outline of the region surrounded by shadow color of the shadow horizontal offset of shadow vertical offset of shadow how far the shadow spreads towards the inside how much blur to apply to the shadow Retrieves the blur radius of the shadow. the blur radius, in pixels a `GskRenderNode` for an outset shadow Retrieves the color of the outset shadow. a color a `GskRenderNode` for an outset shadow Retrieves the horizontal offset of the outset shadow. an offset, in pixels a `GskRenderNode` for an outset shadow Retrieves the vertical offset of the outset shadow. an offset, in pixels a `GskRenderNode` for an outset shadow Retrieves the outline rectangle of the outset shadow. a rounded rectangle a `GskRenderNode` for an outset shadow Retrieves how much the shadow spreads outwards. the size of the shadow, in pixels a `GskRenderNode` for an outset shadow Type of callback that is called when an error occurs during node deserialization. start of the error location end of the error location the error user data A location in a parse buffer. the offset of the location in the parse buffer, as bytes the offset of the location in the parse buffer, as characters the line of the location in the parse buffer the position in the line, as bytes the position in the line, as characters Initializes a `GskRoundedRect` when declaring it. All corner sizes will be initialized to 0. the X coordinate of the origin the Y coordinate of the origin the width the height A render node for a radial gradient. Creates a `GskRenderNode` that draws a radial gradient. The radial gradient starts around @center. The size of the gradient is dictated by @hradius in horizontal orientation and by @vradius in vertial orientation. A new `GskRenderNode` the bounds of the node the center of the gradient the horizontal radius the vertical radius a percentage >= 0 that defines the start of the gradient around @center a percentage >= 0 that defines the end of the gradient around @center a pointer to an array of `GskColorStop` defining the gradient. The offsets of all color stops must be increasing. The first stop's offset must be >= 0 and the last stop's offset must be <= 1. the number of elements in @color_stops Retrieves the center pointer for the gradient. the center point for the gradient a `GskRenderNode` for a radial gradient Retrieves the color stops in the gradient. the color stops in the gradient a `GskRenderNode` for a radial gradient the number of color stops in the returned array Retrieves the end value for the gradient. the end value for the gradient a `GskRenderNode` for a radial gradient Retrieves the horizonal radius for the gradient. the horizontal radius for the gradient a `GskRenderNode` for a radial gradient Retrieves the number of color stops in the gradient. the number of color stops a `GskRenderNode` for a radial gradient Retrieves the start value for the gradient. the start value for the gradient a `GskRenderNode` for a radial gradient Retrieves the vertical radius for the gradient. the vertical radius for the gradient a `GskRenderNode` for a radial gradient `GskRenderNode` is the basic block in a scene graph to be rendered using [class@Gsk.Renderer]. 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 when creating it. Render nodes are meant to be transient; once they have been associated to a [class@Gsk.Renderer] it's safe to release any reference you have on them. All [class@Gsk.RenderNode]s are immutable, you can only specify their properties during construction. Loads data previously created via [method@Gsk.RenderNode.serialize]. For a discussion of the supported format, see that function. a new `GskRenderNode` the bytes containing the data Callback on parsing errors user_data for @error_func Draw the contents of @node to the given cairo context. Typically, you'll use this function to implement fallback rendering of `GskRenderNode`s on an intermediate Cairo context, instead of using the drawing context associated to a [class@Gdk.Surface]'s rendering buffer. For advanced nodes that cannot be supported using Cairo, in particular for nodes doing 3D operations, this function may fail. a `GskRenderNode` cairo context to draw to Retrieves the boundaries of the @node. The node will not draw outside of its boundaries. a `GskRenderNode` return location for the boundaries Returns the type of the @node. the type of the `GskRenderNode` a `GskRenderNode` Acquires a reference on the given `GskRenderNode`. the `GskRenderNode` with an additional reference a `GskRenderNode` 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. a `GBytes` representing the node. a `GskRenderNode` Releases a reference on the given `GskRenderNode`. If the reference was the last, the resources associated to the @node are freed. a `GskRenderNode` This function is equivalent to calling [method@Gsk.RenderNode.serialize] followed by [func@GLib.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. %TRUE if saving was successful a `GskRenderNode` the file to save it to. The type of a node determines what the node is rendering. 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 drawing a radial gradient A node drawing a repeating radial gradient A node drawing a conic 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 A node that uses OpenGL fragment shaders to render `GskRenderer` is a class that renders a scene graph defined via a tree of [class@Gsk.RenderNode] instances. Typically you will use a `GskRenderer` instance to repeatedly call [method@Gsk.Renderer.render] to update the contents of its associated [class@Gdk.Surface]. It is necessary to realize a `GskRenderer` instance using [method@Gsk.Renderer.realize] before calling [method@Gsk.Renderer.render], in order to create the appropriate windowing system resources needed to render the scene. Creates an appropriate `GskRenderer` instance for the given @surface. If the `GSK_RENDERER` environment variable is set, GSK will try that renderer first, before trying the backend-specific default. The ultimate fallback is the cairo renderer. The renderer will be realized before it is returned. a `GskRenderer` a `GdkSurface` Retrieves the `GdkSurface` set using gsk_enderer_realize(). If the renderer has not been realized yet, %NULL will be returned. a `GdkSurface` a `GskRenderer` Checks whether the @renderer is realized or not. %TRUE if the `GskRenderer` was realized, and %FALSE otherwise a `GskRenderer` Creates the resources needed by the @renderer to render the scene graph. Since GTK 4.6, the surface may be `NULL`, which allows using renderers without having to create a surface. Note that it is mandatory to call [method@Gsk.Renderer.unrealize] before destroying the renderer. Whether the renderer was successfully realized a `GskRenderer` the `GdkSurface` renderer will be used on Renders the scene graph, described by a tree of `GskRenderNode` instances to the renderer's surface, ensuring that the given @region gets redrawn. If the renderer has no associated surface, this function does nothing. 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. a realized `GskRenderer` a `GskRenderNode` the `cairo_region_t` that must be redrawn or %NULL for the whole window 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. a `GdkTexture` with the rendered contents of @root. a realized `GskRenderer` a `GskRenderNode` the section to draw or %NULL to use @root's bounds Releases all the resources created by gsk_renderer_realize(). a `GskRenderer` Whether the renderer has been associated with a surface or draw context. The surface associated with renderer. A render node repeating its single child node. Creates a `GskRenderNode` that will repeat the drawing of @child across the given @bounds. A new `GskRenderNode` The bounds of the area to be painted The child to repeat The area of the child to repeat or %NULL to use the child's bounds Retrieves the child of @node. a `GskRenderNode` a repeat `GskRenderNode` Retrieves the bounding rectangle of the child of @node. a bounding rectangle a repeat `GskRenderNode` A render node for a repeating linear gradient. 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. A new `GskRenderNode` the rectangle to render the linear gradient into the point at which the linear gradient will begin the point at which the linear gradient will finish a pointer to an array of `GskColorStop` defining the gradient. The offsets of all color stops must be increasing. The first stop's offset must be >= 0 and the last stop's offset must be <= 1. the number of elements in @color_stops A render node for a repeating radial gradient. Creates a `GskRenderNode` that draws a repeating radial gradient. The radial gradient starts around @center. The size of the gradient is dictated by @hradius in horizontal orientation and by @vradius in vertial orientation. A new `GskRenderNode` the bounds of the node the center of the gradient the horizontal radius the vertical radius a percentage >= 0 that defines the start of the gradient around @center a percentage >= 0 that defines the end of the gradient around @center a pointer to an array of `GskColorStop` defining the gradient. The offsets of all color stops must be increasing. The first stop's offset must be >= 0 and the last stop's offset must be <= 1. the number of elements in @color_stops A render node applying a rounded rectangle clip to its single child. Creates a `GskRenderNode` that will clip the @child to the area given by @clip. A new `GskRenderNode` The node to draw The clip to apply Gets the child node that is getting clipped by the given @node. The child that is getting clipped a rounded clip `GskRenderNode` Retrieves the rounded rectangle used to clip the contents of the @node. a rounded rectangle a rounded clip `GskRenderNode` A rectangular region with rounded corners. Application code should normalize rectangles using [method@Gsk.RoundedRect.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. The algorithm used for normalizing corner sizes is described in [the CSS specification](https://drafts.csswg.org/css-backgrounds-3/#border-radius). the bounds of the rectangle the size of the 4 rounded corners Checks if the given @point is inside the rounded rectangle. %TRUE if the @point is inside the rounded rectangle a `GskRoundedRect` the point to check Checks if the given @rect is contained inside the rounded rectangle. %TRUE if the @rect is fully contained inside the rounded rectangle a `GskRoundedRect` the rectangle to check Initializes the given `GskRoundedRect` with the given values. This function will implicitly normalize the `GskRoundedRect` before returning. the initialized rectangle The `GskRoundedRect` to initialize a `graphene_rect_t` describing the bounds the rounding radius of the top left corner the rounding radius of the top right corner the rounding radius of the bottom right corner the rounding radius of the bottom left corner Initializes @self using the given @src rectangle. This function will not normalize the `GskRoundedRect`, so make sure the source is normalized. the initialized rectangle a `GskRoundedRect` a `GskRoundedRect` Initializes @self to the given @bounds and sets the radius of all four corners to @radius. the initialized rectangle a `GskRoundedRect` a `graphene_rect_t` the border radius Checks if part of the given @rect is contained inside the rounded rectangle. %TRUE if the @rect intersects with the rounded rectangle a `GskRoundedRect` the rectangle to check 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 [ctor@Gsk.ClipNode.new] or [ctor@Gsk.RoundedClipNode.new] should be called. %TRUE if the rectangle is rectilinear the `GskRoundedRect` to check 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. the normalized rectangle a `GskRoundedRect` Offsets the bound's origin by @dx and @dy. The size and corners of the rectangle are unchanged. the offset rectangle a `GskRoundedRect` the horizontal offset the vertical offset 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. the resized `GskRoundedRect` The `GskRoundedRect` to shrink or grow How far to move the top side downwards How far to move the right side to the left How far to move the bottom side upwards How far to move the left side to the right The filters used when scaling texture data. The actual implementation of each filter is deferred to the rendering pipeline. linear interpolation filter nearest neighbor interpolation filter linear interpolation along each axis, plus mipmap generation, with linear interpolation along the mipmap levels Errors that can happen during (de)serialization. The format can not be identified The version of the data is not understood The given data may not exist in a proper serialization An object to build the uniforms data for a `GskGLShader`. Allocates a builder that can be used to construct a new uniform data chunk. The newly allocated builder, free with [method@Gsk.ShaderArgsBuilder.unref] a `GskGLShader` optional `GBytes` with initial values Creates a new `GBytes` args from the current state of the given @builder, and frees the @builder instance. Any uniforms of the shader that have not been explicitly set on the @builder are zero-initialized. the newly allocated buffer with all the args added to @builder a `GskShaderArgsBuilder` Increases the reference count of a `GskShaderArgsBuilder` by one. the passed in `GskShaderArgsBuilder` a `GskShaderArgsBuilder` Sets the value of the uniform @idx. The uniform must be of bool type. a `GskShaderArgsBuilder` index of the uniform value to set the uniform to Sets the value of the uniform @idx. The uniform must be of float type. a `GskShaderArgsBuilder` index of the uniform value to set the uniform to Sets the value of the uniform @idx. The uniform must be of int type. a `GskShaderArgsBuilder` index of the uniform value to set the uniform to Sets the value of the uniform @idx. The uniform must be of uint type. a `GskShaderArgsBuilder` index of the uniform value to set the uniform to Sets the value of the uniform @idx. The uniform must be of vec2 type. A `GskShaderArgsBuilder` index of the uniform value to set the uniform too Sets the value of the uniform @idx. The uniform must be of vec3 type. a `GskShaderArgsBuilder` index of the uniform value to set the uniform too Sets the value of the uniform @idx. The uniform must be of vec4 type. a `GskShaderArgsBuilder` index of the uniform value to set the uniform too Creates a new `GBytes` args from the current state of the given @builder. Any uniforms of the shader that have not been explicitly set on the @builder are zero-initialized. The given `GskShaderArgsBuilder` is reset once this function returns; you cannot call this function multiple times on the same @builder instance. This function is intended primarily for bindings. C code should use [method@Gsk.ShaderArgsBuilder.free_to_args]. the newly allocated buffer with all the args added to @builder a `GskShaderArgsBuilder` Decreases the reference count of a `GskShaderArgBuilder` by one. If the resulting reference count is zero, frees the builder. a `GskShaderArgsBuilder` The shadow parameters in a shadow node. the color of the shadow the horizontal offset of the shadow the vertical offset of the shadow the radius of the shadow A render node drawing one or more shadows behind its single child node. Creates a `GskRenderNode` that will draw a @child with the given @shadows below it. A new `GskRenderNode` The node to draw The shadows to apply number of entries in the @shadows array Retrieves the child `GskRenderNode` of the shadow @node. the child render node a shadow `GskRenderNode` Retrieves the number of shadows in the @node. the number of shadows. a shadow `GskRenderNode` Retrieves the shadow data at the given index @i. the shadow data a shadow `GskRenderNode` the given index A render node drawing a set of glyphs. Creates a render node that renders the given glyphs. Note that @color may not be used if the font contains color glyphs. a new `GskRenderNode` the `PangoFont` containing the glyphs the `PangoGlyphString` to render the foreground color to render with offset of the baseline Retrieves the color used by the text @node. the text color a text `GskRenderNode` Returns the font used by the text @node. the font The `GskRenderNode` Retrieves the glyph information in the @node. the glyph information a text `GskRenderNode` the number of glyphs returned Retrieves the number of glyphs in the text node. the number of glyphs a text `GskRenderNode` Retrieves the offset applied to the text. a point with the horizontal and vertical offsets a text `GskRenderNode` Checks whether the text @node has color glyphs. %TRUE if the text node has color glyphs a text `GskRenderNode` A render node for a `GdkTexture`. Creates a `GskRenderNode` that will render the given @texture into the area given by @bounds. A new `GskRenderNode` the `GdkTexture` the rectangle to render the texture into Retrieves the `GdkTexture` used when creating this `GskRenderNode`. the `GdkTexture` a `GskRenderNode` of type %GSK_TEXTURE_NODE `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. Checks two transforms for equality. %TRUE if the two transforms perform the same operation the first transform the second transform Returns the category this transform belongs to. The category of the transform A `GskTransform` 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. The inverted transform Transform to invert Multiplies @next with the given @matrix. The new transform the next transform the matrix to multiply @next with 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. The new transform the next transform distance of the z=0 plane. Lower values give a more flattened pyramid and therefore a more pronounced perspective effect. Converts @self into a human-readable string representation suitable for printing. The result of this function can later be parsed with [func@Gsk.Transform.parse]. a `GskTransform` The string to print into Acquires a reference on the given `GskTransform`. the `GskTransform` with an additional reference a `GskTransform` Rotates @next @angle degrees in 2D - or in 3D-speak, around the z axis. The new transform the next transform the rotation angle, in degrees (clockwise) Rotates @next @angle degrees around @axis. For a rotation in 2D space, use [method@Gsk.Transform.rotate] The new transform the next transform the rotation angle, in degrees (clockwise) The rotation axis Scales @next in 2-dimensional space by the given factors. Use [method@Gsk.Transform.scale_3d] to scale in all 3 dimensions. The new transform the next transform scaling factor on the X axis scaling factor on the Y axis Scales @next by the given factors. The new transform the next transform scaling factor on the X axis scaling factor on the Y axis scaling factor on the Z axis Applies a skew transform. The new transform the next transform skew factor, in degrees, on the X axis skew factor, in degrees, on the Y axis 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: ``` | 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. a 2D `GskTransform` return location for the xx member return location for the yx member return location for the xy member return location for the yy member return location for the x0 member return location for the y0 member Converts a `GskTransform` to 2D transformation factors. To recreate an equivalent transform from the factors returned by this function, use gsk_transform_skew ( gsk_transform_scale ( gsk_transform_rotate ( gsk_transform_translate (NULL, &GRAPHENE_POINT_T (dx, dy)), angle), scale_x, scale_y), skew_x, skew_y) @self must be a 2D transformation. If you are not sure, use gsk_transform_get_category() >= %GSK_TRANSFORM_CATEGORY_2D to check. a `GskTransform` return location for the skew factor in the x direction return location for the skew factor in the y direction return location for the scale factor in the x direction return location for the scale factor in the y direction return location for the rotation angle return location for the translation in the x direction return location for the translation in the y direction Converts a `GskTransform` to 2D affine transformation factors. To recreate an equivalent transform from the factors returned by this function, use gsk_transform_scale (gsk_transform_translate (NULL, &GRAPHENE_POINT_T (dx, dy)), sx, sy) @self must be a 2D affine transformation. If you are not sure, use gsk_transform_get_category() >= %GSK_TRANSFORM_CATEGORY_2D_AFFINE to check. a `GskTransform` return location for the scale factor in the x direction return location for the scale factor in the y direction return location for the translation in the x direction return location for the translation in the y direction Computes the actual value of @self and stores it in @out_matrix. The previous value of @out_matrix will be ignored. a `GskTransform` The matrix to set Converts a matrix into a string that is suitable for printing. The resulting string can be parsed with [func@Gsk.Transform.parse]. This is a wrapper around [method@Gsk.Transform.print]. A new string for @self a `GskTransform` 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. a `GskTransform` return location for the translation in the x direction return location for the translation in the y direction Applies all the operations from @other to @next. The new transform Transform to apply @other to Transform to apply Transforms a `graphene_rect_t` using the given transform @self. The result is the bounding box containing the coplanar quad. a `GskTransform` a `graphene_rect_t` return location for the bounds of the transformed rectangle Transforms a `graphene_point_t` using the given transform @self. a `GskTransform` a `graphene_point_t` return location for the transformed point Translates @next in 2-dimensional space by @point. The new transform the next transform the point to translate the transform by Translates @next by @point. The new transform the next transform the point to translate the transform by Releases a reference on the given `GskTransform`. If the reference was the last, the resources associated to the @self are freed. a `GskTransform` Parses the given @string into a transform and puts it in @out_transform. Strings printed via [method@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. %TRUE if @string described a valid transform. the string to parse The location to put the transform in 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 multiplication will not worsen categories. So for the matrix multiplication `C = A * B`, `category(C) = MIN (category(A), category(B))`. 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 graphene_matrix_is_2d() returning %TRUE. In particular, this means that Cairo can deal with the matrix. 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. A render node applying a `GskTransform` to its single child node. Creates a `GskRenderNode` that will transform the given @child with the given @transform. A new `GskRenderNode` The node to transform The transform to apply Gets the child node that is getting transformed by the given @node. The child that is getting transformed a `GskRenderNode` for a transform Retrieves the `GskTransform` used by the @node. a `GskTransform` a `GskRenderNode` for a transform Evaluates to %TRUE if @value was initialized with %GSK_TYPE_RENDER_NODE. a `GValue` Parses the given @string into a transform and puts it in @out_transform. Strings printed via [method@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. %TRUE if @string described a valid transform. the string to parse The location to put the transform in Retrieves the `GskRenderNode` stored inside the given `value`, and acquires a reference to it. a `GskRenderNode` a [struct@GObject.Value] initialized with type `GSK_TYPE_RENDER_NODE` Retrieves the `GskRenderNode` stored inside the given `value`. a `GskRenderNode` a `GValue` initialized with type `GSK_TYPE_RENDER_NODE` Stores the given `GskRenderNode` inside `value`. The [struct@GObject.Value] will acquire a reference to the `node`. a [struct@GObject.Value] initialized with type `GSK_TYPE_RENDER_NODE` a `GskRenderNode` Stores the given `GskRenderNode` inside `value`. This function transfers the ownership of the `node` to the `GValue`. a [struct@GObject.Value] initialized with type `GSK_TYPE_RENDER_NODE` a `GskRenderNode`