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 A Broadway based renderer. See [class@Gsk.Renderer]. 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. Broadway will be retired in GTK 5 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 Renders a GSK rendernode tree with 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 colors by applying pixel = transpose(color_matrix) * pixel + color_offset for every pixel. The transformation operates on unpremultiplied colors, with color components ordered R, G, B, A. 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 value returned by this function will not be correct if the render node was created for a non-sRGB color. 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 Specifies a transfer function for a color component to be applied while rendering. The available functions include linear, piecewise-linear, gamma and step functions. Note that the transfer function is applied to un-premultiplied values, and all results are clamped to the [0, 1] range. Creates a new component transfer that applies a step function. The new value is computed as C' = values[k] where k is the smallest value such that k / n <= C < (k + 1) / n <figure> <picture> <source srcset="discrete-dark.png" media="(prefers-color-scheme: dark)"> <img alt="Component transfer: discrete" src="discrete-light.png"> </picture> </figure> a new `GskComponentTransfer` Number of values Values Creates a new component transfer that applies a gamma transform. The new value is computed as C' = amp * pow (C, exp) + ofs <figure> <picture> <source srcset="gamma-dark.png" media="(prefers-color-scheme: dark)"> <img alt="Component transfer: gamma" src="gamma-light.png"> </picture> </figure> a new `GskComponentTransfer` Amplitude Exponent Offset Creates a new component transfer that doesn't change the component value. <figure> <picture> <source srcset="identity-dark.png" media="(prefers-color-scheme: dark)"> <img alt="Component transfer: identity" src="identity-light.png"> </picture> </figure> a new `GskComponentTransfer` Creates a new component transfer that limits the values of the component to `n` levels. The new value is computed as C' = (floor (C * n) + 0.5) / n <figure> <picture> <source srcset="levels-dark.png" media="(prefers-color-scheme: dark)"> <img alt="Component transfer: levels" src="levels-light.png"> </picture> </figure> a new `GskComponentTransfer` Number of levels Creates a new component transfer that applies a linear transform. The new value is computed as C' = C * m + b <figure> <picture> <source srcset="linear-dark.png" media="(prefers-color-scheme: dark)"> <img alt="Component transfer: linear" src="linear-light.png"> </picture> </figure> a new `GskComponentTransfer` Slope Offset Creates a new component transfer that applies a piecewise linear function. The new value is computed as C' = values[k] + (C - k / (n - 1)) * n * (values[k + 1] - values[k]) where k is the smallest value such that k / (n - 1) <= C < (k + 1) / (n - 1) <figure> <picture> <source srcset="table-dark.png" media="(prefers-color-scheme: dark)"> <img alt="Component transfer: table" src="table-light.png"> </picture> </figure> a new `GskComponentTransfer` Number of values Values Creates a copy of @other. a newly allocated copy of @other a component transfer Frees a component transfer. a component transfer Compares two component transfers for equality. true if @self and @other are equal a component transfer another component transfer Creates a render node that will apply component transfers to a child node. A new `GskRenderNode` The child to apply component transfers to transfer for the red component transfer for the green component transfer for the blue component transfer for the alpha component Gets the child node that is getting drawn by the given @node. the child `GskRenderNode` a component transfer `GskRenderNode` Gets the component transfer for one of the components. the `GskComponentTransfer` a component transfer `GskRenderNode` a value between 0 and 3 to indicate the red, green, blue or alpha component 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` A render node filling the area given by [struct@Gsk.Path] and [enum@Gsk.FillRule] with the child node. Creates a `GskRenderNode` that will fill the @child in the area given by @path and @fill_rule. A new `GskRenderNode` The node to fill the area with The path describing the area to fill The fill rule to use Gets the child node that is getting drawn by the given @node. The child that is getting drawn a fill `GskRenderNode` Retrieves the fill rule used to determine how the path is filled. a `GskFillRule` a fill `GskRenderNode` Retrieves the path used to describe the area filled with the contents of the @node. a `GskPath` a fill `GskRenderNode` Specifies how paths are filled. Whether or not a point is included in the fill is determined by taking a ray from that point to infinity and looking at intersections with the path. The ray can be in any direction, as long as it doesn't pass through the end point of a segment or have a tricky intersection such as intersecting tangent to the path. (Note that filling is not actually implemented in this way. This is just a description of the rule that is applied.) New entries may be added in future versions. If the path crosses the ray from left-to-right, counts +1. If the path crosses the ray from right to left, counts -1. (Left and right are determined from the perspective of looking along the ray from the starting point.) If the total count is non-zero, the point will be filled. Counts the total number of intersections, without regard to the orientation of the contour. If the total number of intersections is odd, the point will be filled. Renders a GSK rendernode tree with OpenGL. See [class@Gsk.Renderer]. Creates an instance of the GL renderer. a GL renderer Implements a fragment shader using GLSL. 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 contains 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; } ``` This feature was deprecated in GTK 4.16 after the new rendering infrastructure introduced in 4.14 did not support it. The lack of Vulkan integration would have made it a very hard feature to support. If you want to use OpenGL directly, you should look at [GtkGLArea](../gtk4/class.GLArea.html), which uses a different approach and is still well-supported. Creates a `GskGLShader` that will render pixels using the specified code. GTK's new Vulkan-focused rendering does not support this feature. Use [GtkGLArea](../gtk4/class.GLArea.html) for OpenGL rendering. A new `GskGLShader` GLSL sourcecode for the shader, as a `GBytes` Creates a `GskGLShader` that will render pixels using the specified code. GTK's new Vulkan-focused rendering does not support this feature. Use [GtkGLArea](../gtk4/class.GLArea.html) for OpenGL rendering. 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. GTK's new Vulkan-focused rendering does not support this feature. Use [GtkGLArea](../gtk4/class.GLArea.html) for OpenGL rendering. %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. GTK's new Vulkan-focused rendering does not support this feature. Use [GtkGLArea](../gtk4/class.GLArea.html) for OpenGL rendering. 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. GTK's new Vulkan-focused rendering does not support this feature. Use [GtkGLArea](../gtk4/class.GLArea.html) for OpenGL rendering. 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. GTK's new Vulkan-focused rendering does not support this feature. Use [GtkGLArea](../gtk4/class.GLArea.html) for OpenGL rendering. 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. GTK's new Vulkan-focused rendering does not support this feature. Use [GtkGLArea](../gtk4/class.GLArea.html) for OpenGL rendering. 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. GTK's new Vulkan-focused rendering does not support this feature. Use [GtkGLArea](../gtk4/class.GLArea.html) for OpenGL rendering. 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. GTK's new Vulkan-focused rendering does not support this feature. Use [GtkGLArea](../gtk4/class.GLArea.html) for OpenGL rendering. 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. GTK's new Vulkan-focused rendering does not support this feature. Use [GtkGLArea](../gtk4/class.GLArea.html) for OpenGL rendering. 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. GTK's new Vulkan-focused rendering does not support this feature. Use [GtkGLArea](../gtk4/class.GLArea.html) for OpenGL rendering. 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. GTK's new Vulkan-focused rendering does not support this feature. Use [GtkGLArea](../gtk4/class.GLArea.html) for OpenGL rendering. 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. GTK's new Vulkan-focused rendering does not support this feature. Use [GtkGLArea](../gtk4/class.GLArea.html) for OpenGL rendering. 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. GTK's new Vulkan-focused rendering does not support this feature. Use [GtkGLArea](../gtk4/class.GLArea.html) for OpenGL rendering. 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. GTK's new Vulkan-focused rendering does not support this feature. Use [GtkGLArea](../gtk4/class.GLArea.html) for OpenGL rendering. The number of texture inputs required by @shader a `GskGLShader` Get the number of declared uniforms for this shader. GTK's new Vulkan-focused rendering does not support this feature. Use [GtkGLArea](../gtk4/class.GLArea.html) for OpenGL rendering. The number of declared uniforms a `GskGLShader` Gets the resource path for the GLSL sourcecode being used to render this shader. GTK's new Vulkan-focused rendering does not support this feature. Use [GtkGLArea](../gtk4/class.GLArea.html) for OpenGL rendering. The resource path for the shader a `GskGLShader` Gets the GLSL sourcecode being used to render this shader. GTK's new Vulkan-focused rendering does not support this feature. Use [GtkGLArea](../gtk4/class.GLArea.html) for OpenGL rendering. The source code for the shader a `GskGLShader` Get the name of the declared uniform for this shader at index @idx. GTK's new Vulkan-focused rendering does not support this feature. Use [GtkGLArea](../gtk4/class.GLArea.html) for OpenGL rendering. 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. GTK's new Vulkan-focused rendering does not support this feature. Use [GtkGLArea](../gtk4/class.GLArea.html) for OpenGL rendering. The data offset a `GskGLShader` index of the uniform Get the type of the declared uniform for this shader at index @idx. GTK's new Vulkan-focused rendering does not support this feature. Use [GtkGLArea](../gtk4/class.GLArea.html) for OpenGL rendering. 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. The source code for the shader, as a `GBytes`. 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. GTK's new Vulkan-focused rendering does not support this feature. Use [GtkGLArea](../gtk4/class.GLArea.html) for OpenGL rendering. 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 (currently the GL backend supports up to 4 children) Gets args for the node. GTK's new Vulkan-focused rendering does not support this feature. Use [GtkGLArea](../gtk4/class.GLArea.html) for OpenGL rendering. A `GBytes` with the uniform arguments a `GskRenderNode` for a gl shader Gets one of the children. GTK's new Vulkan-focused rendering does not support this feature. Use [GtkGLArea](../gtk4/class.GLArea.html) for OpenGL rendering. the @idx'th child of @node a `GskRenderNode` for a gl shader the position of the child to get Returns the number of children GTK's new Vulkan-focused rendering does not support this feature. Use [GtkGLArea](../gtk4/class.GLArea.html) for OpenGL rendering. 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 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 value returned by this function will not be correct if the render node was created for a non-sRGB color. 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 Specifies how to render the start and end points of contours or dashes when stroking. The default line cap style is `GSK_LINE_CAP_BUTT`. New entries may be added in future versions. <figure> <picture> <source srcset="caps-dark.png" media="(prefers-color-scheme: dark)"> <img alt="Line Cap Styles" src="caps-light.png"> </picture> <figcaption>GSK_LINE_CAP_BUTT, GSK_LINE_CAP_ROUND, GSK_LINE_CAP_SQUARE</figcaption> </figure> Start and stop the line exactly at the start and end point Use a round ending, the center of the circle is the start or end point use squared ending, the center of the square is the start or end point Specifies how to render the junction of two lines when stroking. The default line join style is `GSK_LINE_JOIN_MITER`. New entries may be added in future versions. <figure> <picture> <source srcset="join-dark.png" media="(prefers-color-scheme: dark)"> <img alt="Line Join Styles" src="join-light.png"> </picture> <figcaption>GSK_LINE_JOINT_MITER, GSK_LINE_JOINT_ROUND, GSK_LINE_JOIN_BEVEL</figcaption> </figure> Use a sharp angled corner Use a round join, the center of the circle is the join point use a cut-off join, the join is cut off at half the line width from the joint point 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 The mask modes available for mask nodes. Use the alpha channel of the mask Use the inverted alpha channel of the mask Use the luminance of the mask, multiplied by mask alpha Use the inverted luminance of the mask, multiplied by mask alpha A render node masking one child node with another. Creates a `GskRenderNode` that will mask a given node by another. The @mask_mode determines how the 'mask values' are derived from the colors of the @mask. Applying the mask consists of multiplying the 'mask value' with the alpha of the source. A new `GskRenderNode` The source node to be drawn The node to be used as mask The mask mode to use Retrieves the mask `GskRenderNode` child of the @node. the mask child node a mask `GskRenderNode` Retrieves the mask mode used by @node. the mask mode a blending `GskRenderNode` Retrieves the source `GskRenderNode` child of the @node. the source child node a mask `GskRenderNode` A GL based renderer. See [class@Gsk.Renderer]. Same as gsk_gl_renderer_new(). Use gsk_gl_renderer_new() a 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. The value returned by this function will not be correct if the render node was created for a non-sRGB color. 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 Describes lines and curves that are more complex than simple rectangles. Paths can used for rendering (filling or stroking) and for animations (e.g. as trajectories). `GskPath` is an immutable, opaque, reference-counted struct. After creation, you cannot change the types it represents. Instead, new `GskPath` objects have to be created. The [struct@Gsk.PathBuilder] structure is meant to help in this endeavor. Conceptually, a path consists of zero or more contours (continuous, connected curves), each of which may or may not be closed. Contours are typically constructed from Bézier segments. <picture> <source srcset="path-dark.png" media="(prefers-color-scheme: dark)"> <img alt="A Path" src="path-light.png"> </picture> Calls @func for every operation of the path. Note that this may only approximate @self, because paths can contain optimizations for various specialized contours, and depending on the @flags, the path may be decomposed into simpler curves than the ones that it contained originally. This function serves two purposes: - When the @flags allow everything, it provides access to the raw, unmodified data of the path. - When the @flags disallow certain operations, it provides an approximation of the path using just the allowed operations. false if @func returned false, true otherwise. a path flags to pass to the foreach function the function to call for operations user data passed to @func Finds intersections between two paths. This function finds intersections between @path1 and @path2, and calls @func for each of them, in increasing order for @path1. If @path2 is not provided or equal to @path1, the function finds non-trivial self-intersections of @path1. When segments of the paths coincide, the callback is called once for the start of the segment, with @GSK_PATH_INTERSECTION_START, and once for the end of the segment, with @GSK_PATH_INTERSECTION_END. Note that other intersections may occur between the start and end of such a segment. If @func returns `FALSE`, the iteration is stopped. `FALSE` if @func returned FALSE`, `TRUE` otherwise. the first path the second path the function to call for intersections user data passed to @func Computes the bounds of the given path. The returned bounds may be larger than necessary, because this function aims to be fast, not accurate. The bounds are guaranteed to contain the path. It is possible that the returned rectangle has 0 width and/or height. This can happen when the path only describes a point or an axis-aligned line. If the path is empty, false is returned and @bounds are set to graphene_rect_zero(). This is different from the case where the path is a single point at the origin, where the @bounds will also be set to the zero rectangle but true will be returned. true if the path has bounds, false if the path is known to be empty and have no bounds a path return location for the bounds Computes the closest point on the path to the given point. If there is no point closer than the given threshold, false is returned. true if @point was set to the closest point on @self, false if no point is closer than @threshold a path the point maximum allowed distance return location for the closest point return location for the distance Gets the end point of the path. An empty path has no points, so false is returned in this case. true if @result was filled a path return location for point Gets the start point of the path. An empty path has no points, so false is returned in this case. true if @result was filled a path return location for point Computes the bounds for stroking the given path with the given parameters. The returned bounds may be larger than necessary, because this function aims to be fast, not accurate. The bounds are guaranteed to contain the area affected by the stroke, including protrusions like miters. true if the path has bounds, false if the path is known to be empty and have no bounds. a path stroke parameters the bounds to fill in Returns whether a point is inside the fill area of a path. Note that this function assumes that filling a contour implicitly closes it. true if @point is inside a path the point to test the fill rule to follow Returns if the path represents a single closed contour. true if the path is closed a path Checks if the path is empty, i.e. contains no lines or curves. true if the path is empty a path Converts the path into a human-readable representation. The string is compatible with (a superset of) [SVG path syntax](https://www.w3.org/TR/SVG11/paths.html#PathData), see [func@Gsk.Path.parse] for a summary of the syntax. a path the string to print into Increases the reference count of a path by one. the passed in `GskPath` a path Appends the path to a cairo context for drawing with Cairo. This may cause some suboptimal conversions to be performed as Cairo does not support all features of `GskPath`. This function does not clear the existing Cairo path. Call cairo_new_path() if you want this. a path a cairo context Converts the path into a human-readable string. You can use this function in a debugger to get a quick overview of the path. This is a wrapper around [method@Gsk.Path.print], see that function for details. a new string for @self a path Decreases the reference count of a path by one. If the resulting reference count is zero, frees the path. a path Constructs a path from a serialized form. The string is expected to be in (a superset of) [SVG path syntax](https://www.w3.org/TR/SVG11/paths.html#PathData), as e.g. produced by [method@Gsk.Path.to_string]. A high-level summary of the syntax: - `M x y` Move to `(x, y)` - `L x y` Add a line from the current point to `(x, y)` - `Q x1 y1 x2 y2` Add a quadratic Bézier from the current point to `(x2, y2)`, with control point `(x1, y1)` - `C x1 y1 x2 y2 x3 y3` Add a cubic Bézier from the current point to `(x3, y3)`, with control points `(x1, y1)` and `(x2, y2)` - `Z` Close the contour by drawing a line back to the start point - `H x` Add a horizontal line from the current point to the given x value - `V y` Add a vertical line from the current point to the given y value - `T x2 y2` Add a quadratic Bézier, using the reflection of the previous segments' control point as control point - `S x2 y2 x3 y3` Add a cubic Bézier, using the reflection of the previous segments' second control point as first control point - `A rx ry r l s x y` Add an elliptical arc from the current point to `(x, y)` with radii rx and ry. See the SVG documentation for how the other parameters influence the arc. - `O x1 y1 x2 y2 w` Add a rational quadratic Bézier from the current point to `(x2, y2)` with control point `(x1, y1)` and weight `w`. All the commands have lowercase variants that interpret coordinates relative to the current point. The `O` command is an extension that is not supported in SVG. a new `GskPath`, or `NULL` if @string could not be parsed a string Constructs `GskPath` objects. A path is constructed like this: ```c GskPath * construct_path (void) { GskPathBuilder *builder; builder = gsk_path_builder_new (); // add contours to the path here return gsk_path_builder_free_to_path (builder); ``` Adding contours to the path can be done in two ways. The easiest option is to use the `gsk_path_builder_add_*` group of functions that add predefined contours to the current path, either common shapes like [method@Gsk.PathBuilder.add_circle] or by adding from other paths like [method@Gsk.PathBuilder.add_path]. The `gsk_path_builder_add_*` methods always add complete contours, and do not use or modify the current point. The other option is to define each line and curve manually with the `gsk_path_builder_*_to` group of functions. You start with a call to [method@Gsk.PathBuilder.move_to] to set the starting point and then use multiple calls to any of the drawing functions to move the pen along the plane. Once you are done, you can call [method@Gsk.PathBuilder.close] to close the path by connecting it back with a line to the starting point. This is similar to how paths are drawn in Cairo. Note that `GskPathBuilder` will reduce the degree of added Bézier curves as much as possible, to simplify rendering. Create a new `GskPathBuilder` object. The resulting builder would create an empty `GskPath`. Use addition functions to add types to it. a new `GskPathBuilder` Adds a Cairo path to the builder. You can use cairo_copy_path() to access the path from a Cairo context. a path builder a path Adds a circle as a new contour. The path is going around the circle in clockwise direction. If @radius is zero, the contour will be a closed point. a path builder the center of the circle the radius of the circle Adds the outlines for the glyphs in @layout to the builder. a path builder the pango layout to add Appends all of @path to the builder. a path builder the path to append Adds a rectangle as a new contour. The path is going around the rectangle in clockwise direction. If the the width or height are 0, the path will be a closed horizontal or vertical line. If both are 0, it'll be a closed dot. a path builder the rectangle to create a path for Appends all of @path to the builder, in reverse order. a path builder the path to append Adds a rounded rectangle as a new contour. The path is going around the rectangle in clockwise direction. a path builder the rounded rect Adds a segment of a path to the builder. If @start is equal to or after @end, the path will first add the segment from @start to the end of the path, and then add the segment from the beginning to @end. If the path is closed, these segments will be connected. Note that this method always adds a path with the given start point and end point. To add a closed path, use [method@Gsk.PathBuilder.add_path]. a path builder the path to take the segment to the point on @path to start at the point on @path to end at Adds an elliptical arc from the current point to @x2, @y2 with @x1, @y1 determining the tangent directions. After this, @x2, @y2 will be the new current point. Note: Two points and their tangents do not determine a unique ellipse, so GSK just picks one. If you need more precise control, use [method@Gsk.PathBuilder.conic_to] or [method@Gsk.PathBuilder.svg_arc_to]. <picture> <source srcset="arc-dark.png" media="(prefers-color-scheme: dark)"> <img alt="Arc To" src="arc-light.png"> </picture> a path builder x coordinate of first control point y coordinate of first control point x coordinate of second control point y coordinate of second control point Ends the current contour with a line back to the start point. Note that this is different from calling [method@Gsk.PathBuilder.line_to] with the start point in that the contour will be closed. A closed contour behaves differently from an open one. When stroking, its start and end point are considered connected, so they will be joined via the line join, and not ended with line caps. a path builder Adds a [conic curve](https://en.wikipedia.org/wiki/Non-uniform_rational_B-spline) from the current point to @x2, @y2 with the given @weight and @x1, @y1 as the control point. The weight determines how strongly the curve is pulled towards the control point. A conic with weight 1 is identical to a quadratic Bézier curve with the same points. Conic curves can be used to draw ellipses and circles. They are also known as rational quadratic Bézier curves. After this, @x2, @y2 will be the new current point. <picture> <source srcset="conic-dark.png" media="(prefers-color-scheme: dark)"> <img alt="Conic To" src="conic-light.png"> </picture> a path builder x coordinate of control point y coordinate of control point x coordinate of the end of the curve y coordinate of the end of the curve weight of the control point, must be greater than zero Adds a [cubic Bézier curve](https://en.wikipedia.org/wiki/B%C3%A9zier_curve) from the current point to @x3, @y3 with @x1, @y1 and @x2, @y2 as the control points. After this, @x3, @y3 will be the new current point. <picture> <source srcset="cubic-dark.png" media="(prefers-color-scheme: dark)"> <img alt="Cubic To" src="cubic-light.png"> </picture> a path builder x coordinate of first control point y coordinate of first control point x coordinate of second control point y coordinate of second control point x coordinate of the end of the curve y coordinate of the end of the curve Creates a new path from the current state of the builder, and unrefs the builder. the newly created path with all the contours added to the builder a path builder Gets the current point. The current point is used for relative drawing commands and updated after every operation. When the builder is created, the default current point is set to `0, 0`. Note that this is different from cairo, which starts out without a current point. the current point a path builder Implements arc-to according to the HTML Canvas spec. A convenience function that implements the [HTML arc_to](https://html.spec.whatwg.org/multipage/canvas.html#dom-context-2d-arcto-dev) functionality. After this, the current point will be the point where the circle with the given radius touches the line from @x1, @y1 to @x2, @y2. a path builder x coordinate of first control point y coordinate of first control point x coordinate of second control point y coordinate of second control point radius of the circle Draws a line from the current point to @x, @y and makes it the new current point. <picture> <source srcset="line-dark.png" media="(prefers-color-scheme: dark)"> <img alt="Line To" src="line-light.png"> </picture> a path builder x coordinate y coordinate Starts a new contour by placing the pen at @x, @y. If this function is called twice in succession, the first call will result in a contour made up of a single point. The second call will start a new contour. a path builder x coordinate y coordinate Adds a [quadratic Bézier curve](https://en.wikipedia.org/wiki/B%C3%A9zier_curve) from the current point to @x2, @y2 with @x1, @y1 as the control point. After this, @x2, @y2 will be the new current point. <picture> <source srcset="quad-dark.png" media="(prefers-color-scheme: dark)"> <img alt="Quad To" src="quad-light.png"> </picture> a path builder x coordinate of control point y coordinate of control point x coordinate of the end of the curve y coordinate of the end of the curve Acquires a reference on the given builder. This function is intended primarily for language bindings. `GskPathBuilder` objects should not be kept around. the given path builder with its reference count increased a path builder Adds an elliptical arc from the current point to @x2, @y2 with @x1, @y1 determining the tangent directions. All coordinates are given relative to the current point. This is the relative version of [method@Gsk.PathBuilder.arc_to]. a path builder x coordinate of first control point y coordinate of first control point x coordinate of second control point y coordinate of second control point Adds a [conic curve](https://en.wikipedia.org/wiki/Non-uniform_rational_B-spline) from the current point to @x2, @y2 with the given @weight and @x1, @y1 as the control point. All coordinates are given relative to the current point. This is the relative version of [method@Gsk.PathBuilder.conic_to]. a path builder x offset of control point y offset of control point x offset of the end of the curve y offset of the end of the curve weight of the curve, must be greater than zero Adds a [cubic Bézier curve](https://en.wikipedia.org/wiki/B%C3%A9zier_curve) from the current point to @x3, @y3 with @x1, @y1 and @x2, @y2 as the control points. All coordinates are given relative to the current point. This is the relative version of [method@Gsk.PathBuilder.cubic_to]. a path builder x offset of first control point y offset of first control point x offset of second control point y offset of second control point x offset of the end of the curve y offset of the end of the curve Implements arc-to according to the HTML Canvas spec. All coordinates are given relative to the current point. This is the relative version of [method@Gsk.PathBuilder.html_arc_to]. a path builder x coordinate of first control point y coordinate of first control point x coordinate of second control point y coordinate of second control point radius of the circle Draws a line from the current point to a point offset from it by @x, @y and makes it the new current point. This is the relative version of [method@Gsk.PathBuilder.line_to]. a path builder x offset y offset Starts a new contour by placing the pen at @x, @y relative to the current point. This is the relative version of [method@Gsk.PathBuilder.move_to]. a path builder x offset y offset Adds a [quadratic Bézier curve](https://en.wikipedia.org/wiki/B%C3%A9zier_curve) from the current point to @x2, @y2 with @x1, @y1 the control point. All coordinates are given relative to the current point. This is the relative version of [method@Gsk.PathBuilder.quad_to]. a path builder x offset of control point y offset of control point x offset of the end of the curve y offset of the end of the curve Implements arc-to according to the SVG spec. All coordinates are given relative to the current point. This is the relative version of [method@Gsk.PathBuilder.svg_arc_to]. a path builder x radius y radius the rotation of the ellipsis whether to add the large arc whether to sweep in the positive direction x coordinate of the endpoint y coordinate of the endpoint Implements arc-to according to the SVG spec. A convenience function that implements the [SVG arc_to](https://www.w3.org/TR/SVG11/paths.html#PathDataEllipticalArcCommands) functionality. After this, @x, @y will be the new current point. a path builder x radius y radius the rotation of the ellipsis whether to add the large arc whether to sweep in the positive direction x coordinate of the endpoint y coordinate of the endpoint Creates a new path from the given builder. The given `GskPathBuilder` is reset to the initial state once this function returns. Calling this function again on the same builder instance will therefore produce an empty path, not a copy of the same path. This function is intended primarily for language bindings. C code should use [method@Gsk.PathBuilder.free_to_path]. the newly created path with all the contours added to the builder a path builder Releases a reference on the given builder. a path builder Used to pick one of the four tangents at a given point on the path. Note that the directions for @GSK_PATH_FROM_START/@GSK_PATH_TO_END and @GSK_PATH_TO_START/@GSK_PATH_FROM_END will coincide for smooth points. Only sharp turns will exhibit four different directions. <picture> <source srcset="directions-dark.png" media="(prefers-color-scheme: dark)"> <img alt="Path Tangents" src="directions-light.png"> </picture> The tangent in path direction of the incoming side of the path The tangent against path direction of the incoming side of the path The tangent in path direction of the outgoing side of the path The tangent against path direction of the outgoing side of the path Flags that can be passed to gsk_path_foreach() to influence what kinds of operations the path is decomposed into. By default, [method@Gsk.Path.foreach] will only emit a path with all operations flattened to straight lines to allow for maximum compatibility. The only operations emitted will be `GSK_PATH_MOVE`, `GSK_PATH_LINE` and `GSK_PATH_CLOSE`. The default behavior, only allow lines. Allow emission of `GSK_PATH_QUAD` operations Allow emission of `GSK_PATH_CUBIC` operations. Allow emission of `GSK_PATH_CONIC` operations. Type of the callback to iterate through the operations of a path. For each operation, the callback is given the @op itself, the points that the operation is applied to in @pts, and a @weight for conic curves. The @n_pts argument is somewhat redundant, since the number of points can be inferred from the operation. Each contour of the path starts with a @GSK_PATH_MOVE operation. Closed contours end with a @GSK_PATH_CLOSE operation. %TRUE to continue iterating the path, %FALSE to immediately abort and not call the function again. The operation The points of the operation The number of points The weight for conic curves, or unused if not a conic curve The user data provided with the function The values of this enumeration classify intersections between paths. No intersection A normal intersection, where the two paths cross each other The start of a segment where the two paths coincide The end of a segment where the two paths coincide Prototype of the callback to iterate through the intersections of two paths. true to continue iterating, false to stop the iteration and not call the function again the first path the intersection as point on @path1 the second path the intersection as point on @path2 the nature of the intersection user data Performs measurements on paths such as determining the length of the path. Many measuring operations require sampling the path length at intermediate points. Therefore, a `GskPathMeasure` has a tolerance that determines what precision is required for such approximations. A `GskPathMeasure` struct is a reference counted struct and should be treated as opaque. Creates a measure object for the given @path with the default tolerance. a new `GskPathMeasure` representing @path the path to measure Creates a measure object for the given @path and @tolerance. a new `GskPathMeasure` representing @path the path to measure the tolerance for measuring operations Gets the length of the path being measured. The length is cached, so this function does not do any work. the length of the path measured by @self a path measure Returns the path that the measure was created for. the path of @self a path measure Gets the point at the given distance into the path. An empty path has no points, so false is returned in that case. true if @result was set a path measure the distance return location for the point Returns the tolerance that the measure was created with. the tolerance of @self a path measure Increases the reference count of a `GskPathMeasure` by one. the passed in `GskPathMeasure`. a path measure Decreases the reference count of a `GskPathMeasure` by one. If the resulting reference count is zero, frees the object. a path measure Describes the segments of a `GskPath`. More values may be added in the future. A move-to operation, with 1 point describing the target point. A close operation ending the current contour with a line back to the starting point. Two points describe the start and end of the line. A line-to operation, with 2 points describing the start and end point of a straight line. A curve-to operation describing a quadratic Bézier curve with 3 points describing the start point, the control point and the end point of the curve. A curve-to operation describing a cubic Bézier curve with 4 points describing the start point, the two control points and the end point of the curve. A rational quadratic Bézier curve with 3 points describing the start point, control point and end point of the curve. A weight for the curve will be passed, too. Represents a point on a path. It can be queried for properties of the path at that point, such as its tangent or its curvature. To obtain a `GskPathPoint`, use [method@Gsk.Path.get_closest_point], [method@Gsk.Path.get_start_point], [method@Gsk.Path.get_end_point] or [method@Gsk.PathMeasure.get_point]. Note that `GskPathPoint` structs are meant to be stack-allocated, and don't hold a reference to the path object they are obtained from. It is the callers responsibility to keep a reference to the path as long as the `GskPathPoint` is used. Returns whether @point1 is before or after @point2. -1 if @point1 is before @point2, 1 if @point1 is after @point2, 0 if they are equal a path point another path point Copies a path point. the copied point a path point Returns whether the two path points refer to the same location on all paths. Note that the start- and endpoint of a closed contour will compare nonequal according to this definition. Use [method@Gsk.Path.is_closed] to find out if the start- and endpoint of a concrete path refer to the same location. true if @point1 and @point2 are equal a path point another path point Frees a path point copied by [method@Gsk.PathPoint.copy]. a path point Calculates the curvature of the path at the point. Optionally, returns the center of the osculating circle as well. The curvature is the inverse of the radius of the osculating circle. Lines have a curvature of zero (indicating an osculating circle of infinite radius). In this case, the @center is not modified. Circles with a radius of zero have `INFINITY` as curvature Note that certain points on a path may not have a single curvature, such as sharp turns. At such points, there are two curvatures — the (limit of) the curvature of the path going into the point, and the (limit of) the curvature of the path coming out of it. The @direction argument lets you choose which one to get. <picture> <source srcset="curvature-dark.png" media="(prefers-color-scheme: dark)"> <img alt="Osculating circle" src="curvature-light.png"> </picture> the curvature of the path at the given point a path point the path that @point is on the direction for which to return the curvature return location for the center of the osculating circle Returns the distance from the beginning of the path to the point. the distance of @point a point on the path a path measure for the path Gets the position of the point. a path point the path that @point is on Return location for the coordinates of the point Gets the direction of the tangent at a given point. This is a convenience variant of [method@Gsk.PathPoint.get_tangent] that returns the angle between the tangent and the X axis. The angle can e.g. be used in [gtk_snapshot_rotate()](../gtk4/method.Snapshot.rotate.html). the angle between the tangent and the X axis, in degrees a path point the path that @point is on the direction for which to return the rotation Gets the tangent of the path at the point. Note that certain points on a path may not have a single tangent, such as sharp turns. At such points, there are two tangents — the direction of the path going into the point, and the direction coming out of it. The @direction argument lets you choose which one to get. If the path is just a single point (e.g. a circle with radius zero), then the tangent is set to `0, 0`. If you want to orient something in the direction of the path, [method@Gsk.PathPoint.get_rotation] may be more convenient to use. a path point the path that @point is on the direction for which to return the tangent Return location for the tangent at the point 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 vertical 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 horizontal 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 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 render node the bytes containing the data callback on parsing errors user_data for @error_func Draws the contents of a render node on a cairo context. Typically, you'll use this function to implement fallback rendering of render nodes 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 render node cairo context to draw to Retrieves the boundaries of the @node. The node will not draw outside of its boundaries. a render node return location for the boundaries Returns the type of the render node. the type of @node a render node Gets an opaque rectangle inside the node that GTK can determine to be fully opaque. There is no guarantee that this is indeed the largest opaque rectangle or that regions outside the rectangle are not opaque. This function is a best effort with that goal. The rectangle will be fully contained in the bounds of the node. true if part or all of the rendernode is opaque, false if no opaque region could be found. a render node return location for the opaque rect Acquires a reference on the given `GskRenderNode`. the render node with an additional reference a render 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. 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 render node 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 render node 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 A node drawing a `GdkTexture` scaled and filtered. A node that masks one child with another. A node that fills a path. A node that strokes a path. A node that possibly redirects part of the scene graph to a subsurface. A node that applies some function to each color component. 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. the realized renderer a surface Retrieves the surface that the renderer is associated with. If the renderer has not been realized yet, `NULL` will be returned. the surface a renderer Checks whether the renderer is realized or not. true if the renderer was realized, false otherwise a renderer Creates the resources needed by the renderer. Since GTK 4.6, the surface may be `NULL`, which allows using renderers without having to create a surface. Since GTK 4.14, it is recommended to use [method@Gsk.Renderer.realize_for_display] for this case. Note that it is mandatory to call [method@Gsk.Renderer.unrealize] before destroying the renderer. whether the renderer was successfully realized a renderer the surface that renderer will be used on Creates the resources needed by the renderer. Note that it is mandatory to call [method@Gsk.Renderer.unrealize] before destroying the renderer. whether the renderer was successfully realized a renderer the display that the 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 renderer the render node to render the `cairo_region_t` that must be redrawn or `NULL` for the whole surface Renders a scene graph, described by a tree of `GskRenderNode` instances, to a texture. 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 texture with the rendered contents of @root a realized renderer the render node to render the section to draw or `NULL` to use @root's bounds Releases all the resources created by [method@Gsk.Renderer.realize]. a renderer 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 vertical 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 rounded rectangle the point to check Checks if the given rectangle is contained inside the rounded rectangle. true if the @rect is fully contained inside the rounded rectangle a rounded rectangle the rectangle to check Initializes a rounded rectangle with the given values. This function will implicitly normalize the rounded rectangle before returning. the initialized rounded rectangle the rounded rectangle 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 a rounded rectangle with a copy. This function will not normalize the rounded rectangle, so make sure the source is normalized. the initialized rounded rectangle the rounded rectangle to initialize another rounded rectangle Initializes a rounded rectangle to the given bounds and sets the radius of all four corners equally. the initialized rounded rectangle the rounded rectangle to initialize a `graphene_rect_t` the border radius Checks if part a rectangle is contained inside the rounded rectangle. true if the @rect intersects with the rounded rectangle a rounded rectangle the rectangle to check Checks if all corners of a rounded rectangle 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 rounded rectangle is rectilinear the rounded rectangle to check Normalizes a rounded rectangle. This function will ensure that the bounds of the rounded rectangle are normalized and ensure that the corner values are positive and the corners do not overlap. the normalized rounded rectangle a rounded rectangle Offsets the rounded rectangle's origin by @dx and @dy. The size and corners of the rounded rectangle are unchanged. the offset rounded rectangle a rounded rectangle the horizontal offset the vertical offset Shrinks (or grows) a rounded 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 rounded rectangles if you pass negative values for the @top, @right, @bottom or @left. the resized rounded rectangle the rounded rectangle 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 Registers an error quark for [class@Gsk.RenderNode] errors. the error quark Builds the uniforms data for a `GskGLShader`. Allocates a builder that can be used to construct a new uniform data chunk. GTK's new Vulkan-focused rendering does not support this feature. Use [GtkGLArea](../gtk4/class.GLArea.html) for OpenGL rendering. 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. GTK's new Vulkan-focused rendering does not support this feature. Use [GtkGLArea](../gtk4/class.GLArea.html) for OpenGL rendering. the newly allocated buffer with all the args added to @builder a `GskShaderArgsBuilder` Increases the reference count of a `GskShaderArgsBuilder` by one. GTK's new Vulkan-focused rendering does not support this feature. Use [GtkGLArea](../gtk4/class.GLArea.html) for OpenGL rendering. the passed in `GskShaderArgsBuilder` a `GskShaderArgsBuilder` Sets the value of the uniform @idx. The uniform must be of bool type. GTK's new Vulkan-focused rendering does not support this feature. Use [GtkGLArea](../gtk4/class.GLArea.html) for OpenGL rendering. 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. GTK's new Vulkan-focused rendering does not support this feature. Use [GtkGLArea](../gtk4/class.GLArea.html) for OpenGL rendering. 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. GTK's new Vulkan-focused rendering does not support this feature. Use [GtkGLArea](../gtk4/class.GLArea.html) for OpenGL rendering. 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. GTK's new Vulkan-focused rendering does not support this feature. Use [GtkGLArea](../gtk4/class.GLArea.html) for OpenGL rendering. 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. GTK's new Vulkan-focused rendering does not support this feature. Use [GtkGLArea](../gtk4/class.GLArea.html) for OpenGL rendering. 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. GTK's new Vulkan-focused rendering does not support this feature. Use [GtkGLArea](../gtk4/class.GLArea.html) for OpenGL rendering. 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]. GTK's new Vulkan-focused rendering does not support this feature. Use [GtkGLArea](../gtk4/class.GLArea.html) for OpenGL rendering. 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. GTK's new Vulkan-focused rendering does not support this feature. Use [GtkGLArea](../gtk4/class.GLArea.html) for OpenGL rendering. 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 Collects the parameters that are needed when stroking a path. Creates a new `GskStroke` with the given @line_width. a new `GskStroke` line width of the stroke. Must be > 0 Creates a copy of a `GskStroke`. a new `GskStroke`. Use [method@Gsk.Stroke.free] to free it the stroke to copy Frees a `GskStroke`. a stroke Gets the dash array in use. the dash array or `NULL` if the dash array is empty a stroke number of elements in the array returned Gets the dash offset. the dash offset a stroke Gets the line cap used. See [enum@Gsk.LineCap] for details. the line cap a stroke Gets the line join used. See [enum@Gsk.LineJoin] for details. the line join a stroke Gets the line width used. the line width a stroke Gets the miter limit. the miter limit a stroke Sets the dash pattern to use. A dash pattern is specified by an array of alternating non-negative values. Each value provides the length of alternate "on" and "off" portions of the stroke. Each "on" segment will have caps applied as if the segment were a separate contour. In particular, it is valid to use an "on" length of 0 with [enum@Gsk.LineCap.round] or [enum@Gsk.LineCap.square] to draw dots or squares along a path. If @n_dash is 0, if all elements in @dash are 0, or if there are negative values in @dash, then dashing is disabled. If @n_dash is 1, an alternating "on" and "off" pattern with the single dash length provided is assumed. If @n_dash is uneven, the dash array will be used with the first element in @dash defining an "on" or "off" in alternating passes through the array. You can specify a starting offset into the dash with [method@Gsk.Stroke.set_dash_offset]. a stroke the array of dashes number of elements in @dash Sets the offset into the dash pattern where dashing should begin. This is an offset into the length of the path, not an index into the array values of the dash array. See [method@Gsk.Stroke.set_dash] for more details on dashing. a stroke offset into the dash pattern Sets the line cap to be used when stroking. See [enum@Gsk.LineCap] for details. a stroke the line cap Sets the line join to be used when stroking. See [enum@Gsk.LineJoin] for details. a stroke the line join to use Sets the line width to be used when stroking. The line width must be >= 0. a stroke width of the line in pixels Sets the miter limit to be used when stroking. The miter limit is the distance from the corner where sharp turns of joins get cut off. The limit is specfied in units of line width and must be non-negative. For joins of type [enum@Gsk.LineJoin.miter] that exceed the miter limit, the join gets rendered as if it was of type [enum@Gsk.LineJoin.bevel]. a stroke the miter limit A helper function that sets the stroke parameters of a cairo context from a `GskStroke`. a stroke the cairo context to configure Checks if two strokes are identical. true if the two strokes are equal, false otherwise the first stroke the second stroke A render node that will fill the area determined by stroking the the given [struct@Gsk.Path] using the [struct@Gsk.Stroke] attributes. Creates a #GskRenderNode that will fill the outline generated by stroking the given @path using the attributes defined in @stroke. The area is filled with @child. A new #GskRenderNode The node to stroke the area with The path describing the area to stroke The stroke attributes to use Gets the child node that is getting drawn by the given @node. The child that is getting drawn a stroke #GskRenderNode Retrieves the path that will be stroked with the contents of the @node. a #GskPath a stroke #GskRenderNode Retrieves the stroke attributes used in this @node. a #GskStroke a stroke #GskRenderNode A render node that potentially diverts a part of the scene graph to a subsurface. Creates a `GskRenderNode` that will possibly divert the child node to a subsurface. Note: Since subsurfaces are currently private, these nodes cannot currently be created outside of GTK. See [GtkGraphicsOffload](../gtk4/class.GraphicsOffload.html). A new `GskRenderNode` The child to divert to a subsurface the subsurface to use Gets the subsurface that was set on this node the subsurface a subsurface `GskRenderNode` Gets the child node that is getting drawn by the given @node. the child `GskRenderNode` a subsurface `GskRenderNode` 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 value returned by this function will not be correct if the render node was created for a non-sRGB color. 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. Note that GSK applies linear filtering when textures are scaled and transformed. See [class@Gsk.TextureScaleNode] for a way to influence filtering. 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 A render node for a `GdkTexture`, with control over scaling. Creates a node that scales the texture to the size given by the bounds using the filter and then places it at the bounds' position. Note that further scaling and other transformations which are applied to the node will apply linear filtering to the resulting texture, as usual. This node is intended for tight control over scaling applied to a texture, such as in image editors and requires the application to be aware of the whole render tree as further transforms may be applied that conflict with the desired effect of this node. A new `GskRenderNode` the texture to scale the size of the texture to scale to how to scale the texture Retrieves the `GskScalingFilter` used when creating this `GskRenderNode`. the `GskScalingFilter` a `GskRenderNode` of type %GSK_TEXTURE_SCALE_NODE Retrieves the `GdkTexture` used when creating this `GskRenderNode`. the `GdkTexture` a `GskRenderNode` of type %GSK_TEXTURE_SCALE_NODE Describes a 3D transform. 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. Creates a new identity transform. This function is meant to be used by language bindings. For C code, this is equivalent to using `NULL`. A new identity transform 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 transform 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. This function consumes @self. Use [method@Gsk.Transform.ref] first if you want to keep it around. The inverted transform transform to invert Multiplies @next with the given @matrix. This function consumes @next. Use [method@Gsk.Transform.ref] first if you want to keep it around. The new transform the next transform the matrix to multiply @next with Multiplies @next with the matrix [ xx yx x0; xy yy y0; 0 0 1 ]. The result of calling [method@Gsk.Transform.to_2d] on the returned [struct@Gsk.Transform] should match the input passed to this function. This function consumes @next. Use [method@Gsk.Transform.ref] first if you want to keep it around. The new transform the next transform the xx member the yx member the xy member the yy member the x0 member the y0 member 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. This function consumes @next. Use [method@Gsk.Transform.ref] first if you want to keep it around. 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 the transform into a human-readable representation. The result of this function can later be parsed with [func@Gsk.Transform.parse]. a transform The string to print into Acquires a reference on the given transform. the transform with an additional reference a transform Rotates @next by an angle around the Z axis. The rotation happens around the origin point of (0, 0). This function consumes @next. Use [method@Gsk.Transform.ref] first if you want to keep it around. 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] This function consumes @next. Use [method@Gsk.Transform.ref] first if you want to keep it around. 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. This function consumes @next. Use [method@Gsk.Transform.ref] first if you want to keep it around. The new transform the next transform scaling factor on the X axis scaling factor on the Y axis Scales @next by the given factors. This function consumes @next. Use [method@Gsk.Transform.ref] first if you want to keep it around. 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. This function consumes @next. Use [method@Gsk.Transform.ref] first if you want to keep it around. The new transform the next transform skew factor, in degrees, on the X axis skew factor, in degrees, on the Y axis Converts a transform 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 are a subset of the full 4x4 matrix that is computed by [method@Gsk.Transform.to_matrix] and 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 transform 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 transform 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_INIT (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 transform 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 transform 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 transform 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 4x4 matrix for the transform. The previous value of @out_matrix will be ignored. a transform return location for the matrix Converts the transform into a human-readable string. 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 transform Converts a transform 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 transform 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. This function consumes @next. Use [method@Gsk.Transform.ref] first if you want to keep it around. The new transform transform to apply @other to transform to apply Transforms a rectangle using the given transform. The result is the bounding box containing the coplanar quad. a transform the rectangle to transform return location for the bounds of the transformed rectangle Transforms a point using the given transform. a transform the point to transform return location for the transformed point Translates @next in 2-dimensional space by @point. This function consumes @next. Use [method@Gsk.Transform.ref] first if you want to keep it around. The new transform the next transform the point to translate the transform by Translates @next by @point. This function consumes @next. Use [method@Gsk.Transform.ref] first if you want to keep it around. The new transform the next transform the point to translate the transform by Releases a reference on the given transform. If the reference was the last, the resources associated to the @self are freed. a transform Parses a given into a 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 return location for the transform 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` Renders a GSK rendernode tree with Vulkan. This renderer will fail to realize if Vulkan is not supported. Creates a new Vulkan renderer. The Vulkan renderer is a renderer that uses the Vulkan library for rendering. This renderer will fail to realize when GTK was not compiled with Vulkan support. a new Vulkan renderer Compares two component transfers for equality. true if @self and @other are equal a component transfer another component transfer Constructs a path from a serialized form. The string is expected to be in (a superset of) [SVG path syntax](https://www.w3.org/TR/SVG11/paths.html#PathData), as e.g. produced by [method@Gsk.Path.to_string]. A high-level summary of the syntax: - `M x y` Move to `(x, y)` - `L x y` Add a line from the current point to `(x, y)` - `Q x1 y1 x2 y2` Add a quadratic Bézier from the current point to `(x2, y2)`, with control point `(x1, y1)` - `C x1 y1 x2 y2 x3 y3` Add a cubic Bézier from the current point to `(x3, y3)`, with control points `(x1, y1)` and `(x2, y2)` - `Z` Close the contour by drawing a line back to the start point - `H x` Add a horizontal line from the current point to the given x value - `V y` Add a vertical line from the current point to the given y value - `T x2 y2` Add a quadratic Bézier, using the reflection of the previous segments' control point as control point - `S x2 y2 x3 y3` Add a cubic Bézier, using the reflection of the previous segments' second control point as first control point - `A rx ry r l s x y` Add an elliptical arc from the current point to `(x, y)` with radii rx and ry. See the SVG documentation for how the other parameters influence the arc. - `O x1 y1 x2 y2 w` Add a rational quadratic Bézier from the current point to `(x2, y2)` with control point `(x1, y1)` and weight `w`. All the commands have lowercase variants that interpret coordinates relative to the current point. The `O` command is an extension that is not supported in SVG. a new `GskPath`, or `NULL` if @string could not be parsed a string Registers an error quark for [class@Gsk.RenderNode] errors. the error quark Checks if two strokes are identical. true if the two strokes are equal, false otherwise the first stroke the second stroke Parses a given into a 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 return location for the transform Retrieves the render node stored inside a `GValue`, and acquires a reference to it. the render node a [struct@GObject.Value] initialized with type `GSK_TYPE_RENDER_NODE` Retrieves the render node stored inside a `GValue`. the render node a `GValue` initialized with type `GSK_TYPE_RENDER_NODE` Stores the given render node inside a `GValue`. The [struct@GObject.Value] will acquire a reference to the render node. a [struct@GObject.Value] initialized with type `GSK_TYPE_RENDER_NODE` a render node Stores the given render node inside a `GValue`. This function transfers the ownership of the render node to the `GValue`. a [struct@GObject.Value] initialized with type `GSK_TYPE_RENDER_NODE` a render node