// This file was generated by gir (https://github.com/gtk-rs/gir)
// from gir-files (https://github.com/gtk-rs/gir-files.git)
// DO NOT EDIT

#![allow(non_camel_case_types, non_upper_case_globals, non_snake_case)]
#![allow(
    clippy::approx_constant,
    clippy::type_complexity,
    clippy::unreadable_literal,
    clippy::upper_case_acronyms
)]
#![cfg_attr(feature = "dox", feature(doc_cfg))]

use cairo_sys as cairo;
use gdk4_sys as gdk;
use glib_sys as glib;
use gobject_sys as gobject;
use graphene_sys as graphene;
use pango_sys as pango;

#[allow(unused_imports)]
use libc::{
    c_char, c_double, c_float, c_int, c_long, c_short, c_uchar, c_uint, c_ulong, c_ushort, c_void,
    intptr_t, size_t, ssize_t, time_t, uintptr_t, FILE,
};

#[allow(unused_imports)]
use glib::{gboolean, gconstpointer, gpointer, GType};

// Enums
pub type GskBlendMode = c_int;
pub const GSK_BLEND_MODE_DEFAULT: GskBlendMode = 0;
pub const GSK_BLEND_MODE_MULTIPLY: GskBlendMode = 1;
pub const GSK_BLEND_MODE_SCREEN: GskBlendMode = 2;
pub const GSK_BLEND_MODE_OVERLAY: GskBlendMode = 3;
pub const GSK_BLEND_MODE_DARKEN: GskBlendMode = 4;
pub const GSK_BLEND_MODE_LIGHTEN: GskBlendMode = 5;
pub const GSK_BLEND_MODE_COLOR_DODGE: GskBlendMode = 6;
pub const GSK_BLEND_MODE_COLOR_BURN: GskBlendMode = 7;
pub const GSK_BLEND_MODE_HARD_LIGHT: GskBlendMode = 8;
pub const GSK_BLEND_MODE_SOFT_LIGHT: GskBlendMode = 9;
pub const GSK_BLEND_MODE_DIFFERENCE: GskBlendMode = 10;
pub const GSK_BLEND_MODE_EXCLUSION: GskBlendMode = 11;
pub const GSK_BLEND_MODE_COLOR: GskBlendMode = 12;
pub const GSK_BLEND_MODE_HUE: GskBlendMode = 13;
pub const GSK_BLEND_MODE_SATURATION: GskBlendMode = 14;
pub const GSK_BLEND_MODE_LUMINOSITY: GskBlendMode = 15;

pub type GskCorner = c_int;
pub const GSK_CORNER_TOP_LEFT: GskCorner = 0;
pub const GSK_CORNER_TOP_RIGHT: GskCorner = 1;
pub const GSK_CORNER_BOTTOM_RIGHT: GskCorner = 2;
pub const GSK_CORNER_BOTTOM_LEFT: GskCorner = 3;

pub type GskGLUniformType = c_int;
pub const GSK_GL_UNIFORM_TYPE_NONE: GskGLUniformType = 0;
pub const GSK_GL_UNIFORM_TYPE_FLOAT: GskGLUniformType = 1;
pub const GSK_GL_UNIFORM_TYPE_INT: GskGLUniformType = 2;
pub const GSK_GL_UNIFORM_TYPE_UINT: GskGLUniformType = 3;
pub const GSK_GL_UNIFORM_TYPE_BOOL: GskGLUniformType = 4;
pub const GSK_GL_UNIFORM_TYPE_VEC2: GskGLUniformType = 5;
pub const GSK_GL_UNIFORM_TYPE_VEC3: GskGLUniformType = 6;
pub const GSK_GL_UNIFORM_TYPE_VEC4: GskGLUniformType = 7;

pub type GskRenderNodeType = c_int;
pub const GSK_NOT_A_RENDER_NODE: GskRenderNodeType = 0;
pub const GSK_CONTAINER_NODE: GskRenderNodeType = 1;
pub const GSK_CAIRO_NODE: GskRenderNodeType = 2;
pub const GSK_COLOR_NODE: GskRenderNodeType = 3;
pub const GSK_LINEAR_GRADIENT_NODE: GskRenderNodeType = 4;
pub const GSK_REPEATING_LINEAR_GRADIENT_NODE: GskRenderNodeType = 5;
pub const GSK_RADIAL_GRADIENT_NODE: GskRenderNodeType = 6;
pub const GSK_REPEATING_RADIAL_GRADIENT_NODE: GskRenderNodeType = 7;
pub const GSK_CONIC_GRADIENT_NODE: GskRenderNodeType = 8;
pub const GSK_BORDER_NODE: GskRenderNodeType = 9;
pub const GSK_TEXTURE_NODE: GskRenderNodeType = 10;
pub const GSK_INSET_SHADOW_NODE: GskRenderNodeType = 11;
pub const GSK_OUTSET_SHADOW_NODE: GskRenderNodeType = 12;
pub const GSK_TRANSFORM_NODE: GskRenderNodeType = 13;
pub const GSK_OPACITY_NODE: GskRenderNodeType = 14;
pub const GSK_COLOR_MATRIX_NODE: GskRenderNodeType = 15;
pub const GSK_REPEAT_NODE: GskRenderNodeType = 16;
pub const GSK_CLIP_NODE: GskRenderNodeType = 17;
pub const GSK_ROUNDED_CLIP_NODE: GskRenderNodeType = 18;
pub const GSK_SHADOW_NODE: GskRenderNodeType = 19;
pub const GSK_BLEND_NODE: GskRenderNodeType = 20;
pub const GSK_CROSS_FADE_NODE: GskRenderNodeType = 21;
pub const GSK_TEXT_NODE: GskRenderNodeType = 22;
pub const GSK_BLUR_NODE: GskRenderNodeType = 23;
pub const GSK_DEBUG_NODE: GskRenderNodeType = 24;
pub const GSK_GL_SHADER_NODE: GskRenderNodeType = 25;

pub type GskScalingFilter = c_int;
pub const GSK_SCALING_FILTER_LINEAR: GskScalingFilter = 0;
pub const GSK_SCALING_FILTER_NEAREST: GskScalingFilter = 1;
pub const GSK_SCALING_FILTER_TRILINEAR: GskScalingFilter = 2;

pub type GskSerializationError = c_int;
pub const GSK_SERIALIZATION_UNSUPPORTED_FORMAT: GskSerializationError = 0;
pub const GSK_SERIALIZATION_UNSUPPORTED_VERSION: GskSerializationError = 1;
pub const GSK_SERIALIZATION_INVALID_DATA: GskSerializationError = 2;

pub type GskTransformCategory = c_int;
pub const GSK_TRANSFORM_CATEGORY_UNKNOWN: GskTransformCategory = 0;
pub const GSK_TRANSFORM_CATEGORY_ANY: GskTransformCategory = 1;
pub const GSK_TRANSFORM_CATEGORY_3D: GskTransformCategory = 2;
pub const GSK_TRANSFORM_CATEGORY_2D: GskTransformCategory = 3;
pub const GSK_TRANSFORM_CATEGORY_2D_AFFINE: GskTransformCategory = 4;
pub const GSK_TRANSFORM_CATEGORY_2D_TRANSLATE: GskTransformCategory = 5;
pub const GSK_TRANSFORM_CATEGORY_IDENTITY: GskTransformCategory = 6;

// Callbacks
pub type GskParseErrorFunc = Option<
    unsafe extern "C" fn(
        *const GskParseLocation,
        *const GskParseLocation,
        *const glib::GError,
        gpointer,
    ),
>;

// Records
#[repr(C)]
pub struct _GskBroadwayRendererClass(c_void);

pub type GskBroadwayRendererClass = *mut _GskBroadwayRendererClass;

#[repr(C)]
pub struct _GskCairoRendererClass(c_void);

pub type GskCairoRendererClass = *mut _GskCairoRendererClass;

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GskColorStop {
    pub offset: c_float,
    pub color: gdk::GdkRGBA,
}

impl ::std::fmt::Debug for GskColorStop {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GskColorStop @ {:p}", self))
            .field("offset", &self.offset)
            .field("color", &self.color)
            .finish()
    }
}

#[repr(C)]
pub struct _GskGLRendererClass(c_void);

pub type GskGLRendererClass = *mut _GskGLRendererClass;

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GskGLShaderClass {
    pub parent_class: gobject::GObjectClass,
}

impl ::std::fmt::Debug for GskGLShaderClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GskGLShaderClass @ {:p}", self))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[repr(C)]
pub struct _GskNglRendererClass(c_void);

pub type GskNglRendererClass = *mut _GskNglRendererClass;

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GskParseLocation {
    pub bytes: size_t,
    pub chars: size_t,
    pub lines: size_t,
    pub line_bytes: size_t,
    pub line_chars: size_t,
}

impl ::std::fmt::Debug for GskParseLocation {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GskParseLocation @ {:p}", self))
            .field("bytes", &self.bytes)
            .field("chars", &self.chars)
            .field("lines", &self.lines)
            .field("line_bytes", &self.line_bytes)
            .field("line_chars", &self.line_chars)
            .finish()
    }
}

#[repr(C)]
pub struct _GskRendererClass(c_void);

pub type GskRendererClass = *mut _GskRendererClass;

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GskRoundedRect {
    pub bounds: graphene::graphene_rect_t,
    pub corner: [graphene::graphene_size_t; 4],
}

impl ::std::fmt::Debug for GskRoundedRect {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GskRoundedRect @ {:p}", self))
            .field("bounds", &self.bounds)
            .field("corner", &self.corner)
            .finish()
    }
}

#[repr(C)]
pub struct GskShaderArgsBuilder(c_void);

impl ::std::fmt::Debug for GskShaderArgsBuilder {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GskShaderArgsBuilder @ {:p}", self))
            .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GskShadow {
    pub color: gdk::GdkRGBA,
    pub dx: c_float,
    pub dy: c_float,
    pub radius: c_float,
}

impl ::std::fmt::Debug for GskShadow {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GskShadow @ {:p}", self))
            .field("color", &self.color)
            .field("dx", &self.dx)
            .field("dy", &self.dy)
            .field("radius", &self.radius)
            .finish()
    }
}

#[repr(C)]
pub struct GskTransform(c_void);

impl ::std::fmt::Debug for GskTransform {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GskTransform @ {:p}", self))
            .finish()
    }
}

// Classes
#[repr(C)]
pub struct GskBlendNode(c_void);

impl ::std::fmt::Debug for GskBlendNode {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GskBlendNode @ {:p}", self))
            .finish()
    }
}

#[repr(C)]
pub struct GskBlurNode(c_void);

impl ::std::fmt::Debug for GskBlurNode {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GskBlurNode @ {:p}", self))
            .finish()
    }
}

#[repr(C)]
pub struct GskBorderNode(c_void);

impl ::std::fmt::Debug for GskBorderNode {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GskBorderNode @ {:p}", self))
            .finish()
    }
}

#[repr(C)]
pub struct GskBroadwayRenderer(c_void);

impl ::std::fmt::Debug for GskBroadwayRenderer {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GskBroadwayRenderer @ {:p}", self))
            .finish()
    }
}

#[repr(C)]
pub struct GskCairoNode(c_void);

impl ::std::fmt::Debug for GskCairoNode {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GskCairoNode @ {:p}", self))
            .finish()
    }
}

#[repr(C)]
pub struct GskCairoRenderer(c_void);

impl ::std::fmt::Debug for GskCairoRenderer {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GskCairoRenderer @ {:p}", self))
            .finish()
    }
}

#[repr(C)]
pub struct GskClipNode(c_void);

impl ::std::fmt::Debug for GskClipNode {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GskClipNode @ {:p}", self))
            .finish()
    }
}

#[repr(C)]
pub struct GskColorMatrixNode(c_void);

impl ::std::fmt::Debug for GskColorMatrixNode {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GskColorMatrixNode @ {:p}", self))
            .finish()
    }
}

#[repr(C)]
pub struct GskColorNode(c_void);

impl ::std::fmt::Debug for GskColorNode {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GskColorNode @ {:p}", self))
            .finish()
    }
}

#[repr(C)]
pub struct GskConicGradientNode(c_void);

impl ::std::fmt::Debug for GskConicGradientNode {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GskConicGradientNode @ {:p}", self))
            .finish()
    }
}

#[repr(C)]
pub struct GskContainerNode(c_void);

impl ::std::fmt::Debug for GskContainerNode {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GskContainerNode @ {:p}", self))
            .finish()
    }
}

#[repr(C)]
pub struct GskCrossFadeNode(c_void);

impl ::std::fmt::Debug for GskCrossFadeNode {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GskCrossFadeNode @ {:p}", self))
            .finish()
    }
}

#[repr(C)]
pub struct GskDebugNode(c_void);

impl ::std::fmt::Debug for GskDebugNode {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GskDebugNode @ {:p}", self))
            .finish()
    }
}

#[repr(C)]
pub struct GskGLRenderer(c_void);

impl ::std::fmt::Debug for GskGLRenderer {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GskGLRenderer @ {:p}", self))
            .finish()
    }
}

#[repr(C)]
pub struct GskGLShader(c_void);

impl ::std::fmt::Debug for GskGLShader {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GskGLShader @ {:p}", self))
            .finish()
    }
}

#[repr(C)]
pub struct GskGLShaderNode(c_void);

impl ::std::fmt::Debug for GskGLShaderNode {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GskGLShaderNode @ {:p}", self))
            .finish()
    }
}

#[repr(C)]
pub struct GskInsetShadowNode(c_void);

impl ::std::fmt::Debug for GskInsetShadowNode {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GskInsetShadowNode @ {:p}", self))
            .finish()
    }
}

#[repr(C)]
pub struct GskLinearGradientNode(c_void);

impl ::std::fmt::Debug for GskLinearGradientNode {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GskLinearGradientNode @ {:p}", self))
            .finish()
    }
}

#[repr(C)]
pub struct GskNglRenderer(c_void);

impl ::std::fmt::Debug for GskNglRenderer {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GskNglRenderer @ {:p}", self))
            .finish()
    }
}

#[repr(C)]
pub struct GskOpacityNode(c_void);

impl ::std::fmt::Debug for GskOpacityNode {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GskOpacityNode @ {:p}", self))
            .finish()
    }
}

#[repr(C)]
pub struct GskOutsetShadowNode(c_void);

impl ::std::fmt::Debug for GskOutsetShadowNode {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GskOutsetShadowNode @ {:p}", self))
            .finish()
    }
}

#[repr(C)]
pub struct GskRadialGradientNode(c_void);

impl ::std::fmt::Debug for GskRadialGradientNode {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GskRadialGradientNode @ {:p}", self))
            .finish()
    }
}

#[repr(C)]
pub struct GskRenderNode(c_void);

impl ::std::fmt::Debug for GskRenderNode {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GskRenderNode @ {:p}", self))
            .finish()
    }
}

#[repr(C)]
pub struct GskRenderer(c_void);

impl ::std::fmt::Debug for GskRenderer {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GskRenderer @ {:p}", self))
            .finish()
    }
}

#[repr(C)]
pub struct GskRepeatNode(c_void);

impl ::std::fmt::Debug for GskRepeatNode {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GskRepeatNode @ {:p}", self))
            .finish()
    }
}

#[repr(C)]
pub struct GskRepeatingLinearGradientNode(c_void);

impl ::std::fmt::Debug for GskRepeatingLinearGradientNode {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GskRepeatingLinearGradientNode @ {:p}", self))
            .finish()
    }
}

#[repr(C)]
pub struct GskRepeatingRadialGradientNode(c_void);

impl ::std::fmt::Debug for GskRepeatingRadialGradientNode {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GskRepeatingRadialGradientNode @ {:p}", self))
            .finish()
    }
}

#[repr(C)]
pub struct GskRoundedClipNode(c_void);

impl ::std::fmt::Debug for GskRoundedClipNode {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GskRoundedClipNode @ {:p}", self))
            .finish()
    }
}

#[repr(C)]
pub struct GskShadowNode(c_void);

impl ::std::fmt::Debug for GskShadowNode {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GskShadowNode @ {:p}", self))
            .finish()
    }
}

#[repr(C)]
pub struct GskTextNode(c_void);

impl ::std::fmt::Debug for GskTextNode {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GskTextNode @ {:p}", self))
            .finish()
    }
}

#[repr(C)]
pub struct GskTextureNode(c_void);

impl ::std::fmt::Debug for GskTextureNode {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GskTextureNode @ {:p}", self))
            .finish()
    }
}

#[repr(C)]
pub struct GskTransformNode(c_void);

impl ::std::fmt::Debug for GskTransformNode {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GskTransformNode @ {:p}", self))
            .finish()
    }
}

#[link(name = "gtk-4")]
extern "C" {

    //=========================================================================
    // GskBlendMode
    //=========================================================================
    pub fn gsk_blend_mode_get_type() -> GType;

    //=========================================================================
    // GskCorner
    //=========================================================================
    pub fn gsk_corner_get_type() -> GType;

    //=========================================================================
    // GskGLUniformType
    //=========================================================================
    pub fn gsk_gl_uniform_type_get_type() -> GType;

    //=========================================================================
    // GskRenderNodeType
    //=========================================================================
    pub fn gsk_render_node_type_get_type() -> GType;

    //=========================================================================
    // GskScalingFilter
    //=========================================================================
    pub fn gsk_scaling_filter_get_type() -> GType;

    //=========================================================================
    // GskSerializationError
    //=========================================================================
    pub fn gsk_serialization_error_get_type() -> GType;
    pub fn gsk_serialization_error_quark() -> glib::GQuark;

    //=========================================================================
    // GskTransformCategory
    //=========================================================================
    pub fn gsk_transform_category_get_type() -> GType;

    //=========================================================================
    // GskRoundedRect
    //=========================================================================
    pub fn gsk_rounded_rect_contains_point(
        self_: *const GskRoundedRect,
        point: *const graphene::graphene_point_t,
    ) -> gboolean;
    pub fn gsk_rounded_rect_contains_rect(
        self_: *const GskRoundedRect,
        rect: *const graphene::graphene_rect_t,
    ) -> gboolean;
    pub fn gsk_rounded_rect_init(
        self_: *mut GskRoundedRect,
        bounds: *const graphene::graphene_rect_t,
        top_left: *const graphene::graphene_size_t,
        top_right: *const graphene::graphene_size_t,
        bottom_right: *const graphene::graphene_size_t,
        bottom_left: *const graphene::graphene_size_t,
    ) -> *mut GskRoundedRect;
    pub fn gsk_rounded_rect_init_copy(
        self_: *mut GskRoundedRect,
        src: *const GskRoundedRect,
    ) -> *mut GskRoundedRect;
    pub fn gsk_rounded_rect_init_from_rect(
        self_: *mut GskRoundedRect,
        bounds: *const graphene::graphene_rect_t,
        radius: c_float,
    ) -> *mut GskRoundedRect;
    pub fn gsk_rounded_rect_intersects_rect(
        self_: *const GskRoundedRect,
        rect: *const graphene::graphene_rect_t,
    ) -> gboolean;
    pub fn gsk_rounded_rect_is_rectilinear(self_: *const GskRoundedRect) -> gboolean;
    pub fn gsk_rounded_rect_normalize(self_: *mut GskRoundedRect) -> *mut GskRoundedRect;
    pub fn gsk_rounded_rect_offset(
        self_: *mut GskRoundedRect,
        dx: c_float,
        dy: c_float,
    ) -> *mut GskRoundedRect;
    pub fn gsk_rounded_rect_shrink(
        self_: *mut GskRoundedRect,
        top: c_float,
        right: c_float,
        bottom: c_float,
        left: c_float,
    ) -> *mut GskRoundedRect;

    //=========================================================================
    // GskShaderArgsBuilder
    //=========================================================================
    pub fn gsk_shader_args_builder_get_type() -> GType;
    pub fn gsk_shader_args_builder_new(
        shader: *mut GskGLShader,
        initial_values: *mut glib::GBytes,
    ) -> *mut GskShaderArgsBuilder;
    pub fn gsk_shader_args_builder_free_to_args(
        builder: *mut GskShaderArgsBuilder,
    ) -> *mut glib::GBytes;
    pub fn gsk_shader_args_builder_ref(
        builder: *mut GskShaderArgsBuilder,
    ) -> *mut GskShaderArgsBuilder;
    pub fn gsk_shader_args_builder_set_bool(
        builder: *mut GskShaderArgsBuilder,
        idx: c_int,
        value: gboolean,
    );
    pub fn gsk_shader_args_builder_set_float(
        builder: *mut GskShaderArgsBuilder,
        idx: c_int,
        value: c_float,
    );
    pub fn gsk_shader_args_builder_set_int(
        builder: *mut GskShaderArgsBuilder,
        idx: c_int,
        value: i32,
    );
    pub fn gsk_shader_args_builder_set_uint(
        builder: *mut GskShaderArgsBuilder,
        idx: c_int,
        value: u32,
    );
    pub fn gsk_shader_args_builder_set_vec2(
        builder: *mut GskShaderArgsBuilder,
        idx: c_int,
        value: *const graphene::graphene_vec2_t,
    );
    pub fn gsk_shader_args_builder_set_vec3(
        builder: *mut GskShaderArgsBuilder,
        idx: c_int,
        value: *const graphene::graphene_vec3_t,
    );
    pub fn gsk_shader_args_builder_set_vec4(
        builder: *mut GskShaderArgsBuilder,
        idx: c_int,
        value: *const graphene::graphene_vec4_t,
    );
    pub fn gsk_shader_args_builder_to_args(builder: *mut GskShaderArgsBuilder)
        -> *mut glib::GBytes;
    pub fn gsk_shader_args_builder_unref(builder: *mut GskShaderArgsBuilder);

    //=========================================================================
    // GskTransform
    //=========================================================================
    pub fn gsk_transform_get_type() -> GType;
    pub fn gsk_transform_new() -> *mut GskTransform;
    pub fn gsk_transform_equal(first: *mut GskTransform, second: *mut GskTransform) -> gboolean;
    pub fn gsk_transform_get_category(self_: *mut GskTransform) -> GskTransformCategory;
    pub fn gsk_transform_invert(self_: *mut GskTransform) -> *mut GskTransform;
    pub fn gsk_transform_matrix(
        next: *mut GskTransform,
        matrix: *const graphene::graphene_matrix_t,
    ) -> *mut GskTransform;
    pub fn gsk_transform_perspective(next: *mut GskTransform, depth: c_float) -> *mut GskTransform;
    pub fn gsk_transform_print(self_: *mut GskTransform, string: *mut glib::GString);
    pub fn gsk_transform_ref(self_: *mut GskTransform) -> *mut GskTransform;
    pub fn gsk_transform_rotate(next: *mut GskTransform, angle: c_float) -> *mut GskTransform;
    pub fn gsk_transform_rotate_3d(
        next: *mut GskTransform,
        angle: c_float,
        axis: *const graphene::graphene_vec3_t,
    ) -> *mut GskTransform;
    pub fn gsk_transform_scale(
        next: *mut GskTransform,
        factor_x: c_float,
        factor_y: c_float,
    ) -> *mut GskTransform;
    pub fn gsk_transform_scale_3d(
        next: *mut GskTransform,
        factor_x: c_float,
        factor_y: c_float,
        factor_z: c_float,
    ) -> *mut GskTransform;
    pub fn gsk_transform_to_2d(
        self_: *mut GskTransform,
        out_xx: *mut c_float,
        out_yx: *mut c_float,
        out_xy: *mut c_float,
        out_yy: *mut c_float,
        out_dx: *mut c_float,
        out_dy: *mut c_float,
    );
    pub fn gsk_transform_to_affine(
        self_: *mut GskTransform,
        out_scale_x: *mut c_float,
        out_scale_y: *mut c_float,
        out_dx: *mut c_float,
        out_dy: *mut c_float,
    );
    pub fn gsk_transform_to_matrix(
        self_: *mut GskTransform,
        out_matrix: *mut graphene::graphene_matrix_t,
    );
    pub fn gsk_transform_to_string(self_: *mut GskTransform) -> *mut c_char;
    pub fn gsk_transform_to_translate(
        self_: *mut GskTransform,
        out_dx: *mut c_float,
        out_dy: *mut c_float,
    );
    pub fn gsk_transform_transform(
        next: *mut GskTransform,
        other: *mut GskTransform,
    ) -> *mut GskTransform;
    pub fn gsk_transform_transform_bounds(
        self_: *mut GskTransform,
        rect: *const graphene::graphene_rect_t,
        out_rect: *mut graphene::graphene_rect_t,
    );
    pub fn gsk_transform_transform_point(
        self_: *mut GskTransform,
        point: *const graphene::graphene_point_t,
        out_point: *mut graphene::graphene_point_t,
    );
    pub fn gsk_transform_translate(
        next: *mut GskTransform,
        point: *const graphene::graphene_point_t,
    ) -> *mut GskTransform;
    pub fn gsk_transform_translate_3d(
        next: *mut GskTransform,
        point: *const graphene::graphene_point3d_t,
    ) -> *mut GskTransform;
    pub fn gsk_transform_unref(self_: *mut GskTransform);
    pub fn gsk_transform_parse(
        string: *const c_char,
        out_transform: *mut *mut GskTransform,
    ) -> gboolean;

    //=========================================================================
    // GskBlendNode
    //=========================================================================
    pub fn gsk_blend_node_get_type() -> GType;
    pub fn gsk_blend_node_new(
        bottom: *mut GskRenderNode,
        top: *mut GskRenderNode,
        blend_mode: GskBlendMode,
    ) -> *mut GskBlendNode;
    pub fn gsk_blend_node_get_blend_mode(node: *const GskBlendNode) -> GskBlendMode;
    pub fn gsk_blend_node_get_bottom_child(node: *const GskBlendNode) -> *mut GskRenderNode;
    pub fn gsk_blend_node_get_top_child(node: *const GskBlendNode) -> *mut GskRenderNode;

    //=========================================================================
    // GskBlurNode
    //=========================================================================
    pub fn gsk_blur_node_get_type() -> GType;
    pub fn gsk_blur_node_new(child: *mut GskRenderNode, radius: c_float) -> *mut GskBlurNode;
    pub fn gsk_blur_node_get_child(node: *const GskBlurNode) -> *mut GskRenderNode;
    pub fn gsk_blur_node_get_radius(node: *const GskBlurNode) -> c_float;

    //=========================================================================
    // GskBorderNode
    //=========================================================================
    pub fn gsk_border_node_get_type() -> GType;
    pub fn gsk_border_node_new(
        outline: *const GskRoundedRect,
        border_width: *const [c_float; 4],
        border_color: *const [gdk::GdkRGBA; 4],
    ) -> *mut GskBorderNode;
    pub fn gsk_border_node_get_colors(node: *const GskBorderNode) -> *const gdk::GdkRGBA;
    pub fn gsk_border_node_get_outline(node: *const GskBorderNode) -> *const GskRoundedRect;
    pub fn gsk_border_node_get_widths(node: *const GskBorderNode) -> *const [c_float; 4];

    //=========================================================================
    // GskBroadwayRenderer
    //=========================================================================
    pub fn gsk_broadway_renderer_get_type() -> GType;
    pub fn gsk_broadway_renderer_new() -> *mut GskRenderer;

    //=========================================================================
    // GskCairoNode
    //=========================================================================
    pub fn gsk_cairo_node_get_type() -> GType;
    pub fn gsk_cairo_node_new(bounds: *const graphene::graphene_rect_t) -> *mut GskCairoNode;
    pub fn gsk_cairo_node_get_draw_context(node: *mut GskCairoNode) -> *mut cairo::cairo_t;
    pub fn gsk_cairo_node_get_surface(node: *mut GskCairoNode) -> *mut cairo::cairo_surface_t;

    //=========================================================================
    // GskCairoRenderer
    //=========================================================================
    pub fn gsk_cairo_renderer_get_type() -> GType;
    pub fn gsk_cairo_renderer_new() -> *mut GskRenderer;

    //=========================================================================
    // GskClipNode
    //=========================================================================
    pub fn gsk_clip_node_get_type() -> GType;
    pub fn gsk_clip_node_new(
        child: *mut GskRenderNode,
        clip: *const graphene::graphene_rect_t,
    ) -> *mut GskClipNode;
    pub fn gsk_clip_node_get_child(node: *const GskClipNode) -> *mut GskRenderNode;
    pub fn gsk_clip_node_get_clip(node: *const GskClipNode) -> *const graphene::graphene_rect_t;

    //=========================================================================
    // GskColorMatrixNode
    //=========================================================================
    pub fn gsk_color_matrix_node_get_type() -> GType;
    pub fn gsk_color_matrix_node_new(
        child: *mut GskRenderNode,
        color_matrix: *const graphene::graphene_matrix_t,
        color_offset: *const graphene::graphene_vec4_t,
    ) -> *mut GskColorMatrixNode;
    pub fn gsk_color_matrix_node_get_child(node: *const GskColorMatrixNode) -> *mut GskRenderNode;
    pub fn gsk_color_matrix_node_get_color_matrix(
        node: *const GskColorMatrixNode,
    ) -> *const graphene::graphene_matrix_t;
    pub fn gsk_color_matrix_node_get_color_offset(
        node: *const GskColorMatrixNode,
    ) -> *const graphene::graphene_vec4_t;

    //=========================================================================
    // GskColorNode
    //=========================================================================
    pub fn gsk_color_node_get_type() -> GType;
    pub fn gsk_color_node_new(
        rgba: *const gdk::GdkRGBA,
        bounds: *const graphene::graphene_rect_t,
    ) -> *mut GskColorNode;
    pub fn gsk_color_node_get_color(node: *const GskColorNode) -> *const gdk::GdkRGBA;

    //=========================================================================
    // GskConicGradientNode
    //=========================================================================
    pub fn gsk_conic_gradient_node_get_type() -> GType;
    pub fn gsk_conic_gradient_node_new(
        bounds: *const graphene::graphene_rect_t,
        center: *const graphene::graphene_point_t,
        rotation: c_float,
        color_stops: *const GskColorStop,
        n_color_stops: size_t,
    ) -> *mut GskConicGradientNode;
    #[cfg(any(feature = "v4_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v4_2")))]
    pub fn gsk_conic_gradient_node_get_angle(node: *const GskConicGradientNode) -> c_float;
    pub fn gsk_conic_gradient_node_get_center(
        node: *const GskConicGradientNode,
    ) -> *const graphene::graphene_point_t;
    pub fn gsk_conic_gradient_node_get_color_stops(
        node: *const GskConicGradientNode,
        n_stops: *mut size_t,
    ) -> *const GskColorStop;
    pub fn gsk_conic_gradient_node_get_n_color_stops(node: *const GskConicGradientNode) -> size_t;
    pub fn gsk_conic_gradient_node_get_rotation(node: *const GskConicGradientNode) -> c_float;

    //=========================================================================
    // GskContainerNode
    //=========================================================================
    pub fn gsk_container_node_get_type() -> GType;
    pub fn gsk_container_node_new(
        children: *mut *mut GskRenderNode,
        n_children: c_uint,
    ) -> *mut GskContainerNode;
    pub fn gsk_container_node_get_child(
        node: *const GskContainerNode,
        idx: c_uint,
    ) -> *mut GskRenderNode;
    pub fn gsk_container_node_get_n_children(node: *const GskContainerNode) -> c_uint;

    //=========================================================================
    // GskCrossFadeNode
    //=========================================================================
    pub fn gsk_cross_fade_node_get_type() -> GType;
    pub fn gsk_cross_fade_node_new(
        start: *mut GskRenderNode,
        end: *mut GskRenderNode,
        progress: c_float,
    ) -> *mut GskCrossFadeNode;
    pub fn gsk_cross_fade_node_get_end_child(node: *const GskCrossFadeNode) -> *mut GskRenderNode;
    pub fn gsk_cross_fade_node_get_progress(node: *const GskCrossFadeNode) -> c_float;
    pub fn gsk_cross_fade_node_get_start_child(node: *const GskCrossFadeNode)
        -> *mut GskRenderNode;

    //=========================================================================
    // GskDebugNode
    //=========================================================================
    pub fn gsk_debug_node_get_type() -> GType;
    pub fn gsk_debug_node_new(child: *mut GskRenderNode, message: *mut c_char)
        -> *mut GskDebugNode;
    pub fn gsk_debug_node_get_child(node: *const GskDebugNode) -> *mut GskRenderNode;
    pub fn gsk_debug_node_get_message(node: *const GskDebugNode) -> *const c_char;

    //=========================================================================
    // GskGLRenderer
    //=========================================================================
    pub fn gsk_gl_renderer_get_type() -> GType;
    pub fn gsk_gl_renderer_new() -> *mut GskRenderer;

    //=========================================================================
    // GskGLShader
    //=========================================================================
    pub fn gsk_gl_shader_get_type() -> GType;
    pub fn gsk_gl_shader_new_from_bytes(sourcecode: *mut glib::GBytes) -> *mut GskGLShader;
    pub fn gsk_gl_shader_new_from_resource(resource_path: *const c_char) -> *mut GskGLShader;
    pub fn gsk_gl_shader_compile(
        shader: *mut GskGLShader,
        renderer: *mut GskRenderer,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn gsk_gl_shader_find_uniform_by_name(
        shader: *mut GskGLShader,
        name: *const c_char,
    ) -> c_int;
    pub fn gsk_gl_shader_format_args(shader: *mut GskGLShader, ...) -> *mut glib::GBytes;
    //pub fn gsk_gl_shader_format_args_va(shader: *mut GskGLShader, uniforms: /*Unimplemented*/va_list) -> *mut glib::GBytes;
    pub fn gsk_gl_shader_get_arg_bool(
        shader: *mut GskGLShader,
        args: *mut glib::GBytes,
        idx: c_int,
    ) -> gboolean;
    pub fn gsk_gl_shader_get_arg_float(
        shader: *mut GskGLShader,
        args: *mut glib::GBytes,
        idx: c_int,
    ) -> c_float;
    pub fn gsk_gl_shader_get_arg_int(
        shader: *mut GskGLShader,
        args: *mut glib::GBytes,
        idx: c_int,
    ) -> i32;
    pub fn gsk_gl_shader_get_arg_uint(
        shader: *mut GskGLShader,
        args: *mut glib::GBytes,
        idx: c_int,
    ) -> u32;
    pub fn gsk_gl_shader_get_arg_vec2(
        shader: *mut GskGLShader,
        args: *mut glib::GBytes,
        idx: c_int,
        out_value: *mut graphene::graphene_vec2_t,
    );
    pub fn gsk_gl_shader_get_arg_vec3(
        shader: *mut GskGLShader,
        args: *mut glib::GBytes,
        idx: c_int,
        out_value: *mut graphene::graphene_vec3_t,
    );
    pub fn gsk_gl_shader_get_arg_vec4(
        shader: *mut GskGLShader,
        args: *mut glib::GBytes,
        idx: c_int,
        out_value: *mut graphene::graphene_vec4_t,
    );
    pub fn gsk_gl_shader_get_args_size(shader: *mut GskGLShader) -> size_t;
    pub fn gsk_gl_shader_get_n_textures(shader: *mut GskGLShader) -> c_int;
    pub fn gsk_gl_shader_get_n_uniforms(shader: *mut GskGLShader) -> c_int;
    pub fn gsk_gl_shader_get_resource(shader: *mut GskGLShader) -> *const c_char;
    pub fn gsk_gl_shader_get_source(shader: *mut GskGLShader) -> *mut glib::GBytes;
    pub fn gsk_gl_shader_get_uniform_name(shader: *mut GskGLShader, idx: c_int) -> *const c_char;
    pub fn gsk_gl_shader_get_uniform_offset(shader: *mut GskGLShader, idx: c_int) -> c_int;
    pub fn gsk_gl_shader_get_uniform_type(shader: *mut GskGLShader, idx: c_int)
        -> GskGLUniformType;

    //=========================================================================
    // GskGLShaderNode
    //=========================================================================
    pub fn gsk_gl_shader_node_get_type() -> GType;
    pub fn gsk_gl_shader_node_new(
        shader: *mut GskGLShader,
        bounds: *const graphene::graphene_rect_t,
        args: *mut glib::GBytes,
        children: *mut *mut GskRenderNode,
        n_children: c_uint,
    ) -> *mut GskGLShaderNode;
    pub fn gsk_gl_shader_node_get_args(node: *const GskGLShaderNode) -> *mut glib::GBytes;
    pub fn gsk_gl_shader_node_get_child(
        node: *const GskGLShaderNode,
        idx: c_uint,
    ) -> *mut GskRenderNode;
    pub fn gsk_gl_shader_node_get_n_children(node: *const GskGLShaderNode) -> c_uint;
    pub fn gsk_gl_shader_node_get_shader(node: *const GskGLShaderNode) -> *mut GskGLShader;

    //=========================================================================
    // GskInsetShadowNode
    //=========================================================================
    pub fn gsk_inset_shadow_node_get_type() -> GType;
    pub fn gsk_inset_shadow_node_new(
        outline: *const GskRoundedRect,
        color: *const gdk::GdkRGBA,
        dx: c_float,
        dy: c_float,
        spread: c_float,
        blur_radius: c_float,
    ) -> *mut GskInsetShadowNode;
    pub fn gsk_inset_shadow_node_get_blur_radius(node: *const GskInsetShadowNode) -> c_float;
    pub fn gsk_inset_shadow_node_get_color(node: *const GskInsetShadowNode) -> *const gdk::GdkRGBA;
    pub fn gsk_inset_shadow_node_get_dx(node: *const GskInsetShadowNode) -> c_float;
    pub fn gsk_inset_shadow_node_get_dy(node: *const GskInsetShadowNode) -> c_float;
    pub fn gsk_inset_shadow_node_get_outline(
        node: *const GskInsetShadowNode,
    ) -> *const GskRoundedRect;
    pub fn gsk_inset_shadow_node_get_spread(node: *const GskInsetShadowNode) -> c_float;

    //=========================================================================
    // GskLinearGradientNode
    //=========================================================================
    pub fn gsk_linear_gradient_node_get_type() -> GType;
    pub fn gsk_linear_gradient_node_new(
        bounds: *const graphene::graphene_rect_t,
        start: *const graphene::graphene_point_t,
        end: *const graphene::graphene_point_t,
        color_stops: *const GskColorStop,
        n_color_stops: size_t,
    ) -> *mut GskLinearGradientNode;
    pub fn gsk_linear_gradient_node_get_color_stops(
        node: *const GskLinearGradientNode,
        n_stops: *mut size_t,
    ) -> *const GskColorStop;
    pub fn gsk_linear_gradient_node_get_end(
        node: *const GskLinearGradientNode,
    ) -> *const graphene::graphene_point_t;
    pub fn gsk_linear_gradient_node_get_n_color_stops(node: *const GskLinearGradientNode)
        -> size_t;
    pub fn gsk_linear_gradient_node_get_start(
        node: *const GskLinearGradientNode,
    ) -> *const graphene::graphene_point_t;

    //=========================================================================
    // GskNglRenderer
    //=========================================================================
    pub fn gsk_ngl_renderer_get_type() -> GType;
    #[cfg(any(feature = "v4_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v4_2")))]
    pub fn gsk_ngl_renderer_new() -> *mut GskRenderer;

    //=========================================================================
    // GskOpacityNode
    //=========================================================================
    pub fn gsk_opacity_node_get_type() -> GType;
    pub fn gsk_opacity_node_new(child: *mut GskRenderNode, opacity: c_float)
        -> *mut GskOpacityNode;
    pub fn gsk_opacity_node_get_child(node: *const GskOpacityNode) -> *mut GskRenderNode;
    pub fn gsk_opacity_node_get_opacity(node: *const GskOpacityNode) -> c_float;

    //=========================================================================
    // GskOutsetShadowNode
    //=========================================================================
    pub fn gsk_outset_shadow_node_get_type() -> GType;
    pub fn gsk_outset_shadow_node_new(
        outline: *const GskRoundedRect,
        color: *const gdk::GdkRGBA,
        dx: c_float,
        dy: c_float,
        spread: c_float,
        blur_radius: c_float,
    ) -> *mut GskOutsetShadowNode;
    pub fn gsk_outset_shadow_node_get_blur_radius(node: *const GskOutsetShadowNode) -> c_float;
    pub fn gsk_outset_shadow_node_get_color(
        node: *const GskOutsetShadowNode,
    ) -> *const gdk::GdkRGBA;
    pub fn gsk_outset_shadow_node_get_dx(node: *const GskOutsetShadowNode) -> c_float;
    pub fn gsk_outset_shadow_node_get_dy(node: *const GskOutsetShadowNode) -> c_float;
    pub fn gsk_outset_shadow_node_get_outline(
        node: *const GskOutsetShadowNode,
    ) -> *const GskRoundedRect;
    pub fn gsk_outset_shadow_node_get_spread(node: *const GskOutsetShadowNode) -> c_float;

    //=========================================================================
    // GskRadialGradientNode
    //=========================================================================
    pub fn gsk_radial_gradient_node_get_type() -> GType;
    pub fn gsk_radial_gradient_node_new(
        bounds: *const graphene::graphene_rect_t,
        center: *const graphene::graphene_point_t,
        hradius: c_float,
        vradius: c_float,
        start: c_float,
        end: c_float,
        color_stops: *const GskColorStop,
        n_color_stops: size_t,
    ) -> *mut GskRadialGradientNode;
    pub fn gsk_radial_gradient_node_get_center(
        node: *const GskRadialGradientNode,
    ) -> *const graphene::graphene_point_t;
    pub fn gsk_radial_gradient_node_get_color_stops(
        node: *const GskRadialGradientNode,
        n_stops: *mut size_t,
    ) -> *const GskColorStop;
    pub fn gsk_radial_gradient_node_get_end(node: *const GskRadialGradientNode) -> c_float;
    pub fn gsk_radial_gradient_node_get_hradius(node: *const GskRadialGradientNode) -> c_float;
    pub fn gsk_radial_gradient_node_get_n_color_stops(node: *const GskRadialGradientNode)
        -> size_t;
    pub fn gsk_radial_gradient_node_get_start(node: *const GskRadialGradientNode) -> c_float;
    pub fn gsk_radial_gradient_node_get_vradius(node: *const GskRadialGradientNode) -> c_float;

    //=========================================================================
    // GskRenderNode
    //=========================================================================
    pub fn gsk_render_node_get_type() -> GType;
    pub fn gsk_render_node_deserialize(
        bytes: *mut glib::GBytes,
        error_func: GskParseErrorFunc,
        user_data: gpointer,
    ) -> *mut GskRenderNode;
    pub fn gsk_render_node_draw(node: *mut GskRenderNode, cr: *mut cairo::cairo_t);
    pub fn gsk_render_node_get_bounds(
        node: *mut GskRenderNode,
        bounds: *mut graphene::graphene_rect_t,
    );
    pub fn gsk_render_node_get_node_type(node: *const GskRenderNode) -> GskRenderNodeType;
    pub fn gsk_render_node_ref(node: *mut GskRenderNode) -> *mut GskRenderNode;
    pub fn gsk_render_node_serialize(node: *mut GskRenderNode) -> *mut glib::GBytes;
    pub fn gsk_render_node_unref(node: *mut GskRenderNode);
    pub fn gsk_render_node_write_to_file(
        node: *mut GskRenderNode,
        filename: *const c_char,
        error: *mut *mut glib::GError,
    ) -> gboolean;

    //=========================================================================
    // GskRenderer
    //=========================================================================
    pub fn gsk_renderer_get_type() -> GType;
    pub fn gsk_renderer_new_for_surface(surface: *mut gdk::GdkSurface) -> *mut GskRenderer;
    pub fn gsk_renderer_get_surface(renderer: *mut GskRenderer) -> *mut gdk::GdkSurface;
    pub fn gsk_renderer_is_realized(renderer: *mut GskRenderer) -> gboolean;
    pub fn gsk_renderer_realize(
        renderer: *mut GskRenderer,
        surface: *mut gdk::GdkSurface,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn gsk_renderer_render(
        renderer: *mut GskRenderer,
        root: *mut GskRenderNode,
        region: *const cairo::cairo_region_t,
    );
    pub fn gsk_renderer_render_texture(
        renderer: *mut GskRenderer,
        root: *mut GskRenderNode,
        viewport: *const graphene::graphene_rect_t,
    ) -> *mut gdk::GdkTexture;
    pub fn gsk_renderer_unrealize(renderer: *mut GskRenderer);

    //=========================================================================
    // GskRepeatNode
    //=========================================================================
    pub fn gsk_repeat_node_get_type() -> GType;
    pub fn gsk_repeat_node_new(
        bounds: *const graphene::graphene_rect_t,
        child: *mut GskRenderNode,
        child_bounds: *const graphene::graphene_rect_t,
    ) -> *mut GskRepeatNode;
    pub fn gsk_repeat_node_get_child(node: *const GskRepeatNode) -> *mut GskRenderNode;
    pub fn gsk_repeat_node_get_child_bounds(
        node: *const GskRepeatNode,
    ) -> *const graphene::graphene_rect_t;

    //=========================================================================
    // GskRepeatingLinearGradientNode
    //=========================================================================
    pub fn gsk_repeating_linear_gradient_node_get_type() -> GType;
    pub fn gsk_repeating_linear_gradient_node_new(
        bounds: *const graphene::graphene_rect_t,
        start: *const graphene::graphene_point_t,
        end: *const graphene::graphene_point_t,
        color_stops: *const GskColorStop,
        n_color_stops: size_t,
    ) -> *mut GskRepeatingLinearGradientNode;

    //=========================================================================
    // GskRepeatingRadialGradientNode
    //=========================================================================
    pub fn gsk_repeating_radial_gradient_node_get_type() -> GType;
    pub fn gsk_repeating_radial_gradient_node_new(
        bounds: *const graphene::graphene_rect_t,
        center: *const graphene::graphene_point_t,
        hradius: c_float,
        vradius: c_float,
        start: c_float,
        end: c_float,
        color_stops: *const GskColorStop,
        n_color_stops: size_t,
    ) -> *mut GskRepeatingRadialGradientNode;

    //=========================================================================
    // GskRoundedClipNode
    //=========================================================================
    pub fn gsk_rounded_clip_node_get_type() -> GType;
    pub fn gsk_rounded_clip_node_new(
        child: *mut GskRenderNode,
        clip: *const GskRoundedRect,
    ) -> *mut GskRoundedClipNode;
    pub fn gsk_rounded_clip_node_get_child(node: *const GskRoundedClipNode) -> *mut GskRenderNode;
    pub fn gsk_rounded_clip_node_get_clip(node: *const GskRoundedClipNode)
        -> *const GskRoundedRect;

    //=========================================================================
    // GskShadowNode
    //=========================================================================
    pub fn gsk_shadow_node_get_type() -> GType;
    pub fn gsk_shadow_node_new(
        child: *mut GskRenderNode,
        shadows: *const GskShadow,
        n_shadows: size_t,
    ) -> *mut GskShadowNode;
    pub fn gsk_shadow_node_get_child(node: *const GskShadowNode) -> *mut GskRenderNode;
    pub fn gsk_shadow_node_get_n_shadows(node: *const GskShadowNode) -> size_t;
    pub fn gsk_shadow_node_get_shadow(node: *const GskShadowNode, i: size_t) -> *const GskShadow;

    //=========================================================================
    // GskTextNode
    //=========================================================================
    pub fn gsk_text_node_get_type() -> GType;
    pub fn gsk_text_node_new(
        font: *mut pango::PangoFont,
        glyphs: *mut pango::PangoGlyphString,
        color: *const gdk::GdkRGBA,
        offset: *const graphene::graphene_point_t,
    ) -> *mut GskTextNode;
    pub fn gsk_text_node_get_color(node: *const GskTextNode) -> *const gdk::GdkRGBA;
    pub fn gsk_text_node_get_font(node: *const GskTextNode) -> *mut pango::PangoFont;
    pub fn gsk_text_node_get_glyphs(
        node: *const GskTextNode,
        n_glyphs: *mut c_uint,
    ) -> *const pango::PangoGlyphInfo;
    pub fn gsk_text_node_get_num_glyphs(node: *const GskTextNode) -> c_uint;
    pub fn gsk_text_node_get_offset(node: *const GskTextNode) -> *const graphene::graphene_point_t;
    #[cfg(any(feature = "v4_2", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v4_2")))]
    pub fn gsk_text_node_has_color_glyphs(node: *const GskTextNode) -> gboolean;

    //=========================================================================
    // GskTextureNode
    //=========================================================================
    pub fn gsk_texture_node_get_type() -> GType;
    pub fn gsk_texture_node_new(
        texture: *mut gdk::GdkTexture,
        bounds: *const graphene::graphene_rect_t,
    ) -> *mut GskTextureNode;
    pub fn gsk_texture_node_get_texture(node: *const GskTextureNode) -> *mut gdk::GdkTexture;

    //=========================================================================
    // GskTransformNode
    //=========================================================================
    pub fn gsk_transform_node_get_type() -> GType;
    pub fn gsk_transform_node_new(
        child: *mut GskRenderNode,
        transform: *mut GskTransform,
    ) -> *mut GskTransformNode;
    pub fn gsk_transform_node_get_child(node: *const GskTransformNode) -> *mut GskRenderNode;
    pub fn gsk_transform_node_get_transform(node: *const GskTransformNode) -> *mut GskTransform;

}