#![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(docsrs, 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;
#[cfg(unix)]
#[allow(unused_imports)]
use libc::{dev_t, gid_t, pid_t, socklen_t, uid_t};
#[allow(unused_imports)]
use libc::{intptr_t, off_t, size_t, ssize_t, time_t, uintptr_t, FILE};
#[allow(unused_imports)]
use std::ffi::{
c_char, c_double, c_float, c_int, c_long, c_short, c_uchar, c_uint, c_ulong, c_ushort, c_void,
};
#[allow(unused_imports)]
use glib::{gboolean, gconstpointer, gpointer, GType};
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 GskFillRule = c_int;
pub const GSK_FILL_RULE_WINDING: GskFillRule = 0;
pub const GSK_FILL_RULE_EVEN_ODD: GskFillRule = 1;
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 GskLineCap = c_int;
pub const GSK_LINE_CAP_BUTT: GskLineCap = 0;
pub const GSK_LINE_CAP_ROUND: GskLineCap = 1;
pub const GSK_LINE_CAP_SQUARE: GskLineCap = 2;
pub type GskLineJoin = c_int;
pub const GSK_LINE_JOIN_MITER: GskLineJoin = 0;
pub const GSK_LINE_JOIN_ROUND: GskLineJoin = 1;
pub const GSK_LINE_JOIN_BEVEL: GskLineJoin = 2;
pub type GskMaskMode = c_int;
pub const GSK_MASK_MODE_ALPHA: GskMaskMode = 0;
pub const GSK_MASK_MODE_INVERTED_ALPHA: GskMaskMode = 1;
pub const GSK_MASK_MODE_LUMINANCE: GskMaskMode = 2;
pub const GSK_MASK_MODE_INVERTED_LUMINANCE: GskMaskMode = 3;
pub type GskPathDirection = c_int;
pub const GSK_PATH_FROM_START: GskPathDirection = 0;
pub const GSK_PATH_TO_START: GskPathDirection = 1;
pub const GSK_PATH_TO_END: GskPathDirection = 2;
pub const GSK_PATH_FROM_END: GskPathDirection = 3;
pub type GskPathOperation = c_int;
pub const GSK_PATH_MOVE: GskPathOperation = 0;
pub const GSK_PATH_CLOSE: GskPathOperation = 1;
pub const GSK_PATH_LINE: GskPathOperation = 2;
pub const GSK_PATH_QUAD: GskPathOperation = 3;
pub const GSK_PATH_CUBIC: GskPathOperation = 4;
pub const GSK_PATH_CONIC: GskPathOperation = 5;
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;
#[cfg(feature = "v4_10")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
pub const GSK_TEXTURE_SCALE_NODE: GskRenderNodeType = 26;
#[cfg(feature = "v4_10")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
pub const GSK_MASK_NODE: GskRenderNodeType = 27;
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub const GSK_FILL_NODE: GskRenderNodeType = 28;
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub const GSK_STROKE_NODE: GskRenderNodeType = 29;
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub const GSK_SUBSURFACE_NODE: GskRenderNodeType = 30;
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;
pub type GskPathForeachFlags = c_uint;
pub const GSK_PATH_FOREACH_ALLOW_ONLY_LINES: GskPathForeachFlags = 0;
pub const GSK_PATH_FOREACH_ALLOW_QUAD: GskPathForeachFlags = 1;
pub const GSK_PATH_FOREACH_ALLOW_CUBIC: GskPathForeachFlags = 2;
pub const GSK_PATH_FOREACH_ALLOW_CONIC: GskPathForeachFlags = 4;
#[derive(Copy, Clone)]
#[repr(C)]
pub union GskPathPoint_u1 {
pub s1: GskPathPoint__s1,
pub padding: [gpointer; 8],
pub alignment: graphene::graphene_vec4_t,
}
impl ::std::fmt::Debug for GskPathPoint_u1 {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GskPathPoint_u1 @ {self:p}"))
.field("s1", unsafe { &self.s1 })
.field("padding", unsafe { &self.padding })
.field("alignment", unsafe { &self.alignment })
.finish()
}
}
pub type GskParseErrorFunc = Option<
unsafe extern "C" fn(
*const GskParseLocation,
*const GskParseLocation,
*const glib::GError,
gpointer,
),
>;
pub type GskPathForeachFunc = Option<
unsafe extern "C" fn(
GskPathOperation,
*const graphene::graphene_point_t,
size_t,
c_float,
gpointer,
) -> gboolean,
>;
#[cfg(feature = "broadway")]
#[cfg_attr(docsrs, doc(cfg(feature = "broadway")))]
#[repr(C)]
#[allow(dead_code)]
pub struct _GskBroadwayRendererClass {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
#[cfg(feature = "broadway")]
#[cfg_attr(docsrs, doc(cfg(feature = "broadway")))]
pub type GskBroadwayRendererClass = _GskBroadwayRendererClass;
#[repr(C)]
#[allow(dead_code)]
pub struct _GskCairoRendererClass {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type GskCairoRendererClass = _GskCairoRendererClass;
#[derive(Copy, Clone)]
#[repr(C)]
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 @ {self:p}"))
.field("offset", &self.offset)
.field("color", &self.color)
.finish()
}
}
#[repr(C)]
#[allow(dead_code)]
pub struct _GskGLRendererClass {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type GskGLRendererClass = _GskGLRendererClass;
#[derive(Copy, Clone)]
#[repr(C)]
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 @ {self:p}"))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
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 @ {self:p}"))
.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)]
#[allow(dead_code)]
pub struct GskPath {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for GskPath {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GskPath @ {self:p}")).finish()
}
}
#[repr(C)]
#[allow(dead_code)]
pub struct GskPathBuilder {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for GskPathBuilder {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GskPathBuilder @ {self:p}"))
.finish()
}
}
#[repr(C)]
#[allow(dead_code)]
pub struct GskPathMeasure {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for GskPathMeasure {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GskPathMeasure @ {self:p}"))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct GskPathPoint {
pub u1: GskPathPoint_u1,
}
impl ::std::fmt::Debug for GskPathPoint {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GskPathPoint @ {self:p}"))
.field("u1", &self.u1)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct GskPathPoint__s1 {
pub contour: size_t,
pub idx: size_t,
pub t: c_float,
}
impl ::std::fmt::Debug for GskPathPoint__s1 {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GskPathPoint__s1 @ {self:p}"))
.field("contour", &self.contour)
.field("idx", &self.idx)
.field("t", &self.t)
.finish()
}
}
#[repr(C)]
#[allow(dead_code)]
pub struct _GskRendererClass {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type GskRendererClass = _GskRendererClass;
#[derive(Copy, Clone)]
#[repr(C)]
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 @ {self:p}"))
.field("bounds", &self.bounds)
.field("corner", &self.corner)
.finish()
}
}
#[repr(C)]
#[allow(dead_code)]
pub struct GskShaderArgsBuilder {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for GskShaderArgsBuilder {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GskShaderArgsBuilder @ {self:p}"))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
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 @ {self:p}"))
.field("color", &self.color)
.field("dx", &self.dx)
.field("dy", &self.dy)
.field("radius", &self.radius)
.finish()
}
}
#[repr(C)]
#[allow(dead_code)]
pub struct GskStroke {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for GskStroke {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GskStroke @ {self:p}")).finish()
}
}
#[repr(C)]
#[allow(dead_code)]
pub struct GskTransform {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for GskTransform {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GskTransform @ {self:p}")).finish()
}
}
#[cfg(feature = "vulkan")]
#[cfg_attr(docsrs, doc(cfg(feature = "vulkan")))]
#[repr(C)]
#[allow(dead_code)]
pub struct _GskVulkanRendererClass {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
#[cfg(feature = "vulkan")]
#[cfg_attr(docsrs, doc(cfg(feature = "vulkan")))]
pub type GskVulkanRendererClass = _GskVulkanRendererClass;
#[repr(C)]
#[allow(dead_code)]
pub struct GskBlendNode {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for GskBlendNode {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GskBlendNode @ {self:p}")).finish()
}
}
#[repr(C)]
#[allow(dead_code)]
pub struct GskBlurNode {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for GskBlurNode {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GskBlurNode @ {self:p}")).finish()
}
}
#[repr(C)]
#[allow(dead_code)]
pub struct GskBorderNode {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for GskBorderNode {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GskBorderNode @ {self:p}"))
.finish()
}
}
#[cfg(feature = "broadway")]
#[cfg_attr(docsrs, doc(cfg(feature = "broadway")))]
#[repr(C)]
#[allow(dead_code)]
pub struct GskBroadwayRenderer {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
#[cfg(feature = "broadway")]
#[cfg_attr(docsrs, doc(cfg(feature = "broadway")))]
impl ::std::fmt::Debug for GskBroadwayRenderer {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GskBroadwayRenderer @ {self:p}"))
.finish()
}
}
#[repr(C)]
#[allow(dead_code)]
pub struct GskCairoNode {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for GskCairoNode {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GskCairoNode @ {self:p}")).finish()
}
}
#[repr(C)]
#[allow(dead_code)]
pub struct GskCairoRenderer {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for GskCairoRenderer {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GskCairoRenderer @ {self:p}"))
.finish()
}
}
#[repr(C)]
#[allow(dead_code)]
pub struct GskClipNode {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for GskClipNode {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GskClipNode @ {self:p}")).finish()
}
}
#[repr(C)]
#[allow(dead_code)]
pub struct GskColorMatrixNode {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for GskColorMatrixNode {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GskColorMatrixNode @ {self:p}"))
.finish()
}
}
#[repr(C)]
#[allow(dead_code)]
pub struct GskColorNode {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for GskColorNode {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GskColorNode @ {self:p}")).finish()
}
}
#[repr(C)]
#[allow(dead_code)]
pub struct GskConicGradientNode {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for GskConicGradientNode {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GskConicGradientNode @ {self:p}"))
.finish()
}
}
#[repr(C)]
#[allow(dead_code)]
pub struct GskContainerNode {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for GskContainerNode {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GskContainerNode @ {self:p}"))
.finish()
}
}
#[repr(C)]
#[allow(dead_code)]
pub struct GskCrossFadeNode {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for GskCrossFadeNode {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GskCrossFadeNode @ {self:p}"))
.finish()
}
}
#[repr(C)]
#[allow(dead_code)]
pub struct GskDebugNode {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for GskDebugNode {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GskDebugNode @ {self:p}")).finish()
}
}
#[repr(C)]
#[allow(dead_code)]
pub struct GskFillNode {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for GskFillNode {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GskFillNode @ {self:p}")).finish()
}
}
#[repr(C)]
#[allow(dead_code)]
pub struct GskGLRenderer {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for GskGLRenderer {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GskGLRenderer @ {self:p}"))
.finish()
}
}
#[repr(C)]
#[allow(dead_code)]
pub struct GskGLShader {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for GskGLShader {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GskGLShader @ {self:p}")).finish()
}
}
#[repr(C)]
#[allow(dead_code)]
pub struct GskGLShaderNode {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for GskGLShaderNode {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GskGLShaderNode @ {self:p}"))
.finish()
}
}
#[repr(C)]
#[allow(dead_code)]
pub struct GskInsetShadowNode {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for GskInsetShadowNode {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GskInsetShadowNode @ {self:p}"))
.finish()
}
}
#[repr(C)]
#[allow(dead_code)]
pub struct GskLinearGradientNode {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for GskLinearGradientNode {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GskLinearGradientNode @ {self:p}"))
.finish()
}
}
#[repr(C)]
#[allow(dead_code)]
pub struct GskMaskNode {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for GskMaskNode {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GskMaskNode @ {self:p}")).finish()
}
}
#[repr(C)]
#[allow(dead_code)]
pub struct GskNglRenderer {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for GskNglRenderer {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GskNglRenderer @ {self:p}"))
.finish()
}
}
#[repr(C)]
#[allow(dead_code)]
pub struct GskOpacityNode {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for GskOpacityNode {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GskOpacityNode @ {self:p}"))
.finish()
}
}
#[repr(C)]
#[allow(dead_code)]
pub struct GskOutsetShadowNode {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for GskOutsetShadowNode {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GskOutsetShadowNode @ {self:p}"))
.finish()
}
}
#[repr(C)]
#[allow(dead_code)]
pub struct GskRadialGradientNode {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for GskRadialGradientNode {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GskRadialGradientNode @ {self:p}"))
.finish()
}
}
#[repr(C)]
#[allow(dead_code)]
pub struct GskRenderNode {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for GskRenderNode {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GskRenderNode @ {self:p}"))
.finish()
}
}
#[repr(C)]
#[allow(dead_code)]
pub struct GskRenderer {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for GskRenderer {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GskRenderer @ {self:p}")).finish()
}
}
#[repr(C)]
#[allow(dead_code)]
pub struct GskRepeatNode {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for GskRepeatNode {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GskRepeatNode @ {self:p}"))
.finish()
}
}
#[repr(C)]
#[allow(dead_code)]
pub struct GskRepeatingLinearGradientNode {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for GskRepeatingLinearGradientNode {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GskRepeatingLinearGradientNode @ {self:p}"))
.finish()
}
}
#[repr(C)]
#[allow(dead_code)]
pub struct GskRepeatingRadialGradientNode {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for GskRepeatingRadialGradientNode {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GskRepeatingRadialGradientNode @ {self:p}"))
.finish()
}
}
#[repr(C)]
#[allow(dead_code)]
pub struct GskRoundedClipNode {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for GskRoundedClipNode {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GskRoundedClipNode @ {self:p}"))
.finish()
}
}
#[repr(C)]
#[allow(dead_code)]
pub struct GskShadowNode {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for GskShadowNode {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GskShadowNode @ {self:p}"))
.finish()
}
}
#[repr(C)]
#[allow(dead_code)]
pub struct GskStrokeNode {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for GskStrokeNode {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GskStrokeNode @ {self:p}"))
.finish()
}
}
#[repr(C)]
#[allow(dead_code)]
pub struct GskSubsurfaceNode {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for GskSubsurfaceNode {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GskSubsurfaceNode @ {self:p}"))
.finish()
}
}
#[repr(C)]
#[allow(dead_code)]
pub struct GskTextNode {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for GskTextNode {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GskTextNode @ {self:p}")).finish()
}
}
#[repr(C)]
#[allow(dead_code)]
pub struct GskTextureNode {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for GskTextureNode {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GskTextureNode @ {self:p}"))
.finish()
}
}
#[repr(C)]
#[allow(dead_code)]
pub struct GskTextureScaleNode {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for GskTextureScaleNode {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GskTextureScaleNode @ {self:p}"))
.finish()
}
}
#[repr(C)]
#[allow(dead_code)]
pub struct GskTransformNode {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for GskTransformNode {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GskTransformNode @ {self:p}"))
.finish()
}
}
#[cfg(feature = "vulkan")]
#[cfg_attr(docsrs, doc(cfg(feature = "vulkan")))]
#[repr(C)]
#[allow(dead_code)]
pub struct GskVulkanRenderer {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
#[cfg(feature = "vulkan")]
#[cfg_attr(docsrs, doc(cfg(feature = "vulkan")))]
impl ::std::fmt::Debug for GskVulkanRenderer {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GskVulkanRenderer @ {self:p}"))
.finish()
}
}
extern "C" {
pub fn gsk_blend_mode_get_type() -> GType;
pub fn gsk_corner_get_type() -> GType;
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_fill_rule_get_type() -> GType;
pub fn gsk_gl_uniform_type_get_type() -> GType;
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_line_cap_get_type() -> GType;
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_line_join_get_type() -> GType;
#[cfg(feature = "v4_10")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
pub fn gsk_mask_mode_get_type() -> GType;
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_path_direction_get_type() -> GType;
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_path_operation_get_type() -> GType;
pub fn gsk_render_node_type_get_type() -> GType;
pub fn gsk_scaling_filter_get_type() -> GType;
pub fn gsk_serialization_error_get_type() -> GType;
pub fn gsk_serialization_error_quark() -> glib::GQuark;
pub fn gsk_transform_category_get_type() -> GType;
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_path_foreach_flags_get_type() -> GType;
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_path_get_type() -> GType;
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_path_foreach(
self_: *mut GskPath,
flags: GskPathForeachFlags,
func: GskPathForeachFunc,
user_data: gpointer,
) -> gboolean;
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_path_get_bounds(
self_: *mut GskPath,
bounds: *mut graphene::graphene_rect_t,
) -> gboolean;
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_path_get_closest_point(
self_: *mut GskPath,
point: *const graphene::graphene_point_t,
threshold: c_float,
result: *mut GskPathPoint,
distance: *mut c_float,
) -> gboolean;
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_path_get_end_point(self_: *mut GskPath, result: *mut GskPathPoint) -> gboolean;
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_path_get_start_point(self_: *mut GskPath, result: *mut GskPathPoint) -> gboolean;
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_path_get_stroke_bounds(
self_: *mut GskPath,
stroke: *const GskStroke,
bounds: *mut graphene::graphene_rect_t,
) -> gboolean;
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_path_in_fill(
self_: *mut GskPath,
point: *const graphene::graphene_point_t,
fill_rule: GskFillRule,
) -> gboolean;
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_path_is_closed(self_: *mut GskPath) -> gboolean;
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_path_is_empty(self_: *mut GskPath) -> gboolean;
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_path_print(self_: *mut GskPath, string: *mut glib::GString);
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_path_ref(self_: *mut GskPath) -> *mut GskPath;
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_path_to_cairo(self_: *mut GskPath, cr: *mut cairo::cairo_t);
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_path_to_string(self_: *mut GskPath) -> *mut c_char;
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_path_unref(self_: *mut GskPath);
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_path_parse(string: *const c_char) -> *mut GskPath;
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_path_builder_get_type() -> GType;
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_path_builder_new() -> *mut GskPathBuilder;
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_path_builder_add_cairo_path(
self_: *mut GskPathBuilder,
path: *const cairo::cairo_path_t,
);
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_path_builder_add_circle(
self_: *mut GskPathBuilder,
center: *const graphene::graphene_point_t,
radius: c_float,
);
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_path_builder_add_layout(self_: *mut GskPathBuilder, layout: *mut pango::PangoLayout);
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_path_builder_add_path(self_: *mut GskPathBuilder, path: *mut GskPath);
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_path_builder_add_rect(
self_: *mut GskPathBuilder,
rect: *const graphene::graphene_rect_t,
);
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_path_builder_add_reverse_path(self_: *mut GskPathBuilder, path: *mut GskPath);
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_path_builder_add_rounded_rect(
self_: *mut GskPathBuilder,
rect: *const GskRoundedRect,
);
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_path_builder_add_segment(
self_: *mut GskPathBuilder,
path: *mut GskPath,
start: *const GskPathPoint,
end: *const GskPathPoint,
);
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_path_builder_arc_to(
self_: *mut GskPathBuilder,
x1: c_float,
y1: c_float,
x2: c_float,
y2: c_float,
);
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_path_builder_close(self_: *mut GskPathBuilder);
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_path_builder_conic_to(
self_: *mut GskPathBuilder,
x1: c_float,
y1: c_float,
x2: c_float,
y2: c_float,
weight: c_float,
);
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_path_builder_cubic_to(
self_: *mut GskPathBuilder,
x1: c_float,
y1: c_float,
x2: c_float,
y2: c_float,
x3: c_float,
y3: c_float,
);
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_path_builder_free_to_path(self_: *mut GskPathBuilder) -> *mut GskPath;
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_path_builder_get_current_point(
self_: *mut GskPathBuilder,
) -> *const graphene::graphene_point_t;
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_path_builder_html_arc_to(
self_: *mut GskPathBuilder,
x1: c_float,
y1: c_float,
x2: c_float,
y2: c_float,
radius: c_float,
);
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_path_builder_line_to(self_: *mut GskPathBuilder, x: c_float, y: c_float);
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_path_builder_move_to(self_: *mut GskPathBuilder, x: c_float, y: c_float);
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_path_builder_quad_to(
self_: *mut GskPathBuilder,
x1: c_float,
y1: c_float,
x2: c_float,
y2: c_float,
);
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_path_builder_ref(self_: *mut GskPathBuilder) -> *mut GskPathBuilder;
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_path_builder_rel_arc_to(
self_: *mut GskPathBuilder,
x1: c_float,
y1: c_float,
x2: c_float,
y2: c_float,
);
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_path_builder_rel_conic_to(
self_: *mut GskPathBuilder,
x1: c_float,
y1: c_float,
x2: c_float,
y2: c_float,
weight: c_float,
);
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_path_builder_rel_cubic_to(
self_: *mut GskPathBuilder,
x1: c_float,
y1: c_float,
x2: c_float,
y2: c_float,
x3: c_float,
y3: c_float,
);
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_path_builder_rel_html_arc_to(
self_: *mut GskPathBuilder,
x1: c_float,
y1: c_float,
x2: c_float,
y2: c_float,
radius: c_float,
);
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_path_builder_rel_line_to(self_: *mut GskPathBuilder, x: c_float, y: c_float);
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_path_builder_rel_move_to(self_: *mut GskPathBuilder, x: c_float, y: c_float);
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_path_builder_rel_quad_to(
self_: *mut GskPathBuilder,
x1: c_float,
y1: c_float,
x2: c_float,
y2: c_float,
);
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_path_builder_rel_svg_arc_to(
self_: *mut GskPathBuilder,
rx: c_float,
ry: c_float,
x_axis_rotation: c_float,
large_arc: gboolean,
positive_sweep: gboolean,
x: c_float,
y: c_float,
);
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_path_builder_svg_arc_to(
self_: *mut GskPathBuilder,
rx: c_float,
ry: c_float,
x_axis_rotation: c_float,
large_arc: gboolean,
positive_sweep: gboolean,
x: c_float,
y: c_float,
);
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_path_builder_to_path(self_: *mut GskPathBuilder) -> *mut GskPath;
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_path_builder_unref(self_: *mut GskPathBuilder);
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_path_measure_get_type() -> GType;
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_path_measure_new(path: *mut GskPath) -> *mut GskPathMeasure;
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_path_measure_new_with_tolerance(
path: *mut GskPath,
tolerance: c_float,
) -> *mut GskPathMeasure;
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_path_measure_get_length(self_: *mut GskPathMeasure) -> c_float;
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_path_measure_get_path(self_: *mut GskPathMeasure) -> *mut GskPath;
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_path_measure_get_point(
self_: *mut GskPathMeasure,
distance: c_float,
result: *mut GskPathPoint,
) -> gboolean;
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_path_measure_get_tolerance(self_: *mut GskPathMeasure) -> c_float;
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_path_measure_ref(self_: *mut GskPathMeasure) -> *mut GskPathMeasure;
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_path_measure_unref(self_: *mut GskPathMeasure);
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_path_point_get_type() -> GType;
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_path_point_compare(
point1: *const GskPathPoint,
point2: *const GskPathPoint,
) -> c_int;
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_path_point_copy(point: *mut GskPathPoint) -> *mut GskPathPoint;
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_path_point_equal(
point1: *const GskPathPoint,
point2: *const GskPathPoint,
) -> gboolean;
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_path_point_free(point: *mut GskPathPoint);
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_path_point_get_curvature(
point: *const GskPathPoint,
path: *mut GskPath,
direction: GskPathDirection,
center: *mut graphene::graphene_point_t,
) -> c_float;
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_path_point_get_distance(
point: *const GskPathPoint,
measure: *mut GskPathMeasure,
) -> c_float;
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_path_point_get_position(
point: *const GskPathPoint,
path: *mut GskPath,
position: *mut graphene::graphene_point_t,
);
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_path_point_get_rotation(
point: *const GskPathPoint,
path: *mut GskPath,
direction: GskPathDirection,
) -> c_float;
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_path_point_get_tangent(
point: *const GskPathPoint,
path: *mut GskPath,
direction: GskPathDirection,
tangent: *mut graphene::graphene_vec2_t,
);
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;
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);
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_stroke_get_type() -> GType;
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_stroke_new(line_width: c_float) -> *mut GskStroke;
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_stroke_copy(other: *const GskStroke) -> *mut GskStroke;
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_stroke_free(self_: *mut GskStroke);
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_stroke_get_dash(self_: *const GskStroke, n_dash: *mut size_t) -> *const c_float;
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_stroke_get_dash_offset(self_: *const GskStroke) -> c_float;
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_stroke_get_line_cap(self_: *const GskStroke) -> GskLineCap;
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_stroke_get_line_join(self_: *const GskStroke) -> GskLineJoin;
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_stroke_get_line_width(self_: *const GskStroke) -> c_float;
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_stroke_get_miter_limit(self_: *const GskStroke) -> c_float;
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_stroke_set_dash(self_: *mut GskStroke, dash: *const c_float, n_dash: size_t);
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_stroke_set_dash_offset(self_: *mut GskStroke, offset: c_float);
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_stroke_set_line_cap(self_: *mut GskStroke, line_cap: GskLineCap);
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_stroke_set_line_join(self_: *mut GskStroke, line_join: GskLineJoin);
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_stroke_set_line_width(self_: *mut GskStroke, line_width: c_float);
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_stroke_set_miter_limit(self_: *mut GskStroke, limit: c_float);
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_stroke_to_cairo(self_: *const GskStroke, cr: *mut cairo::cairo_t);
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_stroke_equal(stroke1: gconstpointer, stroke2: gconstpointer) -> gboolean;
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;
#[cfg(feature = "v4_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
pub fn gsk_transform_skew(
next: *mut GskTransform,
skew_x: c_float,
skew_y: 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,
);
#[cfg(feature = "v4_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
pub fn gsk_transform_to_2d_components(
self_: *mut GskTransform,
out_skew_x: *mut c_float,
out_skew_y: *mut c_float,
out_scale_x: *mut c_float,
out_scale_y: *mut c_float,
out_angle: *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;
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;
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;
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];
#[cfg(feature = "broadway")]
#[cfg_attr(docsrs, doc(cfg(feature = "broadway")))]
pub fn gsk_broadway_renderer_get_type() -> GType;
#[cfg(feature = "broadway")]
#[cfg_attr(docsrs, doc(cfg(feature = "broadway")))]
pub fn gsk_broadway_renderer_new() -> *mut GskRenderer;
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;
pub fn gsk_cairo_renderer_get_type() -> GType;
pub fn gsk_cairo_renderer_new() -> *mut GskRenderer;
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;
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;
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;
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(feature = "v4_2")]
#[cfg_attr(docsrs, 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;
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;
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;
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;
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_fill_node_get_type() -> GType;
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_fill_node_new(
child: *mut GskRenderNode,
path: *mut GskPath,
fill_rule: GskFillRule,
) -> *mut GskFillNode;
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_fill_node_get_child(node: *const GskFillNode) -> *mut GskRenderNode;
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_fill_node_get_fill_rule(node: *const GskFillNode) -> GskFillRule;
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_fill_node_get_path(node: *const GskFillNode) -> *mut GskPath;
#[cfg(feature = "v4_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_2")))]
pub fn gsk_gl_renderer_get_type() -> GType;
#[cfg(feature = "v4_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_2")))]
pub fn gsk_gl_renderer_new() -> *mut GskRenderer;
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_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;
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;
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;
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;
#[cfg(feature = "v4_10")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
pub fn gsk_mask_node_get_type() -> GType;
#[cfg(feature = "v4_10")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
pub fn gsk_mask_node_new(
source: *mut GskRenderNode,
mask: *mut GskRenderNode,
mask_mode: GskMaskMode,
) -> *mut GskMaskNode;
#[cfg(feature = "v4_10")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
pub fn gsk_mask_node_get_mask(node: *const GskMaskNode) -> *mut GskRenderNode;
#[cfg(feature = "v4_10")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
pub fn gsk_mask_node_get_mask_mode(node: *const GskMaskNode) -> GskMaskMode;
#[cfg(feature = "v4_10")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
pub fn gsk_mask_node_get_source(node: *const GskMaskNode) -> *mut GskRenderNode;
#[cfg(feature = "v4_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_2")))]
pub fn gsk_ngl_renderer_get_type() -> GType;
#[cfg(feature = "v4_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_2")))]
pub fn gsk_ngl_renderer_new() -> *mut GskRenderer;
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;
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;
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;
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;
#[cfg(feature = "v4_16")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_16")))]
pub fn gsk_render_node_get_opaque_rect(
self_: *mut GskRenderNode,
out_opaque: *mut graphene::graphene_rect_t,
) -> gboolean;
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;
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;
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_renderer_realize_for_display(
renderer: *mut GskRenderer,
display: *mut gdk::GdkDisplay,
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);
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;
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;
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;
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;
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;
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_stroke_node_get_type() -> GType;
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_stroke_node_new(
child: *mut GskRenderNode,
path: *mut GskPath,
stroke: *const GskStroke,
) -> *mut GskStrokeNode;
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_stroke_node_get_child(node: *const GskStrokeNode) -> *mut GskRenderNode;
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_stroke_node_get_path(node: *const GskStrokeNode) -> *mut GskPath;
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_stroke_node_get_stroke(node: *const GskStrokeNode) -> *const GskStroke;
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_subsurface_node_get_type() -> GType;
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_subsurface_node_new(
child: *mut GskRenderNode,
subsurface: gpointer,
) -> *mut GskSubsurfaceNode;
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_subsurface_node_get_subsurface(node: *const GskDebugNode) -> gpointer;
#[cfg(feature = "v4_14")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
pub fn gsk_subsurface_node_get_child(node: *const GskSubsurfaceNode) -> *mut GskRenderNode;
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(feature = "v4_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_2")))]
pub fn gsk_text_node_has_color_glyphs(node: *const GskTextNode) -> gboolean;
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;
#[cfg(feature = "v4_10")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
pub fn gsk_texture_scale_node_get_type() -> GType;
#[cfg(feature = "v4_10")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
pub fn gsk_texture_scale_node_new(
texture: *mut gdk::GdkTexture,
bounds: *const graphene::graphene_rect_t,
filter: GskScalingFilter,
) -> *mut GskTextureScaleNode;
#[cfg(feature = "v4_10")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
pub fn gsk_texture_scale_node_get_filter(node: *const GskTextureScaleNode) -> GskScalingFilter;
#[cfg(feature = "v4_10")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
pub fn gsk_texture_scale_node_get_texture(
node: *const GskTextureScaleNode,
) -> *mut gdk::GdkTexture;
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;
#[cfg(feature = "vulkan")]
#[cfg_attr(docsrs, doc(cfg(feature = "vulkan")))]
pub fn gsk_vulkan_renderer_get_type() -> GType;
#[cfg(feature = "vulkan")]
#[cfg_attr(docsrs, doc(cfg(feature = "vulkan")))]
pub fn gsk_vulkan_renderer_new() -> *mut GskRenderer;
#[cfg(feature = "v4_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
pub fn gsk_value_dup_render_node(value: *const gobject::GValue) -> *mut GskRenderNode;
#[cfg(feature = "v4_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
pub fn gsk_value_get_render_node(value: *const gobject::GValue) -> *mut GskRenderNode;
#[cfg(feature = "v4_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
pub fn gsk_value_set_render_node(value: *mut gobject::GValue, node: *mut GskRenderNode);
#[cfg(feature = "v4_6")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
pub fn gsk_value_take_render_node(value: *mut gobject::GValue, node: *mut GskRenderNode);
}