///
///
///
///
///
///
///
///
///
///
///
///
///
/**
* Type Definitions for Gjs (https://gjs.guide/)
*
* These type definitions are automatically generated, do not edit them by hand.
* If you found a bug fix it in `ts-for-gir` or create a bug report on https://github.com/gjsify/ts-for-gir
*
* The based EJS template file is used for the generated .d.ts file of each GIR module like Gtk-4.0, GObject-2.0, ...
*/
declare module 'gi://Gsk?version=4.0' {
// Module dependencies
import type Graphene from 'gi://Graphene?version=1.0';
import type GObject from 'gi://GObject?version=2.0';
import type GLib from 'gi://GLib?version=2.0';
import type Gdk from 'gi://Gdk?version=4.0';
import type cairo from 'cairo';
import type PangoCairo from 'gi://PangoCairo?version=1.0';
import type Pango from 'gi://Pango?version=1.0';
import type HarfBuzz from 'gi://HarfBuzz?version=0.0';
import type freetype2 from 'gi://freetype2?version=2.0';
import type Gio from 'gi://Gio?version=2.0';
import type GModule from 'gi://GModule?version=2.0';
import type GdkPixbuf from 'gi://GdkPixbuf?version=2.0';
export namespace Gsk {
/**
* Gsk-4.0
*/
/**
* The blend modes available for render nodes.
*
* The implementation of each blend mode is deferred to the
* rendering pipeline.
*
* See for more information
* on blending and blend modes.
*/
/**
* The blend modes available for render nodes.
*
* The implementation of each blend mode is deferred to the
* rendering pipeline.
*
* See for more information
* on blending and blend modes.
*/
export namespace BlendMode {
export const $gtype: GObject.GType;
}
enum BlendMode {
/**
* The default blend mode, which specifies no blending
*/
DEFAULT,
/**
* The source color is multiplied by the destination
* and replaces the destination
*/
MULTIPLY,
/**
* Multiplies the complements of the destination and source
* color values, then complements the result.
*/
SCREEN,
/**
* Multiplies or screens the colors, depending on the
* destination color value. This is the inverse of hard-list
*/
OVERLAY,
/**
* Selects the darker of the destination and source colors
*/
DARKEN,
/**
* Selects the lighter of the destination and source colors
*/
LIGHTEN,
/**
* Brightens the destination color to reflect the source color
*/
COLOR_DODGE,
/**
* Darkens the destination color to reflect the source color
*/
COLOR_BURN,
/**
* Multiplies or screens the colors, depending on the source color value
*/
HARD_LIGHT,
/**
* Darkens or lightens the colors, depending on the source color value
*/
SOFT_LIGHT,
/**
* Subtracts the darker of the two constituent colors from the lighter color
*/
DIFFERENCE,
/**
* Produces an effect similar to that of the difference mode but lower in contrast
*/
EXCLUSION,
/**
* Creates a color with the hue and saturation of the source color and the luminosity of the destination color
*/
COLOR,
/**
* Creates a color with the hue of the source color and the saturation and luminosity of the destination color
*/
HUE,
/**
* Creates a color with the saturation of the source color and the hue and luminosity of the destination color
*/
SATURATION,
/**
* Creates a color with the luminosity of the source color and the hue and saturation of the destination color
*/
LUMINOSITY,
}
/**
* The corner indices used by `GskRoundedRect`.
*/
/**
* The corner indices used by `GskRoundedRect`.
*/
export namespace Corner {
export const $gtype: GObject.GType;
}
enum Corner {
/**
* The top left corner
*/
TOP_LEFT,
/**
* The top right corner
*/
TOP_RIGHT,
/**
* The bottom right corner
*/
BOTTOM_RIGHT,
/**
* The bottom left corner
*/
BOTTOM_LEFT,
}
/**
* 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.
*/
/**
* 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.
*/
export namespace FillRule {
export const $gtype: GObject.GType;
}
enum FillRule {
/**
* 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.
*/
WINDING,
/**
* 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.
*/
EVEN_ODD,
}
/**
* 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.
*/
/**
* 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.
*/
export namespace GLUniformType {
export const $gtype: GObject.GType;
}
enum GLUniformType {
/**
* No type, used for uninitialized or unspecified values.
*/
NONE,
/**
* A float uniform
*/
FLOAT,
/**
* A GLSL int / gint32 uniform
*/
INT,
/**
* A GLSL uint / guint32 uniform
*/
UINT,
/**
* A GLSL bool / gboolean uniform
*/
BOOL,
/**
* A GLSL vec2 / graphene_vec2_t uniform
*/
VEC2,
/**
* A GLSL vec3 / graphene_vec3_t uniform
*/
VEC3,
/**
* A GLSL vec4 / graphene_vec4_t uniform
*/
VEC4,
}
/**
* 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.
*
*
*
*
*
*
* GSK_LINE_CAP_BUTT, GSK_LINE_CAP_ROUND, GSK_LINE_CAP_SQUARE
*
*/
/**
* 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.
*
*
*
*
*
*
* GSK_LINE_CAP_BUTT, GSK_LINE_CAP_ROUND, GSK_LINE_CAP_SQUARE
*
*/
export namespace LineCap {
export const $gtype: GObject.GType;
}
enum LineCap {
/**
* Start and stop the line exactly at the start
* and end point
*/
BUTT,
/**
* Use a round ending, the center of the circle
* is the start or end point
*/
ROUND,
/**
* use squared ending, the center of the square
* is the start or end point
*/
SQUARE,
}
/**
* 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.
*
*
*
*
*
*
* GSK_LINE_JOINT_MITER, GSK_LINE_JOINT_ROUND, GSK_LINE_JOIN_BEVEL
*
*/
/**
* 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.
*
*
*
*
*
*
* GSK_LINE_JOINT_MITER, GSK_LINE_JOINT_ROUND, GSK_LINE_JOIN_BEVEL
*
*/
export namespace LineJoin {
export const $gtype: GObject.GType;
}
enum LineJoin {
/**
* Use a sharp angled corner
*/
MITER,
/**
* Use a round join, the center of the circle is
* the join point
*/
ROUND,
/**
* use a cut-off join, the join is cut off at half
* the line width from the joint point
*/
BEVEL,
}
/**
* The mask modes available for mask nodes.
*/
/**
* The mask modes available for mask nodes.
*/
export namespace MaskMode {
export const $gtype: GObject.GType;
}
enum MaskMode {
/**
* Use the alpha channel of the mask
*/
ALPHA,
/**
* Use the inverted alpha channel of the mask
*/
INVERTED_ALPHA,
/**
* Use the luminance of the mask,
* multiplied by mask alpha
*/
LUMINANCE,
/**
* Use the inverted luminance of the mask,
* multiplied by mask alpha
*/
INVERTED_LUMINANCE,
}
/**
* 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.
*
*
*
*
*
*/
/**
* 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.
*
*
*
*
*
*/
export namespace PathDirection {
export const $gtype: GObject.GType;
}
enum PathDirection {
/**
* The tangent in path direction of the incoming side
* of the path
*/
FROM_START,
/**
* The tangent against path direction of the incoming side
* of the path
*/
TO_START,
/**
* The tangent in path direction of the outgoing side
* of the path
*/
TO_END,
/**
* The tangent against path direction of the outgoing
* side of the path
*/
FROM_END,
}
/**
* Describes the segments of a `GskPath`.
*
* More values may be added in the future.
*/
/**
* Describes the segments of a `GskPath`.
*
* More values may be added in the future.
*/
export namespace PathOperation {
export const $gtype: GObject.GType;
}
enum PathOperation {
/**
* A move-to operation, with 1 point describing the target point.
*/
MOVE,
/**
* 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.
*/
CLOSE,
/**
* A line-to operation, with 2 points describing the start and
* end point of a straight line.
*/
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.
*/
QUAD,
/**
* 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.
*/
CUBIC,
/**
* 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.
*/
CONIC,
}
/**
* The type of a node determines what the node is rendering.
*/
/**
* The type of a node determines what the node is rendering.
*/
export namespace RenderNodeType {
export const $gtype: GObject.GType;
}
enum RenderNodeType {
/**
* Error type. No node will ever have this type.
*/
NOT_A_RENDER_NODE,
/**
* A node containing a stack of children
*/
CONTAINER_NODE,
/**
* A node drawing a `cairo_surface_t`
*/
CAIRO_NODE,
/**
* A node drawing a single color rectangle
*/
COLOR_NODE,
/**
* A node drawing a linear gradient
*/
LINEAR_GRADIENT_NODE,
/**
* A node drawing a repeating linear gradient
*/
REPEATING_LINEAR_GRADIENT_NODE,
/**
* A node drawing a radial gradient
*/
RADIAL_GRADIENT_NODE,
/**
* A node drawing a repeating radial gradient
*/
REPEATING_RADIAL_GRADIENT_NODE,
/**
* A node drawing a conic gradient
*/
CONIC_GRADIENT_NODE,
/**
* A node stroking a border around an area
*/
BORDER_NODE,
/**
* A node drawing a `GdkTexture`
*/
TEXTURE_NODE,
/**
* A node drawing an inset shadow
*/
INSET_SHADOW_NODE,
/**
* A node drawing an outset shadow
*/
OUTSET_SHADOW_NODE,
/**
* A node that renders its child after applying a matrix transform
*/
TRANSFORM_NODE,
/**
* A node that changes the opacity of its child
*/
OPACITY_NODE,
/**
* A node that applies a color matrix to every pixel
*/
COLOR_MATRIX_NODE,
/**
* A node that repeats the child's contents
*/
REPEAT_NODE,
/**
* A node that clips its child to a rectangular area
*/
CLIP_NODE,
/**
* A node that clips its child to a rounded rectangle
*/
ROUNDED_CLIP_NODE,
/**
* A node that draws a shadow below its child
*/
SHADOW_NODE,
/**
* A node that blends two children together
*/
BLEND_NODE,
/**
* A node that cross-fades between two children
*/
CROSS_FADE_NODE,
/**
* A node containing a glyph string
*/
TEXT_NODE,
/**
* A node that applies a blur
*/
BLUR_NODE,
/**
* Debug information that does not affect the rendering
*/
DEBUG_NODE,
/**
* A node that uses OpenGL fragment shaders to render
*/
GL_SHADER_NODE,
/**
* A node drawing a `GdkTexture` scaled and filtered.
*/
TEXTURE_SCALE_NODE,
/**
* A node that masks one child with another.
*/
MASK_NODE,
/**
* A node that fills a path.
*/
FILL_NODE,
/**
* A node that strokes a path.
*/
STROKE_NODE,
/**
* A node that possibly redirects part of the scene graph to a subsurface.
*/
SUBSURFACE_NODE,
}
/**
* The filters used when scaling texture data.
*
* The actual implementation of each filter is deferred to the
* rendering pipeline.
*/
/**
* The filters used when scaling texture data.
*
* The actual implementation of each filter is deferred to the
* rendering pipeline.
*/
export namespace ScalingFilter {
export const $gtype: GObject.GType;
}
enum ScalingFilter {
/**
* linear interpolation filter
*/
LINEAR,
/**
* nearest neighbor interpolation filter
*/
NEAREST,
/**
* linear interpolation along each axis,
* plus mipmap generation, with linear interpolation along the mipmap
* levels
*/
TRILINEAR,
}
/**
* Errors that can happen during (de)serialization.
*/
class SerializationError extends GLib.Error {
static $gtype: GObject.GType;
// Static fields
/**
* The format can not be identified
*/
static UNSUPPORTED_FORMAT: number;
/**
* The version of the data is not
* understood
*/
static UNSUPPORTED_VERSION: number;
/**
* The given data may not exist in
* a proper serialization
*/
static INVALID_DATA: number;
// Constructors
constructor(options: { message: string; code: number });
_init(...args: any[]): void;
// Static methods
/**
* Registers an error quark for [class`Gsk`.RenderNode] errors.
*/
static quark(): GLib.Quark;
}
/**
* 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 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))`.
*/
export namespace TransformCategory {
export const $gtype: GObject.GType;
}
enum TransformCategory {
/**
* The category of the matrix has not been
* determined.
*/
UNKNOWN,
/**
* Analyzing the matrix concluded that it does
* not fit in any other category.
*/
ANY,
/**
* The matrix is a 3D matrix. This means that
* the w column (the last column) has the values (0, 0, 0, 1).
*/
'3D',
/**
* 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.
*/
'2D',
/**
* 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.
*/
'2D_AFFINE',
/**
* The matrix is a 2D translation.
*/
'2D_TRANSLATE',
/**
* The matrix is the identity matrix.
*/
IDENTITY,
}
/**
* 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.
* @param string a string
* @returns a new `GskPath`, or `NULL` if @string could not be parsed
*/
function path_parse(string: string): Path | null;
/**
* Registers an error quark for [class`Gsk`.RenderNode] errors.
* @returns the error quark
*/
function serialization_error_quark(): GLib.Quark;
/**
* Checks if two strokes are identical.
* @param stroke1 the first stroke
* @param stroke2 the second stroke
* @returns true if the two strokes are equal, false otherwise
*/
function stroke_equal(stroke1?: any | null, stroke2?: any | null): boolean;
/**
* 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`.
* @param string the string to parse
* @returns true if @string described a valid transform
*/
function transform_parse(string: string): [boolean, Transform];
/**
* Retrieves the render node stored inside a `GValue`,
* and acquires a reference to it.
* @param value a [struct@GObject.Value] initialized with type `GSK_TYPE_RENDER_NODE`
* @returns the render node
*/
function value_dup_render_node(value: GObject.Value | any): RenderNode | null;
/**
* Retrieves the render node stored inside a `GValue`.
* @param value a `GValue` initialized with type `GSK_TYPE_RENDER_NODE`
* @returns the render node
*/
function value_get_render_node(value: GObject.Value | any): RenderNode | null;
/**
* Stores the given render node inside a `GValue`.
*
* The [struct`GObject`.Value] will acquire a reference
* to the render node.
* @param value a [struct@GObject.Value] initialized with type `GSK_TYPE_RENDER_NODE`
* @param node a render node
*/
function value_set_render_node(value: GObject.Value | any, node: RenderNode): void;
/**
* Stores the given render node inside a `GValue`.
*
* This function transfers the ownership of the
* render node to the `GValue`.
* @param value a [struct@GObject.Value] initialized with type `GSK_TYPE_RENDER_NODE`
* @param node a render node
*/
function value_take_render_node(value: GObject.Value | any, node?: RenderNode | null): void;
interface ParseErrorFunc {
(start: ParseLocation, end: ParseLocation, error: GLib.Error): void;
}
interface PathForeachFunc {
(op: PathOperation, pts: Graphene.Point, n_pts: number, weight: number): boolean;
}
/**
* 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`.
*/
/**
* 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`.
*/
export namespace PathForeachFlags {
export const $gtype: GObject.GType;
}
enum PathForeachFlags {
/**
* The default behavior, only allow lines.
*/
ONLY_LINES,
/**
* Allow emission of `GSK_PATH_QUAD` operations
*/
QUAD,
/**
* Allow emission of `GSK_PATH_CUBIC` operations.
*/
CUBIC,
/**
* Allow emission of `GSK_PATH_CONIC` operations.
*/
CONIC,
}
namespace BlendNode {
// Signal signatures
interface SignalSignatures extends RenderNode.SignalSignatures {}
}
/**
* A render node applying a blending function between its two child nodes.
*/
class BlendNode extends RenderNode {
static $gtype: GObject.GType;
// Constructors
_init(...args: any[]): void;
static ['new'](bottom: RenderNode, top: RenderNode, blend_mode: BlendMode): BlendNode;
// Signals
connect(
signal: K,
callback: GObject.SignalCallback,
): number;
connect(signal: string, callback: (...args: any[]) => any): number;
connect_after(
signal: K,
callback: GObject.SignalCallback,
): number;
connect_after(signal: string, callback: (...args: any[]) => any): number;
emit(
signal: K,
...args: GObject.GjsParameters extends [any, ...infer Q] ? Q : never
): void;
emit(signal: string, ...args: any[]): void;
// Methods
/**
* Retrieves the blend mode used by `node`.
* @returns the blend mode
*/
get_blend_mode(): BlendMode;
/**
* Retrieves the bottom `GskRenderNode` child of the `node`.
* @returns the bottom child node
*/
get_bottom_child(): RenderNode;
/**
* Retrieves the top `GskRenderNode` child of the `node`.
* @returns the top child node
*/
get_top_child(): RenderNode;
}
namespace BlurNode {
// Signal signatures
interface SignalSignatures extends RenderNode.SignalSignatures {}
}
/**
* A render node applying a blur effect to its single child.
*/
class BlurNode extends RenderNode {
static $gtype: GObject.GType;
// Constructors
_init(...args: any[]): void;
static ['new'](child: RenderNode, radius: number): BlurNode;
// Signals
connect(
signal: K,
callback: GObject.SignalCallback,
): number;
connect(signal: string, callback: (...args: any[]) => any): number;
connect_after(
signal: K,
callback: GObject.SignalCallback,
): number;
connect_after(signal: string, callback: (...args: any[]) => any): number;
emit(
signal: K,
...args: GObject.GjsParameters extends [any, ...infer Q] ? Q : never
): void;
emit(signal: string, ...args: any[]): void;
// Methods
/**
* Retrieves the child `GskRenderNode` of the blur `node`.
* @returns the blurred child node
*/
get_child(): RenderNode;
/**
* Retrieves the blur radius of the `node`.
* @returns the blur radius
*/
get_radius(): number;
}
namespace BorderNode {
// Signal signatures
interface SignalSignatures extends RenderNode.SignalSignatures {}
}
/**
* A render node for a border.
*/
class BorderNode extends RenderNode {
static $gtype: GObject.GType;
// Constructors
_init(...args: any[]): void;
static ['new'](outline: RoundedRect, border_width: number[], border_color: Gdk.RGBA[]): BorderNode;
// Signals
connect(
signal: K,
callback: GObject.SignalCallback,
): number;
connect(signal: string, callback: (...args: any[]) => any): number;
connect_after(
signal: K,
callback: GObject.SignalCallback,
): number;
connect_after(signal: string, callback: (...args: any[]) => any): number;
emit(
signal: K,
...args: GObject.GjsParameters extends [any, ...infer Q] ? Q : never
): void;
emit(signal: string, ...args: any[]): void;
// Methods
/**
* Retrieves the colors of the border.
* @returns an array of 4 `GdkRGBA` structs for the top, right, bottom and left color of the border
*/
get_colors(): Gdk.RGBA[];
/**
* Retrieves the outline of the border.
* @returns the outline of the border
*/
get_outline(): RoundedRect;
/**
* Retrieves the stroke widths of the border.
* @returns an array of 4 floats for the top, right, bottom and left stroke width of the border, respectively
*/
get_widths(): number[];
}
namespace BroadwayRenderer {
// Signal signatures
interface SignalSignatures extends Renderer.SignalSignatures {
'notify::realized': (pspec: GObject.ParamSpec) => void;
'notify::surface': (pspec: GObject.ParamSpec) => void;
}
// Constructor properties interface
interface ConstructorProps extends Renderer.ConstructorProps {}
}
/**
* A Broadway based renderer.
*
* See [class`Gsk`.Renderer].
*/
class BroadwayRenderer extends Renderer {
static $gtype: GObject.GType;
/**
* Compile-time signal type information.
*
* This instance property is generated only for TypeScript type checking.
* It is not defined at runtime and should not be accessed in JS code.
* @internal
*/
$signals: BroadwayRenderer.SignalSignatures;
// Constructors
constructor(properties?: Partial, ...args: any[]);
_init(...args: any[]): void;
static ['new'](): BroadwayRenderer;
// Signals
connect(
signal: K,
callback: GObject.SignalCallback,
): number;
connect(signal: string, callback: (...args: any[]) => any): number;
connect_after(
signal: K,
callback: GObject.SignalCallback,
): number;
connect_after(signal: string, callback: (...args: any[]) => any): number;
emit(
signal: K,
...args: GObject.GjsParameters extends [any, ...infer Q]
? Q
: never
): void;
emit(signal: string, ...args: any[]): void;
}
namespace CairoNode {
// Signal signatures
interface SignalSignatures extends RenderNode.SignalSignatures {}
}
/**
* A render node for a Cairo surface.
*/
class CairoNode extends RenderNode {
static $gtype: GObject.GType;
// Constructors
_init(...args: any[]): void;
static ['new'](bounds: Graphene.Rect): CairoNode;
// Signals
connect(
signal: K,
callback: GObject.SignalCallback,
): number;
connect(signal: string, callback: (...args: any[]) => any): number;
connect_after(
signal: K,
callback: GObject.SignalCallback,
): number;
connect_after(signal: string, callback: (...args: any[]) => any): number;
emit(
signal: K,
...args: GObject.GjsParameters extends [any, ...infer Q] ? Q : never
): void;
emit(signal: string, ...args: any[]): void;
// Methods
/**
* 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`.
* @returns a Cairo context used for drawing; use cairo_destroy() when done drawing
*/
get_draw_context(): cairo.Context;
/**
* Retrieves the Cairo surface used by the render node.
* @returns a Cairo surface
*/
get_surface(): cairo.Surface;
}
namespace CairoRenderer {
// Signal signatures
interface SignalSignatures extends Renderer.SignalSignatures {
'notify::realized': (pspec: GObject.ParamSpec) => void;
'notify::surface': (pspec: GObject.ParamSpec) => void;
}
// Constructor properties interface
interface ConstructorProps extends Renderer.ConstructorProps {}
}
/**
* Renders a GSK rendernode tree with cairo.
*
* Since it is using cairo, this renderer cannot support
* 3D transformations.
*/
class CairoRenderer extends Renderer {
static $gtype: GObject.GType;
/**
* Compile-time signal type information.
*
* This instance property is generated only for TypeScript type checking.
* It is not defined at runtime and should not be accessed in JS code.
* @internal
*/
$signals: CairoRenderer.SignalSignatures;
// Constructors
constructor(properties?: Partial, ...args: any[]);
_init(...args: any[]): void;
static ['new'](): CairoRenderer;
// Signals
connect(
signal: K,
callback: GObject.SignalCallback,
): number;
connect(signal: string, callback: (...args: any[]) => any): number;
connect_after(
signal: K,
callback: GObject.SignalCallback,
): number;
connect_after(signal: string, callback: (...args: any[]) => any): number;
emit(
signal: K,
...args: GObject.GjsParameters extends [any, ...infer Q] ? Q : never
): void;
emit(signal: string, ...args: any[]): void;
}
namespace ClipNode {
// Signal signatures
interface SignalSignatures extends RenderNode.SignalSignatures {}
}
/**
* A render node applying a rectangular clip to its single child node.
*/
class ClipNode extends RenderNode {
static $gtype: GObject.GType;
// Constructors
_init(...args: any[]): void;
static ['new'](child: RenderNode, clip: Graphene.Rect): ClipNode;
// Signals
connect(
signal: K,
callback: GObject.SignalCallback,
): number;
connect(signal: string, callback: (...args: any[]) => any): number;
connect_after(
signal: K,
callback: GObject.SignalCallback,
): number;
connect_after(signal: string, callback: (...args: any[]) => any): number;
emit(
signal: K,
...args: GObject.GjsParameters extends [any, ...infer Q] ? Q : never
): void;
emit(signal: string, ...args: any[]): void;
// Methods
/**
* Gets the child node that is getting clipped by the given `node`.
* @returns The child that is getting clipped
*/
get_child(): RenderNode;
/**
* Retrieves the clip rectangle for `node`.
* @returns a clip rectangle
*/
get_clip(): Graphene.Rect;
}
namespace ColorMatrixNode {
// Signal signatures
interface SignalSignatures extends RenderNode.SignalSignatures {}
}
/**
* A render node controlling the color matrix of its single child node.
*/
class ColorMatrixNode extends RenderNode {
static $gtype: GObject.GType;
// Constructors
_init(...args: any[]): void;
static ['new'](
child: RenderNode,
color_matrix: Graphene.Matrix,
color_offset: Graphene.Vec4,
): ColorMatrixNode;
// Signals
connect(
signal: K,
callback: GObject.SignalCallback,
): number;
connect(signal: string, callback: (...args: any[]) => any): number;
connect_after(
signal: K,
callback: GObject.SignalCallback,
): number;
connect_after(signal: string, callback: (...args: any[]) => any): number;
emit(
signal: K,
...args: GObject.GjsParameters extends [any, ...infer Q]
? Q
: never
): void;
emit(signal: string, ...args: any[]): void;
// Methods
/**
* Gets the child node that is getting its colors modified by the given `node`.
* @returns The child that is getting its colors modified
*/
get_child(): RenderNode;
/**
* Retrieves the color matrix used by the `node`.
* @returns a 4x4 color matrix
*/
get_color_matrix(): Graphene.Matrix;
/**
* Retrieves the color offset used by the `node`.
* @returns a color vector
*/
get_color_offset(): Graphene.Vec4;
}
namespace ColorNode {
// Signal signatures
interface SignalSignatures extends RenderNode.SignalSignatures {}
}
/**
* A render node for a solid color.
*/
class ColorNode extends RenderNode {
static $gtype: GObject.GType;
// Constructors
_init(...args: any[]): void;
static ['new'](rgba: Gdk.RGBA, bounds: Graphene.Rect): ColorNode;
// Signals
connect(
signal: K,
callback: GObject.SignalCallback,
): number;
connect(signal: string, callback: (...args: any[]) => any): number;
connect_after(
signal: K,
callback: GObject.SignalCallback,
): number;
connect_after(signal: string, callback: (...args: any[]) => any): number;
emit(
signal: K,
...args: GObject.GjsParameters extends [any, ...infer Q] ? Q : never
): void;
emit(signal: string, ...args: any[]): void;
// Methods
/**
* 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.
* @returns the color of the node
*/
get_color(): Gdk.RGBA;
}
namespace ConicGradientNode {
// Signal signatures
interface SignalSignatures extends RenderNode.SignalSignatures {}
}
/**
* A render node for a conic gradient.
*/
class ConicGradientNode extends RenderNode {
static $gtype: GObject.GType;
// Constructors
_init(...args: any[]): void;
static ['new'](
bounds: Graphene.Rect,
center: Graphene.Point,
rotation: number,
color_stops: ColorStop[],
): ConicGradientNode;
// Signals
connect(
signal: K,
callback: GObject.SignalCallback,
): number;
connect(signal: string, callback: (...args: any[]) => any): number;
connect_after(
signal: K,
callback: GObject.SignalCallback,
): number;
connect_after(signal: string, callback: (...args: any[]) => any): number;
emit(
signal: K,
...args: GObject.GjsParameters extends [any, ...infer Q]
? Q
: never
): void;
emit(signal: string, ...args: any[]): void;
// Methods
/**
* 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()
* @returns the angle for the gradient
*/
get_angle(): number;
/**
* Retrieves the center pointer for the gradient.
* @returns the center point for the gradient
*/
get_center(): Graphene.Point;
/**
* Retrieves the color stops in the gradient.
* @returns the color stops in the gradient
*/
get_color_stops(): ColorStop[];
/**
* Retrieves the number of color stops in the gradient.
* @returns the number of color stops
*/
get_n_color_stops(): number;
/**
* Retrieves the rotation for the gradient in degrees.
* @returns the rotation for the gradient
*/
get_rotation(): number;
}
namespace ContainerNode {
// Signal signatures
interface SignalSignatures extends RenderNode.SignalSignatures {}
}
/**
* A render node that can contain other render nodes.
*/
class ContainerNode extends RenderNode {
static $gtype: GObject.GType;
// Constructors
_init(...args: any[]): void;
static ['new'](children: RenderNode[]): ContainerNode;
// Signals
connect(
signal: K,
callback: GObject.SignalCallback,
): number;
connect(signal: string, callback: (...args: any[]) => any): number;
connect_after(
signal: K,
callback: GObject.SignalCallback,
): number;
connect_after(signal: string, callback: (...args: any[]) => any): number;
emit(
signal: K,
...args: GObject.GjsParameters extends [any, ...infer Q] ? Q : never
): void;
emit(signal: string, ...args: any[]): void;
// Methods
/**
* Gets one of the children of `container`.
* @param idx the position of the child to get
* @returns the @idx'th child of @container
*/
get_child(idx: number): RenderNode;
/**
* Retrieves the number of direct children of `node`.
* @returns the number of children of the `GskRenderNode`
*/
get_n_children(): number;
}
namespace CrossFadeNode {
// Signal signatures
interface SignalSignatures extends RenderNode.SignalSignatures {}
}
/**
* A render node cross fading between two child nodes.
*/
class CrossFadeNode extends RenderNode {
static $gtype: GObject.GType;
// Constructors
_init(...args: any[]): void;
static ['new'](start: RenderNode, end: RenderNode, progress: number): CrossFadeNode;
// Signals
connect(
signal: K,
callback: GObject.SignalCallback,
): number;
connect(signal: string, callback: (...args: any[]) => any): number;
connect_after(
signal: K,
callback: GObject.SignalCallback,
): number;
connect_after(signal: string, callback: (...args: any[]) => any): number;
emit(
signal: K,
...args: GObject.GjsParameters extends [any, ...infer Q] ? Q : never
): void;
emit(signal: string, ...args: any[]): void;
// Methods
/**
* Retrieves the child `GskRenderNode` at the end of the cross-fade.
* @returns a `GskRenderNode`
*/
get_end_child(): RenderNode;
/**
* Retrieves the progress value of the cross fade.
* @returns the progress value, between 0 and 1
*/
get_progress(): number;
/**
* Retrieves the child `GskRenderNode` at the beginning of the cross-fade.
* @returns a `GskRenderNode`
*/
get_start_child(): RenderNode;
}
namespace DebugNode {
// Signal signatures
interface SignalSignatures extends RenderNode.SignalSignatures {}
}
/**
* A render node that emits a debugging message when drawing its
* child node.
*/
class DebugNode extends RenderNode {
static $gtype: GObject.GType;
// Constructors
_init(...args: any[]): void;
static ['new'](child: RenderNode, message: string): DebugNode;
// Signals
connect(
signal: K,
callback: GObject.SignalCallback,
): number;
connect(signal: string, callback: (...args: any[]) => any): number;
connect_after(
signal: K,
callback: GObject.SignalCallback,
): number;
connect_after(signal: string, callback: (...args: any[]) => any): number;
emit(
signal: K,
...args: GObject.GjsParameters extends [any, ...infer Q] ? Q : never
): void;
emit(signal: string, ...args: any[]): void;
// Methods
/**
* Gets the child node that is getting drawn by the given `node`.
* @returns the child `GskRenderNode`
*/
get_child(): RenderNode;
/**
* Gets the debug message that was set on this node
* @returns The debug message
*/
get_message(): string;
}
namespace FillNode {
// Signal signatures
interface SignalSignatures extends RenderNode.SignalSignatures {}
}
/**
* A render node filling the area given by [struct`Gsk`.Path]
* and [enum`Gsk`.FillRule] with the child node.
*/
class FillNode extends RenderNode {
static $gtype: GObject.GType;
// Constructors
_init(...args: any[]): void;
static ['new'](child: RenderNode, path: Path, fill_rule: FillRule): FillNode;
// Signals
connect(
signal: K,
callback: GObject.SignalCallback,
): number;
connect(signal: string, callback: (...args: any[]) => any): number;
connect_after(
signal: K,
callback: GObject.SignalCallback,
): number;
connect_after(signal: string, callback: (...args: any[]) => any): number;
emit(
signal: K,
...args: GObject.GjsParameters extends [any, ...infer Q] ? Q : never
): void;
emit(signal: string, ...args: any[]): void;
// Methods
/**
* Gets the child node that is getting drawn by the given `node`.
* @returns The child that is getting drawn
*/
get_child(): RenderNode;
/**
* Retrieves the fill rule used to determine how the path is filled.
* @returns a `GskFillRule`
*/
get_fill_rule(): FillRule;
/**
* Retrieves the path used to describe the area filled with the contents of
* the `node`.
* @returns a `GskPath`
*/
get_path(): Path;
}
namespace GLRenderer {
// Signal signatures
interface SignalSignatures extends Renderer.SignalSignatures {
'notify::realized': (pspec: GObject.ParamSpec) => void;
'notify::surface': (pspec: GObject.ParamSpec) => void;
}
// Constructor properties interface
interface ConstructorProps extends Renderer.ConstructorProps {}
}
/**
* Renders a GSK rendernode tree with OpenGL.
*
* See [class`Gsk`.Renderer].
*/
class GLRenderer extends Renderer {
static $gtype: GObject.GType;
/**
* Compile-time signal type information.
*
* This instance property is generated only for TypeScript type checking.
* It is not defined at runtime and should not be accessed in JS code.
* @internal
*/
$signals: GLRenderer.SignalSignatures;
// Constructors
constructor(properties?: Partial, ...args: any[]);
_init(...args: any[]): void;
static ['new'](): GLRenderer;
// Signals
connect(
signal: K,
callback: GObject.SignalCallback,
): number;
connect(signal: string, callback: (...args: any[]) => any): number;
connect_after(
signal: K,
callback: GObject.SignalCallback,
): number;
connect_after(signal: string, callback: (...args: any[]) => any): number;
emit(
signal: K,
...args: GObject.GjsParameters extends [any, ...infer Q] ? Q : never
): void;
emit(signal: string, ...args: any[]): void;
}
namespace GLShader {
// Signal signatures
interface SignalSignatures extends GObject.Object.SignalSignatures {
'notify::resource': (pspec: GObject.ParamSpec) => void;
'notify::source': (pspec: GObject.ParamSpec) => void;
}
// Constructor properties interface
interface ConstructorProps extends GObject.Object.ConstructorProps {
resource: string;
source: GLib.Bytes;
}
}
/**
* 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;
* }
* ```
*/
class GLShader extends GObject.Object {
static $gtype: GObject.GType;
// Properties
/**
* Resource containing the source code for the shader.
*
* If the shader source is not coming from a resource, this
* will be %NULL.
*/
get resource(): string;
/**
* The source code for the shader, as a `GBytes`.
*/
get source(): GLib.Bytes;
/**
* Compile-time signal type information.
*
* This instance property is generated only for TypeScript type checking.
* It is not defined at runtime and should not be accessed in JS code.
* @internal
*/
$signals: GLShader.SignalSignatures;
// Constructors
constructor(properties?: Partial, ...args: any[]);
_init(...args: any[]): void;
static new_from_bytes(sourcecode: GLib.Bytes | Uint8Array): GLShader;
static new_from_resource(resource_path: string): GLShader;
// Signals
connect(
signal: K,
callback: GObject.SignalCallback,
): number;
connect(signal: string, callback: (...args: any[]) => any): number;
connect_after(
signal: K,
callback: GObject.SignalCallback,
): number;
connect_after(signal: string, callback: (...args: any[]) => any): number;
emit(
signal: K,
...args: GObject.GjsParameters extends [any, ...infer Q] ? Q : never
): void;
emit(signal: string, ...args: any[]): void;
// Methods
/**
* 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.
* @param renderer a `GskRenderer`
* @returns %TRUE on success, %FALSE if an error occurred
*/
compile(renderer: Renderer): boolean;
/**
* Looks for a uniform by the name `name,` and returns the index
* of the uniform, or -1 if it was not found.
* @param name uniform name
* @returns The index of the uniform, or -1
*/
find_uniform_by_name(name: string): number;
/**
* Gets the value of the uniform `idx` in the `args` block.
*
* The uniform must be of bool type.
* @param args uniform arguments
* @param idx index of the uniform
* @returns The value
*/
get_arg_bool(args: GLib.Bytes | Uint8Array, idx: number): boolean;
/**
* Gets the value of the uniform `idx` in the `args` block.
*
* The uniform must be of float type.
* @param args uniform arguments
* @param idx index of the uniform
* @returns The value
*/
get_arg_float(args: GLib.Bytes | Uint8Array, idx: number): number;
/**
* Gets the value of the uniform `idx` in the `args` block.
*
* The uniform must be of int type.
* @param args uniform arguments
* @param idx index of the uniform
* @returns The value
*/
get_arg_int(args: GLib.Bytes | Uint8Array, idx: number): number;
/**
* Gets the value of the uniform `idx` in the `args` block.
*
* The uniform must be of uint type.
* @param args uniform arguments
* @param idx index of the uniform
* @returns The value
*/
get_arg_uint(args: GLib.Bytes | Uint8Array, idx: number): number;
/**
* Gets the value of the uniform `idx` in the `args` block.
*
* The uniform must be of vec2 type.
* @param args uniform arguments
* @param idx index of the uniform
* @param out_value location to store the uniform value in
*/
get_arg_vec2(args: GLib.Bytes | Uint8Array, idx: number, out_value: Graphene.Vec2): void;
/**
* Gets the value of the uniform `idx` in the `args` block.
*
* The uniform must be of vec3 type.
* @param args uniform arguments
* @param idx index of the uniform
* @param out_value location to store the uniform value in
*/
get_arg_vec3(args: GLib.Bytes | Uint8Array, idx: number, out_value: Graphene.Vec3): void;
/**
* Gets the value of the uniform `idx` in the `args` block.
*
* The uniform must be of vec4 type.
* @param args uniform arguments
* @param idx index of the uniform
* @param out_value location to store set the uniform value in
*/
get_arg_vec4(args: GLib.Bytes | Uint8Array, idx: number, out_value: Graphene.Vec4): void;
/**
* Get the size of the data block used to specify arguments for this shader.
* @returns The size of the data block
*/
get_args_size(): number;
/**
* 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.
* @returns The number of texture inputs required by @shader
*/
get_n_textures(): number;
/**
* Get the number of declared uniforms for this shader.
* @returns The number of declared uniforms
*/
get_n_uniforms(): number;
/**
* Gets the resource path for the GLSL sourcecode being used
* to render this shader.
* @returns The resource path for the shader
*/
get_resource(): string | null;
/**
* Gets the GLSL sourcecode being used to render this shader.
* @returns The source code for the shader
*/
get_source(): GLib.Bytes;
/**
* Get the name of the declared uniform for this shader at index `idx`.
* @param idx index of the uniform
* @returns The name of the declared uniform
*/
get_uniform_name(idx: number): string;
/**
* Get the offset into the data block where data for this uniforms is stored.
* @param idx index of the uniform
* @returns The data offset
*/
get_uniform_offset(idx: number): number;
/**
* Get the type of the declared uniform for this shader at index `idx`.
* @param idx index of the uniform
* @returns The type of the declared uniform
*/
get_uniform_type(idx: number): GLUniformType;
}
namespace GLShaderNode {
// Signal signatures
interface SignalSignatures extends RenderNode.SignalSignatures {}
}
/**
* A render node using a GL shader when drawing its children nodes.
*/
class GLShaderNode extends RenderNode {
static $gtype: GObject.GType;
// Constructors
_init(...args: any[]): void;
static ['new'](
shader: GLShader,
bounds: Graphene.Rect,
args: GLib.Bytes | Uint8Array,
children?: RenderNode[] | null,
): GLShaderNode;
// Signals
connect(
signal: K,
callback: GObject.SignalCallback,
): number;
connect(signal: string, callback: (...args: any[]) => any): number;
connect_after(
signal: K,
callback: GObject.SignalCallback,
): number;
connect_after(signal: string, callback: (...args: any[]) => any): number;
emit(
signal: K,
...args: GObject.GjsParameters extends [any, ...infer Q] ? Q : never
): void;
emit(signal: string, ...args: any[]): void;
// Methods
/**
* Gets args for the node.
* @returns A `GBytes` with the uniform arguments
*/
get_args(): GLib.Bytes;
/**
* Gets one of the children.
* @param idx the position of the child to get
* @returns the @idx'th child of @node
*/
get_child(idx: number): RenderNode;
/**
* Returns the number of children
* @returns The number of children
*/
get_n_children(): number;
/**
* Gets shader code for the node.
* @returns the `GskGLShader` shader
*/
get_shader(): GLShader;
}
namespace InsetShadowNode {
// Signal signatures
interface SignalSignatures extends RenderNode.SignalSignatures {}
}
/**
* A render node for an inset shadow.
*/
class InsetShadowNode extends RenderNode {
static $gtype: GObject.GType;
// Constructors
_init(...args: any[]): void;
static ['new'](
outline: RoundedRect,
color: Gdk.RGBA,
dx: number,
dy: number,
spread: number,
blur_radius: number,
): InsetShadowNode;
// Signals
connect(
signal: K,
callback: GObject.SignalCallback,
): number;
connect(signal: string, callback: (...args: any[]) => any): number;
connect_after(
signal: K,
callback: GObject.SignalCallback,
): number;
connect_after(signal: string, callback: (...args: any[]) => any): number;
emit(
signal: K,
...args: GObject.GjsParameters extends [any, ...infer Q]
? Q
: never
): void;
emit(signal: string, ...args: any[]): void;
// Methods
/**
* Retrieves the blur radius to apply to the shadow.
* @returns the blur radius, in pixels
*/
get_blur_radius(): number;
/**
* 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.
* @returns the color of the shadow
*/
get_color(): Gdk.RGBA;
/**
* Retrieves the horizontal offset of the inset shadow.
* @returns an offset, in pixels
*/
get_dx(): number;
/**
* Retrieves the vertical offset of the inset shadow.
* @returns an offset, in pixels
*/
get_dy(): number;
/**
* Retrieves the outline rectangle of the inset shadow.
* @returns a rounded rectangle
*/
get_outline(): RoundedRect;
/**
* Retrieves how much the shadow spreads inwards.
* @returns the size of the shadow, in pixels
*/
get_spread(): number;
}
namespace LinearGradientNode {
// Signal signatures
interface SignalSignatures extends RenderNode.SignalSignatures {}
}
/**
* A render node for a linear gradient.
*/
class LinearGradientNode extends RenderNode {
static $gtype: GObject.GType;
// Constructors
_init(...args: any[]): void;
static ['new'](
bounds: Graphene.Rect,
start: Graphene.Point,
end: Graphene.Point,
color_stops: ColorStop[],
): LinearGradientNode;
// Signals
connect(
signal: K,
callback: GObject.SignalCallback,
): number;
connect(signal: string, callback: (...args: any[]) => any): number;
connect_after(
signal: K,
callback: GObject.SignalCallback,
): number;
connect_after(signal: string, callback: (...args: any[]) => any): number;
emit(
signal: K,
...args: GObject.GjsParameters extends [any, ...infer Q]
? Q
: never
): void;
emit(signal: string, ...args: any[]): void;
// Methods
/**
* Retrieves the color stops in the gradient.
* @returns the color stops in the gradient
*/
get_color_stops(): ColorStop[];
/**
* Retrieves the final point of the linear gradient.
* @returns the final point
*/
get_end(): Graphene.Point;
/**
* Retrieves the number of color stops in the gradient.
* @returns the number of color stops
*/
get_n_color_stops(): number;
/**
* Retrieves the initial point of the linear gradient.
* @returns the initial point
*/
get_start(): Graphene.Point;
}
namespace MaskNode {
// Signal signatures
interface SignalSignatures extends RenderNode.SignalSignatures {}
}
/**
* A render node masking one child node with another.
*/
class MaskNode extends RenderNode {
static $gtype: GObject.GType;
// Constructors
_init(...args: any[]): void;
static ['new'](source: RenderNode, mask: RenderNode, mask_mode: MaskMode): MaskNode;
// Signals
connect(
signal: K,
callback: GObject.SignalCallback,
): number;
connect(signal: string, callback: (...args: any[]) => any): number;
connect_after(
signal: K,
callback: GObject.SignalCallback,
): number;
connect_after(signal: string, callback: (...args: any[]) => any): number;
emit(
signal: K,
...args: GObject.GjsParameters extends [any, ...infer Q] ? Q : never
): void;
emit(signal: string, ...args: any[]): void;
// Methods
/**
* Retrieves the mask `GskRenderNode` child of the `node`.
* @returns the mask child node
*/
get_mask(): RenderNode;
/**
* Retrieves the mask mode used by `node`.
* @returns the mask mode
*/
get_mask_mode(): MaskMode;
/**
* Retrieves the source `GskRenderNode` child of the `node`.
* @returns the source child node
*/
get_source(): RenderNode;
}
namespace NglRenderer {
// Signal signatures
interface SignalSignatures extends Renderer.SignalSignatures {
'notify::realized': (pspec: GObject.ParamSpec) => void;
'notify::surface': (pspec: GObject.ParamSpec) => void;
}
// Constructor properties interface
interface ConstructorProps extends Renderer.ConstructorProps {}
}
/**
* A GL based renderer.
*
* See [class`Gsk`.Renderer].
*/
class NglRenderer extends Renderer {
static $gtype: GObject.GType;
/**
* Compile-time signal type information.
*
* This instance property is generated only for TypeScript type checking.
* It is not defined at runtime and should not be accessed in JS code.
* @internal
*/
$signals: NglRenderer.SignalSignatures;
// Constructors
constructor(properties?: Partial, ...args: any[]);
_init(...args: any[]): void;
static ['new'](): NglRenderer;
// Signals
connect(
signal: K,
callback: GObject.SignalCallback,
): number;
connect(signal: string, callback: (...args: any[]) => any): number;
connect_after(
signal: K,
callback: GObject.SignalCallback,
): number;
connect_after(signal: string, callback: (...args: any[]) => any): number;
emit(
signal: K,
...args: GObject.GjsParameters extends [any, ...infer Q] ? Q : never
): void;
emit(signal: string, ...args: any[]): void;
}
namespace OpacityNode {
// Signal signatures
interface SignalSignatures extends RenderNode.SignalSignatures {}
}
/**
* A render node controlling the opacity of its single child node.
*/
class OpacityNode extends RenderNode {
static $gtype: GObject.GType;
// Constructors
_init(...args: any[]): void;
static ['new'](child: RenderNode, opacity: number): OpacityNode;
// Signals
connect(
signal: K,
callback: GObject.SignalCallback,
): number;
connect(signal: string, callback: (...args: any[]) => any): number;
connect_after(
signal: K,
callback: GObject.SignalCallback,
): number;
connect_after(signal: string, callback: (...args: any[]) => any): number;
emit(
signal: K,
...args: GObject.GjsParameters extends [any, ...infer Q] ? Q : never
): void;
emit(signal: string, ...args: any[]): void;
// Methods
/**
* Gets the child node that is getting opacityed by the given `node`.
* @returns The child that is getting opacityed
*/
get_child(): RenderNode;
/**
* Gets the transparency factor for an opacity node.
* @returns the opacity factor
*/
get_opacity(): number;
}
namespace OutsetShadowNode {
// Signal signatures
interface SignalSignatures extends RenderNode.SignalSignatures {}
}
/**
* A render node for an outset shadow.
*/
class OutsetShadowNode extends RenderNode {
static $gtype: GObject.GType;
// Constructors
_init(...args: any[]): void;
static ['new'](
outline: RoundedRect,
color: Gdk.RGBA,
dx: number,
dy: number,
spread: number,
blur_radius: number,
): OutsetShadowNode;
// Signals
connect(
signal: K,
callback: GObject.SignalCallback,
): number;
connect(signal: string, callback: (...args: any[]) => any): number;
connect_after(
signal: K,
callback: GObject.SignalCallback,
): number;
connect_after(signal: string, callback: (...args: any[]) => any): number;
emit(
signal: K,
...args: GObject.GjsParameters extends [any, ...infer Q]
? Q
: never
): void;
emit(signal: string, ...args: any[]): void;
// Methods
/**
* Retrieves the blur radius of the shadow.
* @returns the blur radius, in pixels
*/
get_blur_radius(): number;
/**
* 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.
* @returns a color
*/
get_color(): Gdk.RGBA;
/**
* Retrieves the horizontal offset of the outset shadow.
* @returns an offset, in pixels
*/
get_dx(): number;
/**
* Retrieves the vertical offset of the outset shadow.
* @returns an offset, in pixels
*/
get_dy(): number;
/**
* Retrieves the outline rectangle of the outset shadow.
* @returns a rounded rectangle
*/
get_outline(): RoundedRect;
/**
* Retrieves how much the shadow spreads outwards.
* @returns the size of the shadow, in pixels
*/
get_spread(): number;
}
namespace RadialGradientNode {
// Signal signatures
interface SignalSignatures extends RenderNode.SignalSignatures {}
}
/**
* A render node for a radial gradient.
*/
class RadialGradientNode extends RenderNode {
static $gtype: GObject.GType;
// Constructors
_init(...args: any[]): void;
static ['new'](
bounds: Graphene.Rect,
center: Graphene.Point,
hradius: number,
vradius: number,
start: number,
end: number,
color_stops: ColorStop[],
): RadialGradientNode;
// Signals
connect(
signal: K,
callback: GObject.SignalCallback,
): number;
connect(signal: string, callback: (...args: any[]) => any): number;
connect_after(
signal: K,
callback: GObject.SignalCallback,
): number;
connect_after(signal: string, callback: (...args: any[]) => any): number;
emit(
signal: K,
...args: GObject.GjsParameters extends [any, ...infer Q]
? Q
: never
): void;
emit(signal: string, ...args: any[]): void;
// Methods
/**
* Retrieves the center pointer for the gradient.
* @returns the center point for the gradient
*/
get_center(): Graphene.Point;
/**
* Retrieves the color stops in the gradient.
* @returns the color stops in the gradient
*/
get_color_stops(): ColorStop[];
/**
* Retrieves the end value for the gradient.
* @returns the end value for the gradient
*/
get_end(): number;
/**
* Retrieves the horizontal radius for the gradient.
* @returns the horizontal radius for the gradient
*/
get_hradius(): number;
/**
* Retrieves the number of color stops in the gradient.
* @returns the number of color stops
*/
get_n_color_stops(): number;
/**
* Retrieves the start value for the gradient.
* @returns the start value for the gradient
*/
get_start(): number;
/**
* Retrieves the vertical radius for the gradient.
* @returns the vertical radius for the gradient
*/
get_vradius(): number;
}
namespace RenderNode {
// Signal signatures
interface SignalSignatures extends GObject.Object.SignalSignatures {}
}
/**
* 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.
*/
abstract class RenderNode {
static $gtype: GObject.GType;
// Constructors
_init(...args: any[]): void;
// Signals
connect(
signal: K,
callback: GObject.SignalCallback,
): number;
connect(signal: string, callback: (...args: any[]) => any): number;
connect_after(
signal: K,
callback: GObject.SignalCallback,
): number;
connect_after(signal: string, callback: (...args: any[]) => any): number;
emit(
signal: K,
...args: GObject.GjsParameters extends [any, ...infer Q] ? Q : never
): void;
emit(signal: string, ...args: any[]): void;
// Static methods
/**
* Loads data previously created via [method`Gsk`.RenderNode.serialize].
*
* For a discussion of the supported format, see that function.
* @param bytes the bytes containing the data
* @param error_func callback on parsing errors
*/
static deserialize(bytes: GLib.Bytes | Uint8Array, error_func?: ParseErrorFunc | null): RenderNode | null;
// Methods
/**
* 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.
* @param cr cairo context to draw to
*/
draw(cr: cairo.Context): void;
/**
* Retrieves the boundaries of the `node`.
*
* The node will not draw outside of its boundaries.
*/
get_bounds(): Graphene.Rect;
/**
* Returns the type of the render node.
* @returns the type of @node
*/
get_node_type(): RenderNodeType;
/**
* 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.
* @returns true if part or all of the rendernode is opaque, false if no opaque region could be found.
*/
get_opaque_rect(): [boolean, Graphene.Rect];
/**
* Acquires a reference on the given `GskRenderNode`.
* @returns the render node with an additional reference
*/
ref(): RenderNode;
/**
* 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.
* @returns a `GBytes` representing the node.
*/
serialize(): GLib.Bytes;
/**
* Releases a reference on the given `GskRenderNode`.
*
* If the reference was the last, the resources associated to the `node` are
* freed.
*/
unref(): void;
/**
* 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.
* @param filename the file to save it to
* @returns true if saving was successful
*/
write_to_file(filename: string): boolean;
}
namespace Renderer {
// Signal signatures
interface SignalSignatures extends GObject.Object.SignalSignatures {
'notify::realized': (pspec: GObject.ParamSpec) => void;
'notify::surface': (pspec: GObject.ParamSpec) => void;
}
// Constructor properties interface
interface ConstructorProps extends GObject.Object.ConstructorProps {
realized: boolean;
surface: Gdk.Surface;
}
}
/**
* 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.
*/
abstract class Renderer extends GObject.Object {
static $gtype: GObject.GType;
// Properties
/**
* Whether the renderer has been associated with a surface or draw context.
*/
get realized(): boolean;
/**
* The surface associated with renderer.
*/
get surface(): Gdk.Surface;
/**
* Compile-time signal type information.
*
* This instance property is generated only for TypeScript type checking.
* It is not defined at runtime and should not be accessed in JS code.
* @internal
*/
$signals: Renderer.SignalSignatures;
// Constructors
constructor(properties?: Partial, ...args: any[]);
_init(...args: any[]): void;
static new_for_surface(surface: Gdk.Surface): Renderer;
// Signals
connect(
signal: K,
callback: GObject.SignalCallback,
): number;
connect(signal: string, callback: (...args: any[]) => any): number;
connect_after(
signal: K,
callback: GObject.SignalCallback,
): number;
connect_after(signal: string, callback: (...args: any[]) => any): number;
emit(
signal: K,
...args: GObject.GjsParameters extends [any, ...infer Q] ? Q : never
): void;
emit(signal: string, ...args: any[]): void;
// Methods
/**
* Retrieves the surface that the renderer is associated with.
*
* If the renderer has not been realized yet, `NULL` will be returned.
* @returns the surface
*/
get_surface(): Gdk.Surface | null;
/**
* Checks whether the renderer is realized or not.
* @returns true if the renderer was realized, false otherwise
*/
is_realized(): boolean;
/**
* 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.
* @param surface the surface that renderer will be used on
* @returns whether the renderer was successfully realized
*/
realize(surface?: Gdk.Surface | null): boolean;
/**
* Creates the resources needed by the renderer.
*
* Note that it is mandatory to call [method`Gsk`.Renderer.unrealize]
* before destroying the renderer.
* @param display the display that the renderer will be used on
* @returns whether the renderer was successfully realized
*/
realize_for_display(display: Gdk.Display): boolean;
/**
* 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.
* @param root the render node to render
* @param region the `cairo_region_t` that must be redrawn or `NULL` for the whole surface
*/
render(root: RenderNode, region?: cairo.Region | null): void;
/**
* 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.
* @param root the render node to render
* @param viewport the section to draw or `NULL` to use @root's bounds
* @returns a texture with the rendered contents of @root
*/
render_texture(root: RenderNode, viewport?: Graphene.Rect | null): Gdk.Texture;
/**
* Releases all the resources created by [method`Gsk`.Renderer.realize].
*/
unrealize(): void;
}
namespace RepeatNode {
// Signal signatures
interface SignalSignatures extends RenderNode.SignalSignatures {}
}
/**
* A render node repeating its single child node.
*/
class RepeatNode extends RenderNode {
static $gtype: GObject.GType;
// Constructors
_init(...args: any[]): void;
static ['new'](bounds: Graphene.Rect, child: RenderNode, child_bounds?: Graphene.Rect | null): RepeatNode;
// Signals
connect(
signal: K,
callback: GObject.SignalCallback,
): number;
connect(signal: string, callback: (...args: any[]) => any): number;
connect_after(
signal: K,
callback: GObject.SignalCallback,
): number;
connect_after(signal: string, callback: (...args: any[]) => any): number;
emit(
signal: K,
...args: GObject.GjsParameters extends [any, ...infer Q] ? Q : never
): void;
emit(signal: string, ...args: any[]): void;
// Methods
/**
* Retrieves the child of `node`.
* @returns a `GskRenderNode`
*/
get_child(): RenderNode;
/**
* Retrieves the bounding rectangle of the child of `node`.
* @returns a bounding rectangle
*/
get_child_bounds(): Graphene.Rect;
}
namespace RepeatingLinearGradientNode {
// Signal signatures
interface SignalSignatures extends RenderNode.SignalSignatures {}
}
/**
* A render node for a repeating linear gradient.
*/
class RepeatingLinearGradientNode extends RenderNode {
static $gtype: GObject.GType;
// Constructors
_init(...args: any[]): void;
static ['new'](
bounds: Graphene.Rect,
start: Graphene.Point,
end: Graphene.Point,
color_stops: ColorStop[],
): RepeatingLinearGradientNode;
// Signals
connect(
signal: K,
callback: GObject.SignalCallback,
): number;
connect(signal: string, callback: (...args: any[]) => any): number;
connect_after(
signal: K,
callback: GObject.SignalCallback,
): number;
connect_after(signal: string, callback: (...args: any[]) => any): number;
emit(
signal: K,
...args: GObject.GjsParameters extends [
any,
...infer Q,
]
? Q
: never
): void;
emit(signal: string, ...args: any[]): void;
}
namespace RepeatingRadialGradientNode {
// Signal signatures
interface SignalSignatures extends RenderNode.SignalSignatures {}
}
/**
* A render node for a repeating radial gradient.
*/
class RepeatingRadialGradientNode extends RenderNode {
static $gtype: GObject.GType;
// Constructors
_init(...args: any[]): void;
static ['new'](
bounds: Graphene.Rect,
center: Graphene.Point,
hradius: number,
vradius: number,
start: number,
end: number,
color_stops: ColorStop[],
): RepeatingRadialGradientNode;
// Signals
connect(
signal: K,
callback: GObject.SignalCallback,
): number;
connect(signal: string, callback: (...args: any[]) => any): number;
connect_after(
signal: K,
callback: GObject.SignalCallback,
): number;
connect_after(signal: string, callback: (...args: any[]) => any): number;
emit(
signal: K,
...args: GObject.GjsParameters extends [
any,
...infer Q,
]
? Q
: never
): void;
emit(signal: string, ...args: any[]): void;
}
namespace RoundedClipNode {
// Signal signatures
interface SignalSignatures extends RenderNode.SignalSignatures {}
}
/**
* A render node applying a rounded rectangle clip to its single child.
*/
class RoundedClipNode extends RenderNode {
static $gtype: GObject.GType;
// Constructors
_init(...args: any[]): void;
static ['new'](child: RenderNode, clip: RoundedRect): RoundedClipNode;
// Signals
connect(
signal: K,
callback: GObject.SignalCallback,
): number;
connect(signal: string, callback: (...args: any[]) => any): number;
connect_after(
signal: K,
callback: GObject.SignalCallback,
): number;
connect_after(signal: string, callback: (...args: any[]) => any): number;
emit(
signal: K,
...args: GObject.GjsParameters extends [any, ...infer Q]
? Q
: never
): void;
emit(signal: string, ...args: any[]): void;
// Methods
/**
* Gets the child node that is getting clipped by the given `node`.
* @returns The child that is getting clipped
*/
get_child(): RenderNode;
/**
* Retrieves the rounded rectangle used to clip the contents of the `node`.
* @returns a rounded rectangle
*/
get_clip(): RoundedRect;
}
namespace ShadowNode {
// Signal signatures
interface SignalSignatures extends RenderNode.SignalSignatures {}
}
/**
* A render node drawing one or more shadows behind its single child node.
*/
class ShadowNode extends RenderNode {
static $gtype: GObject.GType;
// Constructors
_init(...args: any[]): void;
static ['new'](child: RenderNode, shadows: Shadow[]): ShadowNode;
// Signals
connect(
signal: K,
callback: GObject.SignalCallback,
): number;
connect(signal: string, callback: (...args: any[]) => any): number;
connect_after(
signal: K,
callback: GObject.SignalCallback,
): number;
connect_after(signal: string, callback: (...args: any[]) => any): number;
emit(
signal: K,
...args: GObject.GjsParameters extends [any, ...infer Q] ? Q : never
): void;
emit(signal: string, ...args: any[]): void;
// Methods
/**
* Retrieves the child `GskRenderNode` of the shadow `node`.
* @returns the child render node
*/
get_child(): RenderNode;
/**
* Retrieves the number of shadows in the `node`.
* @returns the number of shadows.
*/
get_n_shadows(): number;
/**
* Retrieves the shadow data at the given index `i`.
* @param i the given index
* @returns the shadow data
*/
get_shadow(i: number): Shadow;
}
namespace StrokeNode {
// Signal signatures
interface SignalSignatures extends RenderNode.SignalSignatures {}
}
/**
* A render node that will fill the area determined by stroking the the given
* [struct`Gsk`.Path] using the [struct`Gsk`.Stroke] attributes.
*/
class StrokeNode extends RenderNode {
static $gtype: GObject.GType;
// Constructors
_init(...args: any[]): void;
static ['new'](child: RenderNode, path: Path, stroke: Stroke): StrokeNode;
// Signals
connect(
signal: K,
callback: GObject.SignalCallback,
): number;
connect(signal: string, callback: (...args: any[]) => any): number;
connect_after(
signal: K,
callback: GObject.SignalCallback,
): number;
connect_after(signal: string, callback: (...args: any[]) => any): number;
emit(
signal: K,
...args: GObject.GjsParameters extends [any, ...infer Q] ? Q : never
): void;
emit(signal: string, ...args: any[]): void;
// Methods
/**
* Gets the child node that is getting drawn by the given `node`.
* @returns The child that is getting drawn
*/
get_child(): RenderNode;
/**
* Retrieves the path that will be stroked with the contents of
* the `node`.
* @returns a #GskPath
*/
get_path(): Path;
/**
* Retrieves the stroke attributes used in this `node`.
* @returns a #GskStroke
*/
get_stroke(): Stroke;
}
namespace SubsurfaceNode {
// Signal signatures
interface SignalSignatures extends RenderNode.SignalSignatures {}
}
/**
* A render node that potentially diverts a part of the scene graph to a subsurface.
*/
class SubsurfaceNode extends RenderNode {
static $gtype: GObject.GType;
// Constructors
_init(...args: any[]): void;
// Signals
connect(
signal: K,
callback: GObject.SignalCallback,
): number;
connect(signal: string, callback: (...args: any[]) => any): number;
connect_after(
signal: K,
callback: GObject.SignalCallback,
): number;
connect_after(signal: string, callback: (...args: any[]) => any): number;
emit(
signal: K,
...args: GObject.GjsParameters extends [any, ...infer Q] ? Q : never
): void;
emit(signal: string, ...args: any[]): void;
// Methods
/**
* Gets the child node that is getting drawn by the given `node`.
* @returns the child `GskRenderNode`
*/
get_child(): RenderNode;
}
namespace TextNode {
// Signal signatures
interface SignalSignatures extends RenderNode.SignalSignatures {}
}
/**
* A render node drawing a set of glyphs.
*/
class TextNode extends RenderNode {
static $gtype: GObject.GType;
// Constructors
_init(...args: any[]): void;
static ['new'](
font: Pango.Font,
glyphs: Pango.GlyphString,
color: Gdk.RGBA,
offset: Graphene.Point,
): TextNode;
// Signals
connect
* 
* 
*