1#![allow(non_camel_case_types, non_upper_case_globals, non_snake_case)]
6#![allow(
7 clippy::approx_constant,
8 clippy::type_complexity,
9 clippy::unreadable_literal,
10 clippy::upper_case_acronyms
11)]
12#![cfg_attr(docsrs, feature(doc_cfg))]
13
14use cairo_sys as cairo;
15use gdk4_sys as gdk;
16use glib_sys as glib;
17use gobject_sys as gobject;
18use graphene_sys as graphene;
19use pango_sys as pango;
20
21#[cfg(unix)]
22#[allow(unused_imports)]
23use libc::{dev_t, gid_t, pid_t, socklen_t, uid_t};
24#[allow(unused_imports)]
25use libc::{intptr_t, off_t, size_t, ssize_t, time_t, uintptr_t, FILE};
26#[allow(unused_imports)]
27use std::ffi::{
28 c_char, c_double, c_float, c_int, c_long, c_short, c_uchar, c_uint, c_ulong, c_ushort, c_void,
29};
30
31#[allow(unused_imports)]
32use glib::{gboolean, gconstpointer, gpointer, GType};
33
34pub type GskBlendMode = c_int;
36pub const GSK_BLEND_MODE_DEFAULT: GskBlendMode = 0;
37pub const GSK_BLEND_MODE_MULTIPLY: GskBlendMode = 1;
38pub const GSK_BLEND_MODE_SCREEN: GskBlendMode = 2;
39pub const GSK_BLEND_MODE_OVERLAY: GskBlendMode = 3;
40pub const GSK_BLEND_MODE_DARKEN: GskBlendMode = 4;
41pub const GSK_BLEND_MODE_LIGHTEN: GskBlendMode = 5;
42pub const GSK_BLEND_MODE_COLOR_DODGE: GskBlendMode = 6;
43pub const GSK_BLEND_MODE_COLOR_BURN: GskBlendMode = 7;
44pub const GSK_BLEND_MODE_HARD_LIGHT: GskBlendMode = 8;
45pub const GSK_BLEND_MODE_SOFT_LIGHT: GskBlendMode = 9;
46pub const GSK_BLEND_MODE_DIFFERENCE: GskBlendMode = 10;
47pub const GSK_BLEND_MODE_EXCLUSION: GskBlendMode = 11;
48pub const GSK_BLEND_MODE_COLOR: GskBlendMode = 12;
49pub const GSK_BLEND_MODE_HUE: GskBlendMode = 13;
50pub const GSK_BLEND_MODE_SATURATION: GskBlendMode = 14;
51pub const GSK_BLEND_MODE_LUMINOSITY: GskBlendMode = 15;
52
53pub type GskCorner = c_int;
54pub const GSK_CORNER_TOP_LEFT: GskCorner = 0;
55pub const GSK_CORNER_TOP_RIGHT: GskCorner = 1;
56pub const GSK_CORNER_BOTTOM_RIGHT: GskCorner = 2;
57pub const GSK_CORNER_BOTTOM_LEFT: GskCorner = 3;
58
59pub type GskFillRule = c_int;
60pub const GSK_FILL_RULE_WINDING: GskFillRule = 0;
61pub const GSK_FILL_RULE_EVEN_ODD: GskFillRule = 1;
62
63pub type GskGLUniformType = c_int;
64pub const GSK_GL_UNIFORM_TYPE_NONE: GskGLUniformType = 0;
65pub const GSK_GL_UNIFORM_TYPE_FLOAT: GskGLUniformType = 1;
66pub const GSK_GL_UNIFORM_TYPE_INT: GskGLUniformType = 2;
67pub const GSK_GL_UNIFORM_TYPE_UINT: GskGLUniformType = 3;
68pub const GSK_GL_UNIFORM_TYPE_BOOL: GskGLUniformType = 4;
69pub const GSK_GL_UNIFORM_TYPE_VEC2: GskGLUniformType = 5;
70pub const GSK_GL_UNIFORM_TYPE_VEC3: GskGLUniformType = 6;
71pub const GSK_GL_UNIFORM_TYPE_VEC4: GskGLUniformType = 7;
72
73pub type GskLineCap = c_int;
74pub const GSK_LINE_CAP_BUTT: GskLineCap = 0;
75pub const GSK_LINE_CAP_ROUND: GskLineCap = 1;
76pub const GSK_LINE_CAP_SQUARE: GskLineCap = 2;
77
78pub type GskLineJoin = c_int;
79pub const GSK_LINE_JOIN_MITER: GskLineJoin = 0;
80pub const GSK_LINE_JOIN_ROUND: GskLineJoin = 1;
81pub const GSK_LINE_JOIN_BEVEL: GskLineJoin = 2;
82
83pub type GskMaskMode = c_int;
84pub const GSK_MASK_MODE_ALPHA: GskMaskMode = 0;
85pub const GSK_MASK_MODE_INVERTED_ALPHA: GskMaskMode = 1;
86pub const GSK_MASK_MODE_LUMINANCE: GskMaskMode = 2;
87pub const GSK_MASK_MODE_INVERTED_LUMINANCE: GskMaskMode = 3;
88
89pub type GskPathDirection = c_int;
90pub const GSK_PATH_FROM_START: GskPathDirection = 0;
91pub const GSK_PATH_TO_START: GskPathDirection = 1;
92pub const GSK_PATH_TO_END: GskPathDirection = 2;
93pub const GSK_PATH_FROM_END: GskPathDirection = 3;
94
95pub type GskPathIntersection = c_int;
96pub const GSK_PATH_INTERSECTION_NONE: GskPathIntersection = 0;
97pub const GSK_PATH_INTERSECTION_NORMAL: GskPathIntersection = 1;
98pub const GSK_PATH_INTERSECTION_START: GskPathIntersection = 2;
99pub const GSK_PATH_INTERSECTION_END: GskPathIntersection = 3;
100
101pub type GskPathOperation = c_int;
102pub const GSK_PATH_MOVE: GskPathOperation = 0;
103pub const GSK_PATH_CLOSE: GskPathOperation = 1;
104pub const GSK_PATH_LINE: GskPathOperation = 2;
105pub const GSK_PATH_QUAD: GskPathOperation = 3;
106pub const GSK_PATH_CUBIC: GskPathOperation = 4;
107pub const GSK_PATH_CONIC: GskPathOperation = 5;
108
109pub type GskPorterDuff = c_int;
110pub const GSK_PORTER_DUFF_SOURCE: GskPorterDuff = 0;
111pub const GSK_PORTER_DUFF_DEST: GskPorterDuff = 1;
112pub const GSK_PORTER_DUFF_SOURCE_OVER_DEST: GskPorterDuff = 2;
113pub const GSK_PORTER_DUFF_DEST_OVER_SOURCE: GskPorterDuff = 3;
114pub const GSK_PORTER_DUFF_SOURCE_IN_DEST: GskPorterDuff = 4;
115pub const GSK_PORTER_DUFF_DEST_IN_SOURCE: GskPorterDuff = 5;
116pub const GSK_PORTER_DUFF_SOURCE_OUT_DEST: GskPorterDuff = 6;
117pub const GSK_PORTER_DUFF_DEST_OUT_SOURCE: GskPorterDuff = 7;
118pub const GSK_PORTER_DUFF_SOURCE_ATOP_DEST: GskPorterDuff = 8;
119pub const GSK_PORTER_DUFF_DEST_ATOP_SOURCE: GskPorterDuff = 9;
120pub const GSK_PORTER_DUFF_XOR: GskPorterDuff = 10;
121pub const GSK_PORTER_DUFF_CLEAR: GskPorterDuff = 11;
122
123pub type GskRenderNodeType = c_int;
124pub const GSK_NOT_A_RENDER_NODE: GskRenderNodeType = 0;
125pub const GSK_CONTAINER_NODE: GskRenderNodeType = 1;
126pub const GSK_CAIRO_NODE: GskRenderNodeType = 2;
127pub const GSK_COLOR_NODE: GskRenderNodeType = 3;
128pub const GSK_LINEAR_GRADIENT_NODE: GskRenderNodeType = 4;
129pub const GSK_REPEATING_LINEAR_GRADIENT_NODE: GskRenderNodeType = 5;
130pub const GSK_RADIAL_GRADIENT_NODE: GskRenderNodeType = 6;
131pub const GSK_REPEATING_RADIAL_GRADIENT_NODE: GskRenderNodeType = 7;
132pub const GSK_CONIC_GRADIENT_NODE: GskRenderNodeType = 8;
133pub const GSK_BORDER_NODE: GskRenderNodeType = 9;
134pub const GSK_TEXTURE_NODE: GskRenderNodeType = 10;
135pub const GSK_INSET_SHADOW_NODE: GskRenderNodeType = 11;
136pub const GSK_OUTSET_SHADOW_NODE: GskRenderNodeType = 12;
137pub const GSK_TRANSFORM_NODE: GskRenderNodeType = 13;
138pub const GSK_OPACITY_NODE: GskRenderNodeType = 14;
139pub const GSK_COLOR_MATRIX_NODE: GskRenderNodeType = 15;
140pub const GSK_REPEAT_NODE: GskRenderNodeType = 16;
141pub const GSK_CLIP_NODE: GskRenderNodeType = 17;
142pub const GSK_ROUNDED_CLIP_NODE: GskRenderNodeType = 18;
143pub const GSK_SHADOW_NODE: GskRenderNodeType = 19;
144pub const GSK_BLEND_NODE: GskRenderNodeType = 20;
145pub const GSK_CROSS_FADE_NODE: GskRenderNodeType = 21;
146pub const GSK_TEXT_NODE: GskRenderNodeType = 22;
147pub const GSK_BLUR_NODE: GskRenderNodeType = 23;
148pub const GSK_DEBUG_NODE: GskRenderNodeType = 24;
149pub const GSK_GL_SHADER_NODE: GskRenderNodeType = 25;
150#[cfg(feature = "v4_10")]
151#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
152pub const GSK_TEXTURE_SCALE_NODE: GskRenderNodeType = 26;
153#[cfg(feature = "v4_10")]
154#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
155pub const GSK_MASK_NODE: GskRenderNodeType = 27;
156#[cfg(feature = "v4_14")]
157#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
158pub const GSK_FILL_NODE: GskRenderNodeType = 28;
159#[cfg(feature = "v4_14")]
160#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
161pub const GSK_STROKE_NODE: GskRenderNodeType = 29;
162#[cfg(feature = "v4_14")]
163#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
164pub const GSK_SUBSURFACE_NODE: GskRenderNodeType = 30;
165#[cfg(feature = "v4_20")]
166#[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
167pub const GSK_COMPONENT_TRANSFER_NODE: GskRenderNodeType = 31;
168#[cfg(feature = "v4_22")]
169#[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
170pub const GSK_COPY_NODE: GskRenderNodeType = 32;
171#[cfg(feature = "v4_22")]
172#[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
173pub const GSK_PASTE_NODE: GskRenderNodeType = 33;
174#[cfg(feature = "v4_22")]
175#[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
176pub const GSK_COMPOSITE_NODE: GskRenderNodeType = 34;
177#[cfg(feature = "v4_22")]
178#[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
179pub const GSK_ISOLATION_NODE: GskRenderNodeType = 35;
180#[cfg(feature = "v4_22")]
181#[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
182pub const GSK_DISPLACEMENT_NODE: GskRenderNodeType = 36;
183#[cfg(feature = "v4_22")]
184#[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
185pub const GSK_ARITHMETIC_NODE: GskRenderNodeType = 37;
186
187pub type GskScalingFilter = c_int;
188pub const GSK_SCALING_FILTER_LINEAR: GskScalingFilter = 0;
189pub const GSK_SCALING_FILTER_NEAREST: GskScalingFilter = 1;
190pub const GSK_SCALING_FILTER_TRILINEAR: GskScalingFilter = 2;
191
192pub type GskSerializationError = c_int;
193pub const GSK_SERIALIZATION_UNSUPPORTED_FORMAT: GskSerializationError = 0;
194pub const GSK_SERIALIZATION_UNSUPPORTED_VERSION: GskSerializationError = 1;
195pub const GSK_SERIALIZATION_INVALID_DATA: GskSerializationError = 2;
196
197pub type GskTransformCategory = c_int;
198pub const GSK_TRANSFORM_CATEGORY_UNKNOWN: GskTransformCategory = 0;
199pub const GSK_TRANSFORM_CATEGORY_ANY: GskTransformCategory = 1;
200pub const GSK_TRANSFORM_CATEGORY_3D: GskTransformCategory = 2;
201pub const GSK_TRANSFORM_CATEGORY_2D: GskTransformCategory = 3;
202pub const GSK_TRANSFORM_CATEGORY_2D_AFFINE: GskTransformCategory = 4;
203pub const GSK_TRANSFORM_CATEGORY_2D_TRANSLATE: GskTransformCategory = 5;
204pub const GSK_TRANSFORM_CATEGORY_IDENTITY: GskTransformCategory = 6;
205
206pub type GskIsolation = c_uint;
208pub const GSK_ISOLATION_NONE: GskIsolation = 0;
209pub const GSK_ISOLATION_BACKGROUND: GskIsolation = 1;
210pub const GSK_ISOLATION_COPY_PASTE: GskIsolation = 2;
211pub const GSK_ISOLATION_ALL: GskIsolation = 4294967295;
212
213pub type GskPathForeachFlags = c_uint;
214pub const GSK_PATH_FOREACH_ALLOW_ONLY_LINES: GskPathForeachFlags = 0;
215pub const GSK_PATH_FOREACH_ALLOW_QUAD: GskPathForeachFlags = 1;
216pub const GSK_PATH_FOREACH_ALLOW_CUBIC: GskPathForeachFlags = 2;
217pub const GSK_PATH_FOREACH_ALLOW_CONIC: GskPathForeachFlags = 4;
218
219#[derive(Copy, Clone)]
221#[repr(C)]
222pub union GskPathPoint_u1 {
223 pub s1: GskPathPoint__s1,
224 pub padding: [gpointer; 8],
225 pub alignment: graphene::graphene_vec4_t,
226}
227
228impl ::std::fmt::Debug for GskPathPoint_u1 {
229 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
230 f.debug_struct(&format!("GskPathPoint_u1 @ {self:p}"))
231 .field("s1", unsafe { &self.s1 })
232 .field("padding", unsafe { &self.padding })
233 .field("alignment", unsafe { &self.alignment })
234 .finish()
235 }
236}
237
238pub type GskParseErrorFunc = Option<
240 unsafe extern "C" fn(
241 *const GskParseLocation,
242 *const GskParseLocation,
243 *const glib::GError,
244 gpointer,
245 ),
246>;
247pub type GskPathForeachFunc = Option<
248 unsafe extern "C" fn(
249 GskPathOperation,
250 *const graphene::graphene_point_t,
251 size_t,
252 c_float,
253 gpointer,
254 ) -> gboolean,
255>;
256pub type GskPathIntersectionFunc = Option<
257 unsafe extern "C" fn(
258 *mut GskPath,
259 *const GskPathPoint,
260 *mut GskPath,
261 *const GskPathPoint,
262 GskPathIntersection,
263 gpointer,
264 ) -> gboolean,
265>;
266pub type GskRenderReplayFontFilter = Option<
267 unsafe extern "C" fn(
268 *mut GskRenderReplay,
269 *mut pango::PangoFont,
270 gpointer,
271 ) -> *mut pango::PangoFont,
272>;
273pub type GskRenderReplayNodeFilter = Option<
274 unsafe extern "C" fn(*mut GskRenderReplay, *mut GskRenderNode, gpointer) -> *mut GskRenderNode,
275>;
276pub type GskRenderReplayNodeForeach =
277 Option<unsafe extern "C" fn(*mut GskRenderReplay, *mut GskRenderNode, gpointer) -> gboolean>;
278pub type GskRenderReplayTextureFilter = Option<
279 unsafe extern "C" fn(
280 *mut GskRenderReplay,
281 *mut gdk::GdkTexture,
282 gpointer,
283 ) -> *mut gdk::GdkTexture,
284>;
285
286#[cfg(feature = "broadway")]
288#[cfg_attr(docsrs, doc(cfg(feature = "broadway")))]
289#[repr(C)]
290#[allow(dead_code)]
291pub struct _GskBroadwayRendererClass {
292 _data: [u8; 0],
293 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
294}
295
296#[cfg(feature = "broadway")]
297#[cfg_attr(docsrs, doc(cfg(feature = "broadway")))]
298pub type GskBroadwayRendererClass = _GskBroadwayRendererClass;
299
300#[repr(C)]
301#[allow(dead_code)]
302pub struct _GskCairoRendererClass {
303 _data: [u8; 0],
304 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
305}
306
307pub type GskCairoRendererClass = _GskCairoRendererClass;
308
309#[derive(Copy, Clone)]
310#[repr(C)]
311pub struct GskColorStop {
312 pub offset: c_float,
313 pub color: gdk::GdkRGBA,
314}
315
316impl ::std::fmt::Debug for GskColorStop {
317 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
318 f.debug_struct(&format!("GskColorStop @ {self:p}"))
319 .field("offset", &self.offset)
320 .field("color", &self.color)
321 .finish()
322 }
323}
324
325#[repr(C)]
326#[allow(dead_code)]
327pub struct GskComponentTransfer {
328 _data: [u8; 0],
329 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
330}
331
332impl ::std::fmt::Debug for GskComponentTransfer {
333 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
334 f.debug_struct(&format!("GskComponentTransfer @ {self:p}"))
335 .finish()
336 }
337}
338
339#[repr(C)]
340#[allow(dead_code)]
341pub struct _GskGLRendererClass {
342 _data: [u8; 0],
343 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
344}
345
346pub type GskGLRendererClass = _GskGLRendererClass;
347
348#[derive(Copy, Clone)]
349#[repr(C)]
350pub struct GskGLShaderClass {
351 pub parent_class: gobject::GObjectClass,
352}
353
354impl ::std::fmt::Debug for GskGLShaderClass {
355 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
356 f.debug_struct(&format!("GskGLShaderClass @ {self:p}"))
357 .field("parent_class", &self.parent_class)
358 .finish()
359 }
360}
361
362#[derive(Copy, Clone)]
363#[repr(C)]
364pub struct GskParseLocation {
365 pub bytes: size_t,
366 pub chars: size_t,
367 pub lines: size_t,
368 pub line_bytes: size_t,
369 pub line_chars: size_t,
370}
371
372impl ::std::fmt::Debug for GskParseLocation {
373 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
374 f.debug_struct(&format!("GskParseLocation @ {self:p}"))
375 .field("bytes", &self.bytes)
376 .field("chars", &self.chars)
377 .field("lines", &self.lines)
378 .field("line_bytes", &self.line_bytes)
379 .field("line_chars", &self.line_chars)
380 .finish()
381 }
382}
383
384#[repr(C)]
385#[allow(dead_code)]
386pub struct GskPath {
387 _data: [u8; 0],
388 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
389}
390
391impl ::std::fmt::Debug for GskPath {
392 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
393 f.debug_struct(&format!("GskPath @ {self:p}")).finish()
394 }
395}
396
397#[repr(C)]
398#[allow(dead_code)]
399pub struct GskPathBuilder {
400 _data: [u8; 0],
401 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
402}
403
404impl ::std::fmt::Debug for GskPathBuilder {
405 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
406 f.debug_struct(&format!("GskPathBuilder @ {self:p}"))
407 .finish()
408 }
409}
410
411#[repr(C)]
412#[allow(dead_code)]
413pub struct GskPathMeasure {
414 _data: [u8; 0],
415 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
416}
417
418impl ::std::fmt::Debug for GskPathMeasure {
419 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
420 f.debug_struct(&format!("GskPathMeasure @ {self:p}"))
421 .finish()
422 }
423}
424
425#[derive(Copy, Clone)]
426#[repr(C)]
427pub struct GskPathPoint {
428 pub u1: GskPathPoint_u1,
429}
430
431impl ::std::fmt::Debug for GskPathPoint {
432 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
433 f.debug_struct(&format!("GskPathPoint @ {self:p}"))
434 .field("u1", &self.u1)
435 .finish()
436 }
437}
438
439#[derive(Copy, Clone)]
440#[repr(C)]
441pub struct GskPathPoint__s1 {
442 pub contour: size_t,
443 pub idx: size_t,
444 pub t: c_float,
445}
446
447impl ::std::fmt::Debug for GskPathPoint__s1 {
448 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
449 f.debug_struct(&format!("GskPathPoint__s1 @ {self:p}"))
450 .field("contour", &self.contour)
451 .field("idx", &self.idx)
452 .field("t", &self.t)
453 .finish()
454 }
455}
456
457#[repr(C)]
458#[allow(dead_code)]
459pub struct _GskRenderReplay {
460 _data: [u8; 0],
461 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
462}
463
464pub type GskRenderReplay = _GskRenderReplay;
465
466#[repr(C)]
467#[allow(dead_code)]
468pub struct _GskRendererClass {
469 _data: [u8; 0],
470 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
471}
472
473pub type GskRendererClass = _GskRendererClass;
474
475#[derive(Copy, Clone)]
476#[repr(C)]
477pub struct GskRoundedRect {
478 pub bounds: graphene::graphene_rect_t,
479 pub corner: [graphene::graphene_size_t; 4],
480}
481
482impl ::std::fmt::Debug for GskRoundedRect {
483 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
484 f.debug_struct(&format!("GskRoundedRect @ {self:p}"))
485 .field("bounds", &self.bounds)
486 .field("corner", &self.corner)
487 .finish()
488 }
489}
490
491#[repr(C)]
492#[allow(dead_code)]
493pub struct GskShaderArgsBuilder {
494 _data: [u8; 0],
495 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
496}
497
498impl ::std::fmt::Debug for GskShaderArgsBuilder {
499 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
500 f.debug_struct(&format!("GskShaderArgsBuilder @ {self:p}"))
501 .finish()
502 }
503}
504
505#[derive(Copy, Clone)]
506#[repr(C)]
507pub struct GskShadow {
508 pub color: gdk::GdkRGBA,
509 pub dx: c_float,
510 pub dy: c_float,
511 pub radius: c_float,
512}
513
514impl ::std::fmt::Debug for GskShadow {
515 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
516 f.debug_struct(&format!("GskShadow @ {self:p}"))
517 .field("color", &self.color)
518 .field("dx", &self.dx)
519 .field("dy", &self.dy)
520 .field("radius", &self.radius)
521 .finish()
522 }
523}
524
525#[repr(C)]
526#[allow(dead_code)]
527pub struct GskStroke {
528 _data: [u8; 0],
529 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
530}
531
532impl ::std::fmt::Debug for GskStroke {
533 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
534 f.debug_struct(&format!("GskStroke @ {self:p}")).finish()
535 }
536}
537
538#[repr(C)]
539#[allow(dead_code)]
540pub struct GskTransform {
541 _data: [u8; 0],
542 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
543}
544
545impl ::std::fmt::Debug for GskTransform {
546 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
547 f.debug_struct(&format!("GskTransform @ {self:p}")).finish()
548 }
549}
550
551#[cfg(feature = "vulkan")]
552#[cfg_attr(docsrs, doc(cfg(feature = "vulkan")))]
553#[repr(C)]
554#[allow(dead_code)]
555pub struct _GskVulkanRendererClass {
556 _data: [u8; 0],
557 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
558}
559
560#[cfg(feature = "vulkan")]
561#[cfg_attr(docsrs, doc(cfg(feature = "vulkan")))]
562pub type GskVulkanRendererClass = _GskVulkanRendererClass;
563
564#[repr(C)]
566#[allow(dead_code)]
567pub struct GskBlendNode {
568 _data: [u8; 0],
569 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
570}
571
572impl ::std::fmt::Debug for GskBlendNode {
573 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
574 f.debug_struct(&format!("GskBlendNode @ {self:p}")).finish()
575 }
576}
577
578#[repr(C)]
579#[allow(dead_code)]
580pub struct GskBlurNode {
581 _data: [u8; 0],
582 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
583}
584
585impl ::std::fmt::Debug for GskBlurNode {
586 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
587 f.debug_struct(&format!("GskBlurNode @ {self:p}")).finish()
588 }
589}
590
591#[repr(C)]
592#[allow(dead_code)]
593pub struct GskBorderNode {
594 _data: [u8; 0],
595 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
596}
597
598impl ::std::fmt::Debug for GskBorderNode {
599 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
600 f.debug_struct(&format!("GskBorderNode @ {self:p}"))
601 .finish()
602 }
603}
604
605#[cfg(feature = "broadway")]
606#[cfg_attr(docsrs, doc(cfg(feature = "broadway")))]
607#[repr(C)]
608#[allow(dead_code)]
609pub struct GskBroadwayRenderer {
610 _data: [u8; 0],
611 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
612}
613
614#[cfg(feature = "broadway")]
615#[cfg_attr(docsrs, doc(cfg(feature = "broadway")))]
616impl ::std::fmt::Debug for GskBroadwayRenderer {
617 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
618 f.debug_struct(&format!("GskBroadwayRenderer @ {self:p}"))
619 .finish()
620 }
621}
622
623#[repr(C)]
624#[allow(dead_code)]
625pub struct GskCairoNode {
626 _data: [u8; 0],
627 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
628}
629
630impl ::std::fmt::Debug for GskCairoNode {
631 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
632 f.debug_struct(&format!("GskCairoNode @ {self:p}")).finish()
633 }
634}
635
636#[repr(C)]
637#[allow(dead_code)]
638pub struct GskCairoRenderer {
639 _data: [u8; 0],
640 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
641}
642
643impl ::std::fmt::Debug for GskCairoRenderer {
644 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
645 f.debug_struct(&format!("GskCairoRenderer @ {self:p}"))
646 .finish()
647 }
648}
649
650#[repr(C)]
651#[allow(dead_code)]
652pub struct GskClipNode {
653 _data: [u8; 0],
654 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
655}
656
657impl ::std::fmt::Debug for GskClipNode {
658 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
659 f.debug_struct(&format!("GskClipNode @ {self:p}")).finish()
660 }
661}
662
663#[repr(C)]
664#[allow(dead_code)]
665pub struct GskColorMatrixNode {
666 _data: [u8; 0],
667 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
668}
669
670impl ::std::fmt::Debug for GskColorMatrixNode {
671 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
672 f.debug_struct(&format!("GskColorMatrixNode @ {self:p}"))
673 .finish()
674 }
675}
676
677#[repr(C)]
678#[allow(dead_code)]
679pub struct GskColorNode {
680 _data: [u8; 0],
681 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
682}
683
684impl ::std::fmt::Debug for GskColorNode {
685 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
686 f.debug_struct(&format!("GskColorNode @ {self:p}")).finish()
687 }
688}
689
690#[repr(C)]
691#[allow(dead_code)]
692pub struct GskComponentTransferNode {
693 _data: [u8; 0],
694 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
695}
696
697impl ::std::fmt::Debug for GskComponentTransferNode {
698 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
699 f.debug_struct(&format!("GskComponentTransferNode @ {self:p}"))
700 .finish()
701 }
702}
703
704#[repr(C)]
705#[allow(dead_code)]
706pub struct GskCompositeNode {
707 _data: [u8; 0],
708 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
709}
710
711impl ::std::fmt::Debug for GskCompositeNode {
712 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
713 f.debug_struct(&format!("GskCompositeNode @ {self:p}"))
714 .finish()
715 }
716}
717
718#[repr(C)]
719#[allow(dead_code)]
720pub struct GskConicGradientNode {
721 _data: [u8; 0],
722 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
723}
724
725impl ::std::fmt::Debug for GskConicGradientNode {
726 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
727 f.debug_struct(&format!("GskConicGradientNode @ {self:p}"))
728 .finish()
729 }
730}
731
732#[repr(C)]
733#[allow(dead_code)]
734pub struct GskContainerNode {
735 _data: [u8; 0],
736 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
737}
738
739impl ::std::fmt::Debug for GskContainerNode {
740 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
741 f.debug_struct(&format!("GskContainerNode @ {self:p}"))
742 .finish()
743 }
744}
745
746#[repr(C)]
747#[allow(dead_code)]
748pub struct GskCopyNode {
749 _data: [u8; 0],
750 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
751}
752
753impl ::std::fmt::Debug for GskCopyNode {
754 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
755 f.debug_struct(&format!("GskCopyNode @ {self:p}")).finish()
756 }
757}
758
759#[repr(C)]
760#[allow(dead_code)]
761pub struct GskCrossFadeNode {
762 _data: [u8; 0],
763 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
764}
765
766impl ::std::fmt::Debug for GskCrossFadeNode {
767 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
768 f.debug_struct(&format!("GskCrossFadeNode @ {self:p}"))
769 .finish()
770 }
771}
772
773#[repr(C)]
774#[allow(dead_code)]
775pub struct GskDebugNode {
776 _data: [u8; 0],
777 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
778}
779
780impl ::std::fmt::Debug for GskDebugNode {
781 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
782 f.debug_struct(&format!("GskDebugNode @ {self:p}")).finish()
783 }
784}
785
786#[repr(C)]
787#[allow(dead_code)]
788pub struct GskFillNode {
789 _data: [u8; 0],
790 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
791}
792
793impl ::std::fmt::Debug for GskFillNode {
794 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
795 f.debug_struct(&format!("GskFillNode @ {self:p}")).finish()
796 }
797}
798
799#[repr(C)]
800#[allow(dead_code)]
801pub struct GskGLRenderer {
802 _data: [u8; 0],
803 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
804}
805
806impl ::std::fmt::Debug for GskGLRenderer {
807 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
808 f.debug_struct(&format!("GskGLRenderer @ {self:p}"))
809 .finish()
810 }
811}
812
813#[repr(C)]
814#[allow(dead_code)]
815pub struct GskGLShader {
816 _data: [u8; 0],
817 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
818}
819
820impl ::std::fmt::Debug for GskGLShader {
821 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
822 f.debug_struct(&format!("GskGLShader @ {self:p}")).finish()
823 }
824}
825
826#[repr(C)]
827#[allow(dead_code)]
828pub struct GskGLShaderNode {
829 _data: [u8; 0],
830 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
831}
832
833impl ::std::fmt::Debug for GskGLShaderNode {
834 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
835 f.debug_struct(&format!("GskGLShaderNode @ {self:p}"))
836 .finish()
837 }
838}
839
840#[repr(C)]
841#[allow(dead_code)]
842pub struct GskInsetShadowNode {
843 _data: [u8; 0],
844 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
845}
846
847impl ::std::fmt::Debug for GskInsetShadowNode {
848 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
849 f.debug_struct(&format!("GskInsetShadowNode @ {self:p}"))
850 .finish()
851 }
852}
853
854#[repr(C)]
855#[allow(dead_code)]
856pub struct GskIsolationNode {
857 _data: [u8; 0],
858 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
859}
860
861impl ::std::fmt::Debug for GskIsolationNode {
862 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
863 f.debug_struct(&format!("GskIsolationNode @ {self:p}"))
864 .finish()
865 }
866}
867
868#[repr(C)]
869#[allow(dead_code)]
870pub struct GskLinearGradientNode {
871 _data: [u8; 0],
872 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
873}
874
875impl ::std::fmt::Debug for GskLinearGradientNode {
876 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
877 f.debug_struct(&format!("GskLinearGradientNode @ {self:p}"))
878 .finish()
879 }
880}
881
882#[repr(C)]
883#[allow(dead_code)]
884pub struct GskMaskNode {
885 _data: [u8; 0],
886 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
887}
888
889impl ::std::fmt::Debug for GskMaskNode {
890 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
891 f.debug_struct(&format!("GskMaskNode @ {self:p}")).finish()
892 }
893}
894
895#[repr(C)]
896#[allow(dead_code)]
897pub struct GskNglRenderer {
898 _data: [u8; 0],
899 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
900}
901
902impl ::std::fmt::Debug for GskNglRenderer {
903 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
904 f.debug_struct(&format!("GskNglRenderer @ {self:p}"))
905 .finish()
906 }
907}
908
909#[repr(C)]
910#[allow(dead_code)]
911pub struct GskOpacityNode {
912 _data: [u8; 0],
913 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
914}
915
916impl ::std::fmt::Debug for GskOpacityNode {
917 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
918 f.debug_struct(&format!("GskOpacityNode @ {self:p}"))
919 .finish()
920 }
921}
922
923#[repr(C)]
924#[allow(dead_code)]
925pub struct GskOutsetShadowNode {
926 _data: [u8; 0],
927 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
928}
929
930impl ::std::fmt::Debug for GskOutsetShadowNode {
931 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
932 f.debug_struct(&format!("GskOutsetShadowNode @ {self:p}"))
933 .finish()
934 }
935}
936
937#[repr(C)]
938#[allow(dead_code)]
939pub struct GskPasteNode {
940 _data: [u8; 0],
941 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
942}
943
944impl ::std::fmt::Debug for GskPasteNode {
945 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
946 f.debug_struct(&format!("GskPasteNode @ {self:p}")).finish()
947 }
948}
949
950#[repr(C)]
951#[allow(dead_code)]
952pub struct GskRadialGradientNode {
953 _data: [u8; 0],
954 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
955}
956
957impl ::std::fmt::Debug for GskRadialGradientNode {
958 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
959 f.debug_struct(&format!("GskRadialGradientNode @ {self:p}"))
960 .finish()
961 }
962}
963
964#[repr(C)]
965#[allow(dead_code)]
966pub struct GskRenderNode {
967 _data: [u8; 0],
968 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
969}
970
971impl ::std::fmt::Debug for GskRenderNode {
972 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
973 f.debug_struct(&format!("GskRenderNode @ {self:p}"))
974 .finish()
975 }
976}
977
978#[repr(C)]
979#[allow(dead_code)]
980pub struct GskRenderer {
981 _data: [u8; 0],
982 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
983}
984
985impl ::std::fmt::Debug for GskRenderer {
986 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
987 f.debug_struct(&format!("GskRenderer @ {self:p}")).finish()
988 }
989}
990
991#[repr(C)]
992#[allow(dead_code)]
993pub struct GskRepeatNode {
994 _data: [u8; 0],
995 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
996}
997
998impl ::std::fmt::Debug for GskRepeatNode {
999 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1000 f.debug_struct(&format!("GskRepeatNode @ {self:p}"))
1001 .finish()
1002 }
1003}
1004
1005#[repr(C)]
1006#[allow(dead_code)]
1007pub struct GskRepeatingLinearGradientNode {
1008 _data: [u8; 0],
1009 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1010}
1011
1012impl ::std::fmt::Debug for GskRepeatingLinearGradientNode {
1013 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1014 f.debug_struct(&format!("GskRepeatingLinearGradientNode @ {self:p}"))
1015 .finish()
1016 }
1017}
1018
1019#[repr(C)]
1020#[allow(dead_code)]
1021pub struct GskRepeatingRadialGradientNode {
1022 _data: [u8; 0],
1023 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1024}
1025
1026impl ::std::fmt::Debug for GskRepeatingRadialGradientNode {
1027 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1028 f.debug_struct(&format!("GskRepeatingRadialGradientNode @ {self:p}"))
1029 .finish()
1030 }
1031}
1032
1033#[repr(C)]
1034#[allow(dead_code)]
1035pub struct GskRoundedClipNode {
1036 _data: [u8; 0],
1037 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1038}
1039
1040impl ::std::fmt::Debug for GskRoundedClipNode {
1041 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1042 f.debug_struct(&format!("GskRoundedClipNode @ {self:p}"))
1043 .finish()
1044 }
1045}
1046
1047#[repr(C)]
1048#[allow(dead_code)]
1049pub struct GskShadowNode {
1050 _data: [u8; 0],
1051 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1052}
1053
1054impl ::std::fmt::Debug for GskShadowNode {
1055 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1056 f.debug_struct(&format!("GskShadowNode @ {self:p}"))
1057 .finish()
1058 }
1059}
1060
1061#[repr(C)]
1062#[allow(dead_code)]
1063pub struct GskStrokeNode {
1064 _data: [u8; 0],
1065 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1066}
1067
1068impl ::std::fmt::Debug for GskStrokeNode {
1069 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1070 f.debug_struct(&format!("GskStrokeNode @ {self:p}"))
1071 .finish()
1072 }
1073}
1074
1075#[repr(C)]
1076#[allow(dead_code)]
1077pub struct GskSubsurfaceNode {
1078 _data: [u8; 0],
1079 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1080}
1081
1082impl ::std::fmt::Debug for GskSubsurfaceNode {
1083 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1084 f.debug_struct(&format!("GskSubsurfaceNode @ {self:p}"))
1085 .finish()
1086 }
1087}
1088
1089#[repr(C)]
1090#[allow(dead_code)]
1091pub struct GskTextNode {
1092 _data: [u8; 0],
1093 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1094}
1095
1096impl ::std::fmt::Debug for GskTextNode {
1097 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1098 f.debug_struct(&format!("GskTextNode @ {self:p}")).finish()
1099 }
1100}
1101
1102#[repr(C)]
1103#[allow(dead_code)]
1104pub struct GskTextureNode {
1105 _data: [u8; 0],
1106 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1107}
1108
1109impl ::std::fmt::Debug for GskTextureNode {
1110 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1111 f.debug_struct(&format!("GskTextureNode @ {self:p}"))
1112 .finish()
1113 }
1114}
1115
1116#[repr(C)]
1117#[allow(dead_code)]
1118pub struct GskTextureScaleNode {
1119 _data: [u8; 0],
1120 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1121}
1122
1123impl ::std::fmt::Debug for GskTextureScaleNode {
1124 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1125 f.debug_struct(&format!("GskTextureScaleNode @ {self:p}"))
1126 .finish()
1127 }
1128}
1129
1130#[repr(C)]
1131#[allow(dead_code)]
1132pub struct GskTransformNode {
1133 _data: [u8; 0],
1134 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1135}
1136
1137impl ::std::fmt::Debug for GskTransformNode {
1138 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1139 f.debug_struct(&format!("GskTransformNode @ {self:p}"))
1140 .finish()
1141 }
1142}
1143
1144#[cfg(feature = "vulkan")]
1145#[cfg_attr(docsrs, doc(cfg(feature = "vulkan")))]
1146#[repr(C)]
1147#[allow(dead_code)]
1148pub struct GskVulkanRenderer {
1149 _data: [u8; 0],
1150 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1151}
1152
1153#[cfg(feature = "vulkan")]
1154#[cfg_attr(docsrs, doc(cfg(feature = "vulkan")))]
1155impl ::std::fmt::Debug for GskVulkanRenderer {
1156 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1157 f.debug_struct(&format!("GskVulkanRenderer @ {self:p}"))
1158 .finish()
1159 }
1160}
1161
1162extern "C" {
1163
1164 pub fn gsk_blend_mode_get_type() -> GType;
1168
1169 pub fn gsk_corner_get_type() -> GType;
1173
1174 #[cfg(feature = "v4_14")]
1178 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1179 pub fn gsk_fill_rule_get_type() -> GType;
1180
1181 pub fn gsk_gl_uniform_type_get_type() -> GType;
1185
1186 #[cfg(feature = "v4_14")]
1190 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1191 pub fn gsk_line_cap_get_type() -> GType;
1192
1193 #[cfg(feature = "v4_14")]
1197 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1198 pub fn gsk_line_join_get_type() -> GType;
1199
1200 #[cfg(feature = "v4_10")]
1204 #[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
1205 pub fn gsk_mask_mode_get_type() -> GType;
1206
1207 #[cfg(feature = "v4_14")]
1211 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1212 pub fn gsk_path_direction_get_type() -> GType;
1213
1214 #[cfg(feature = "v4_20")]
1218 #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
1219 pub fn gsk_path_intersection_get_type() -> GType;
1220
1221 #[cfg(feature = "v4_14")]
1225 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1226 pub fn gsk_path_operation_get_type() -> GType;
1227
1228 #[cfg(feature = "v4_22")]
1232 #[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
1233 pub fn gsk_porter_duff_get_type() -> GType;
1234
1235 pub fn gsk_render_node_type_get_type() -> GType;
1239
1240 pub fn gsk_scaling_filter_get_type() -> GType;
1244
1245 pub fn gsk_serialization_error_get_type() -> GType;
1249 pub fn gsk_serialization_error_quark() -> glib::GQuark;
1250
1251 pub fn gsk_transform_category_get_type() -> GType;
1255
1256 #[cfg(feature = "v4_22")]
1260 #[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
1261 pub fn gsk_isolation_get_type() -> GType;
1262
1263 #[cfg(feature = "v4_14")]
1267 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1268 pub fn gsk_path_foreach_flags_get_type() -> GType;
1269
1270 #[cfg(feature = "v4_20")]
1274 #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
1275 pub fn gsk_component_transfer_get_type() -> GType;
1276 #[cfg(feature = "v4_20")]
1277 #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
1278 pub fn gsk_component_transfer_new_discrete(
1279 n: c_uint,
1280 values: *mut c_float,
1281 ) -> *mut GskComponentTransfer;
1282 #[cfg(feature = "v4_20")]
1283 #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
1284 pub fn gsk_component_transfer_new_gamma(
1285 amp: c_float,
1286 exp: c_float,
1287 ofs: c_float,
1288 ) -> *mut GskComponentTransfer;
1289 #[cfg(feature = "v4_20")]
1290 #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
1291 pub fn gsk_component_transfer_new_identity() -> *mut GskComponentTransfer;
1292 #[cfg(feature = "v4_20")]
1293 #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
1294 pub fn gsk_component_transfer_new_levels(n: c_float) -> *mut GskComponentTransfer;
1295 #[cfg(feature = "v4_20")]
1296 #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
1297 pub fn gsk_component_transfer_new_linear(m: c_float, b: c_float) -> *mut GskComponentTransfer;
1298 #[cfg(feature = "v4_20")]
1299 #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
1300 pub fn gsk_component_transfer_new_table(
1301 n: c_uint,
1302 values: *mut c_float,
1303 ) -> *mut GskComponentTransfer;
1304 #[cfg(feature = "v4_20")]
1305 #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
1306 pub fn gsk_component_transfer_copy(
1307 other: *const GskComponentTransfer,
1308 ) -> *mut GskComponentTransfer;
1309 #[cfg(feature = "v4_20")]
1310 #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
1311 pub fn gsk_component_transfer_free(self_: *mut GskComponentTransfer);
1312 #[cfg(feature = "v4_20")]
1313 #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
1314 pub fn gsk_component_transfer_equal(self_: gconstpointer, other: gconstpointer) -> gboolean;
1315
1316 #[cfg(feature = "v4_14")]
1320 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1321 pub fn gsk_path_get_type() -> GType;
1322 #[cfg(feature = "v4_22")]
1323 #[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
1324 pub fn gsk_path_equal(path1: *const GskPath, path2: *const GskPath) -> gboolean;
1325 #[cfg(feature = "v4_14")]
1326 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1327 pub fn gsk_path_foreach(
1328 self_: *mut GskPath,
1329 flags: GskPathForeachFlags,
1330 func: GskPathForeachFunc,
1331 user_data: gpointer,
1332 ) -> gboolean;
1333 #[cfg(feature = "v4_20")]
1334 #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
1335 pub fn gsk_path_foreach_intersection(
1336 path1: *mut GskPath,
1337 path2: *mut GskPath,
1338 func: GskPathIntersectionFunc,
1339 user_data: gpointer,
1340 ) -> gboolean;
1341 #[cfg(feature = "v4_14")]
1342 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1343 pub fn gsk_path_get_bounds(
1344 self_: *mut GskPath,
1345 bounds: *mut graphene::graphene_rect_t,
1346 ) -> gboolean;
1347 #[cfg(feature = "v4_14")]
1348 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1349 pub fn gsk_path_get_closest_point(
1350 self_: *mut GskPath,
1351 point: *const graphene::graphene_point_t,
1352 threshold: c_float,
1353 result: *mut GskPathPoint,
1354 distance: *mut c_float,
1355 ) -> gboolean;
1356 #[cfg(feature = "v4_14")]
1357 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1358 pub fn gsk_path_get_end_point(self_: *mut GskPath, result: *mut GskPathPoint) -> gboolean;
1359 #[cfg(feature = "v4_22")]
1360 #[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
1361 pub fn gsk_path_get_next(self_: *mut GskPath, point: *mut GskPathPoint) -> gboolean;
1362 #[cfg(feature = "v4_22")]
1363 #[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
1364 pub fn gsk_path_get_previous(self_: *mut GskPath, point: *mut GskPathPoint) -> gboolean;
1365 #[cfg(feature = "v4_14")]
1366 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1367 pub fn gsk_path_get_start_point(self_: *mut GskPath, result: *mut GskPathPoint) -> gboolean;
1368 #[cfg(feature = "v4_14")]
1369 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1370 pub fn gsk_path_get_stroke_bounds(
1371 self_: *mut GskPath,
1372 stroke: *const GskStroke,
1373 bounds: *mut graphene::graphene_rect_t,
1374 ) -> gboolean;
1375 #[cfg(feature = "v4_22")]
1376 #[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
1377 pub fn gsk_path_get_tight_bounds(
1378 self_: *mut GskPath,
1379 bounds: *mut graphene::graphene_rect_t,
1380 ) -> gboolean;
1381 #[cfg(feature = "v4_14")]
1382 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1383 pub fn gsk_path_in_fill(
1384 self_: *mut GskPath,
1385 point: *const graphene::graphene_point_t,
1386 fill_rule: GskFillRule,
1387 ) -> gboolean;
1388 #[cfg(feature = "v4_14")]
1389 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1390 pub fn gsk_path_is_closed(self_: *mut GskPath) -> gboolean;
1391 #[cfg(feature = "v4_14")]
1392 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1393 pub fn gsk_path_is_empty(self_: *mut GskPath) -> gboolean;
1394 #[cfg(feature = "v4_14")]
1395 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1396 pub fn gsk_path_print(self_: *mut GskPath, string: *mut glib::GString);
1397 #[cfg(feature = "v4_14")]
1398 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1399 pub fn gsk_path_ref(self_: *mut GskPath) -> *mut GskPath;
1400 #[cfg(feature = "v4_14")]
1401 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1402 pub fn gsk_path_to_cairo(self_: *mut GskPath, cr: *mut cairo::cairo_t);
1403 #[cfg(feature = "v4_14")]
1404 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1405 pub fn gsk_path_to_string(self_: *mut GskPath) -> *mut c_char;
1406 #[cfg(feature = "v4_14")]
1407 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1408 pub fn gsk_path_unref(self_: *mut GskPath);
1409 #[cfg(feature = "v4_14")]
1410 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1411 pub fn gsk_path_parse(string: *const c_char) -> *mut GskPath;
1412
1413 #[cfg(feature = "v4_14")]
1417 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1418 pub fn gsk_path_builder_get_type() -> GType;
1419 #[cfg(feature = "v4_14")]
1420 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1421 pub fn gsk_path_builder_new() -> *mut GskPathBuilder;
1422 #[cfg(feature = "v4_14")]
1423 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1424 pub fn gsk_path_builder_add_cairo_path(
1425 self_: *mut GskPathBuilder,
1426 path: *const cairo::cairo_path_t,
1427 );
1428 #[cfg(feature = "v4_14")]
1429 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1430 pub fn gsk_path_builder_add_circle(
1431 self_: *mut GskPathBuilder,
1432 center: *const graphene::graphene_point_t,
1433 radius: c_float,
1434 );
1435 #[cfg(feature = "v4_14")]
1436 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1437 pub fn gsk_path_builder_add_layout(self_: *mut GskPathBuilder, layout: *mut pango::PangoLayout);
1438 #[cfg(feature = "v4_14")]
1439 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1440 pub fn gsk_path_builder_add_path(self_: *mut GskPathBuilder, path: *mut GskPath);
1441 #[cfg(feature = "v4_14")]
1442 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1443 pub fn gsk_path_builder_add_rect(
1444 self_: *mut GskPathBuilder,
1445 rect: *const graphene::graphene_rect_t,
1446 );
1447 #[cfg(feature = "v4_14")]
1448 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1449 pub fn gsk_path_builder_add_reverse_path(self_: *mut GskPathBuilder, path: *mut GskPath);
1450 #[cfg(feature = "v4_14")]
1451 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1452 pub fn gsk_path_builder_add_rounded_rect(
1453 self_: *mut GskPathBuilder,
1454 rect: *const GskRoundedRect,
1455 );
1456 #[cfg(feature = "v4_14")]
1457 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1458 pub fn gsk_path_builder_add_segment(
1459 self_: *mut GskPathBuilder,
1460 path: *mut GskPath,
1461 start: *const GskPathPoint,
1462 end: *const GskPathPoint,
1463 );
1464 #[cfg(feature = "v4_14")]
1465 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1466 pub fn gsk_path_builder_arc_to(
1467 self_: *mut GskPathBuilder,
1468 x1: c_float,
1469 y1: c_float,
1470 x2: c_float,
1471 y2: c_float,
1472 );
1473 #[cfg(feature = "v4_14")]
1474 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1475 pub fn gsk_path_builder_close(self_: *mut GskPathBuilder);
1476 #[cfg(feature = "v4_14")]
1477 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1478 pub fn gsk_path_builder_conic_to(
1479 self_: *mut GskPathBuilder,
1480 x1: c_float,
1481 y1: c_float,
1482 x2: c_float,
1483 y2: c_float,
1484 weight: c_float,
1485 );
1486 #[cfg(feature = "v4_14")]
1487 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1488 pub fn gsk_path_builder_cubic_to(
1489 self_: *mut GskPathBuilder,
1490 x1: c_float,
1491 y1: c_float,
1492 x2: c_float,
1493 y2: c_float,
1494 x3: c_float,
1495 y3: c_float,
1496 );
1497 #[cfg(feature = "v4_14")]
1498 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1499 pub fn gsk_path_builder_free_to_path(self_: *mut GskPathBuilder) -> *mut GskPath;
1500 #[cfg(feature = "v4_14")]
1501 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1502 pub fn gsk_path_builder_get_current_point(
1503 self_: *mut GskPathBuilder,
1504 ) -> *const graphene::graphene_point_t;
1505 #[cfg(feature = "v4_14")]
1506 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1507 pub fn gsk_path_builder_html_arc_to(
1508 self_: *mut GskPathBuilder,
1509 x1: c_float,
1510 y1: c_float,
1511 x2: c_float,
1512 y2: c_float,
1513 radius: c_float,
1514 );
1515 #[cfg(feature = "v4_14")]
1516 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1517 pub fn gsk_path_builder_line_to(self_: *mut GskPathBuilder, x: c_float, y: c_float);
1518 #[cfg(feature = "v4_14")]
1519 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1520 pub fn gsk_path_builder_move_to(self_: *mut GskPathBuilder, x: c_float, y: c_float);
1521 #[cfg(feature = "v4_14")]
1522 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1523 pub fn gsk_path_builder_quad_to(
1524 self_: *mut GskPathBuilder,
1525 x1: c_float,
1526 y1: c_float,
1527 x2: c_float,
1528 y2: c_float,
1529 );
1530 #[cfg(feature = "v4_14")]
1531 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1532 pub fn gsk_path_builder_ref(self_: *mut GskPathBuilder) -> *mut GskPathBuilder;
1533 #[cfg(feature = "v4_14")]
1534 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1535 pub fn gsk_path_builder_rel_arc_to(
1536 self_: *mut GskPathBuilder,
1537 x1: c_float,
1538 y1: c_float,
1539 x2: c_float,
1540 y2: c_float,
1541 );
1542 #[cfg(feature = "v4_14")]
1543 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1544 pub fn gsk_path_builder_rel_conic_to(
1545 self_: *mut GskPathBuilder,
1546 x1: c_float,
1547 y1: c_float,
1548 x2: c_float,
1549 y2: c_float,
1550 weight: c_float,
1551 );
1552 #[cfg(feature = "v4_14")]
1553 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1554 pub fn gsk_path_builder_rel_cubic_to(
1555 self_: *mut GskPathBuilder,
1556 x1: c_float,
1557 y1: c_float,
1558 x2: c_float,
1559 y2: c_float,
1560 x3: c_float,
1561 y3: c_float,
1562 );
1563 #[cfg(feature = "v4_14")]
1564 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1565 pub fn gsk_path_builder_rel_html_arc_to(
1566 self_: *mut GskPathBuilder,
1567 x1: c_float,
1568 y1: c_float,
1569 x2: c_float,
1570 y2: c_float,
1571 radius: c_float,
1572 );
1573 #[cfg(feature = "v4_14")]
1574 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1575 pub fn gsk_path_builder_rel_line_to(self_: *mut GskPathBuilder, x: c_float, y: c_float);
1576 #[cfg(feature = "v4_14")]
1577 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1578 pub fn gsk_path_builder_rel_move_to(self_: *mut GskPathBuilder, x: c_float, y: c_float);
1579 #[cfg(feature = "v4_14")]
1580 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1581 pub fn gsk_path_builder_rel_quad_to(
1582 self_: *mut GskPathBuilder,
1583 x1: c_float,
1584 y1: c_float,
1585 x2: c_float,
1586 y2: c_float,
1587 );
1588 #[cfg(feature = "v4_14")]
1589 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1590 pub fn gsk_path_builder_rel_svg_arc_to(
1591 self_: *mut GskPathBuilder,
1592 rx: c_float,
1593 ry: c_float,
1594 x_axis_rotation: c_float,
1595 large_arc: gboolean,
1596 positive_sweep: gboolean,
1597 x: c_float,
1598 y: c_float,
1599 );
1600 #[cfg(feature = "v4_14")]
1601 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1602 pub fn gsk_path_builder_svg_arc_to(
1603 self_: *mut GskPathBuilder,
1604 rx: c_float,
1605 ry: c_float,
1606 x_axis_rotation: c_float,
1607 large_arc: gboolean,
1608 positive_sweep: gboolean,
1609 x: c_float,
1610 y: c_float,
1611 );
1612 #[cfg(feature = "v4_14")]
1613 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1614 pub fn gsk_path_builder_to_path(self_: *mut GskPathBuilder) -> *mut GskPath;
1615 #[cfg(feature = "v4_14")]
1616 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1617 pub fn gsk_path_builder_unref(self_: *mut GskPathBuilder);
1618
1619 #[cfg(feature = "v4_14")]
1623 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1624 pub fn gsk_path_measure_get_type() -> GType;
1625 #[cfg(feature = "v4_14")]
1626 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1627 pub fn gsk_path_measure_new(path: *mut GskPath) -> *mut GskPathMeasure;
1628 #[cfg(feature = "v4_14")]
1629 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1630 pub fn gsk_path_measure_new_with_tolerance(
1631 path: *mut GskPath,
1632 tolerance: c_float,
1633 ) -> *mut GskPathMeasure;
1634 #[cfg(feature = "v4_14")]
1635 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1636 pub fn gsk_path_measure_get_length(self_: *mut GskPathMeasure) -> c_float;
1637 #[cfg(feature = "v4_14")]
1638 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1639 pub fn gsk_path_measure_get_path(self_: *mut GskPathMeasure) -> *mut GskPath;
1640 #[cfg(feature = "v4_14")]
1641 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1642 pub fn gsk_path_measure_get_point(
1643 self_: *mut GskPathMeasure,
1644 distance: c_float,
1645 result: *mut GskPathPoint,
1646 ) -> gboolean;
1647 #[cfg(feature = "v4_14")]
1648 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1649 pub fn gsk_path_measure_get_tolerance(self_: *mut GskPathMeasure) -> c_float;
1650 #[cfg(feature = "v4_14")]
1651 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1652 pub fn gsk_path_measure_ref(self_: *mut GskPathMeasure) -> *mut GskPathMeasure;
1653 #[cfg(feature = "v4_14")]
1654 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1655 pub fn gsk_path_measure_unref(self_: *mut GskPathMeasure);
1656
1657 #[cfg(feature = "v4_14")]
1661 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1662 pub fn gsk_path_point_get_type() -> GType;
1663 #[cfg(feature = "v4_14")]
1664 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1665 pub fn gsk_path_point_compare(
1666 point1: *const GskPathPoint,
1667 point2: *const GskPathPoint,
1668 ) -> c_int;
1669 #[cfg(feature = "v4_14")]
1670 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1671 pub fn gsk_path_point_copy(point: *mut GskPathPoint) -> *mut GskPathPoint;
1672 #[cfg(feature = "v4_14")]
1673 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1674 pub fn gsk_path_point_equal(
1675 point1: *const GskPathPoint,
1676 point2: *const GskPathPoint,
1677 ) -> gboolean;
1678 #[cfg(feature = "v4_14")]
1679 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1680 pub fn gsk_path_point_free(point: *mut GskPathPoint);
1681 #[cfg(feature = "v4_14")]
1682 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1683 pub fn gsk_path_point_get_curvature(
1684 point: *const GskPathPoint,
1685 path: *mut GskPath,
1686 direction: GskPathDirection,
1687 center: *mut graphene::graphene_point_t,
1688 ) -> c_float;
1689 #[cfg(feature = "v4_14")]
1690 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1691 pub fn gsk_path_point_get_distance(
1692 point: *const GskPathPoint,
1693 measure: *mut GskPathMeasure,
1694 ) -> c_float;
1695 #[cfg(feature = "v4_14")]
1696 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1697 pub fn gsk_path_point_get_position(
1698 point: *const GskPathPoint,
1699 path: *mut GskPath,
1700 position: *mut graphene::graphene_point_t,
1701 );
1702 #[cfg(feature = "v4_14")]
1703 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1704 pub fn gsk_path_point_get_rotation(
1705 point: *const GskPathPoint,
1706 path: *mut GskPath,
1707 direction: GskPathDirection,
1708 ) -> c_float;
1709 #[cfg(feature = "v4_14")]
1710 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1711 pub fn gsk_path_point_get_tangent(
1712 point: *const GskPathPoint,
1713 path: *mut GskPath,
1714 direction: GskPathDirection,
1715 tangent: *mut graphene::graphene_vec2_t,
1716 );
1717
1718 #[cfg(feature = "v4_22")]
1722 #[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
1723 pub fn gsk_render_replay_get_type() -> GType;
1724 #[cfg(feature = "v4_22")]
1725 #[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
1726 pub fn gsk_render_replay_new() -> *mut GskRenderReplay;
1727 #[cfg(feature = "v4_22")]
1728 #[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
1729 pub fn gsk_render_replay_default(
1730 self_: *mut GskRenderReplay,
1731 node: *mut GskRenderNode,
1732 ) -> *mut GskRenderNode;
1733 #[cfg(feature = "v4_22")]
1734 #[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
1735 pub fn gsk_render_replay_filter_font(
1736 self_: *mut GskRenderReplay,
1737 font: *mut pango::PangoFont,
1738 ) -> *mut pango::PangoFont;
1739 #[cfg(feature = "v4_22")]
1740 #[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
1741 pub fn gsk_render_replay_filter_node(
1742 self_: *mut GskRenderReplay,
1743 node: *mut GskRenderNode,
1744 ) -> *mut GskRenderNode;
1745 #[cfg(feature = "v4_22")]
1746 #[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
1747 pub fn gsk_render_replay_filter_texture(
1748 self_: *mut GskRenderReplay,
1749 texture: *mut gdk::GdkTexture,
1750 ) -> *mut gdk::GdkTexture;
1751 #[cfg(feature = "v4_22")]
1752 #[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
1753 pub fn gsk_render_replay_foreach_node(self_: *mut GskRenderReplay, node: *mut GskRenderNode);
1754 #[cfg(feature = "v4_22")]
1755 #[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
1756 pub fn gsk_render_replay_free(self_: *mut GskRenderReplay);
1757 #[cfg(feature = "v4_22")]
1758 #[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
1759 pub fn gsk_render_replay_set_font_filter(
1760 self_: *mut GskRenderReplay,
1761 filter: GskRenderReplayFontFilter,
1762 user_data: gpointer,
1763 user_destroy: glib::GDestroyNotify,
1764 );
1765 #[cfg(feature = "v4_22")]
1766 #[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
1767 pub fn gsk_render_replay_set_node_filter(
1768 self_: *mut GskRenderReplay,
1769 filter: GskRenderReplayNodeFilter,
1770 user_data: gpointer,
1771 user_destroy: glib::GDestroyNotify,
1772 );
1773 #[cfg(feature = "v4_22")]
1774 #[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
1775 pub fn gsk_render_replay_set_node_foreach(
1776 self_: *mut GskRenderReplay,
1777 foreach: GskRenderReplayNodeForeach,
1778 user_data: gpointer,
1779 user_destroy: glib::GDestroyNotify,
1780 );
1781 #[cfg(feature = "v4_22")]
1782 #[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
1783 pub fn gsk_render_replay_set_texture_filter(
1784 self_: *mut GskRenderReplay,
1785 filter: GskRenderReplayTextureFilter,
1786 user_data: gpointer,
1787 user_destroy: glib::GDestroyNotify,
1788 );
1789
1790 pub fn gsk_rounded_rect_contains_point(
1794 self_: *const GskRoundedRect,
1795 point: *const graphene::graphene_point_t,
1796 ) -> gboolean;
1797 pub fn gsk_rounded_rect_contains_rect(
1798 self_: *const GskRoundedRect,
1799 rect: *const graphene::graphene_rect_t,
1800 ) -> gboolean;
1801 pub fn gsk_rounded_rect_init(
1802 self_: *mut GskRoundedRect,
1803 bounds: *const graphene::graphene_rect_t,
1804 top_left: *const graphene::graphene_size_t,
1805 top_right: *const graphene::graphene_size_t,
1806 bottom_right: *const graphene::graphene_size_t,
1807 bottom_left: *const graphene::graphene_size_t,
1808 ) -> *mut GskRoundedRect;
1809 pub fn gsk_rounded_rect_init_copy(
1810 self_: *mut GskRoundedRect,
1811 src: *const GskRoundedRect,
1812 ) -> *mut GskRoundedRect;
1813 pub fn gsk_rounded_rect_init_from_rect(
1814 self_: *mut GskRoundedRect,
1815 bounds: *const graphene::graphene_rect_t,
1816 radius: c_float,
1817 ) -> *mut GskRoundedRect;
1818 pub fn gsk_rounded_rect_intersects_rect(
1819 self_: *const GskRoundedRect,
1820 rect: *const graphene::graphene_rect_t,
1821 ) -> gboolean;
1822 pub fn gsk_rounded_rect_is_rectilinear(self_: *const GskRoundedRect) -> gboolean;
1823 pub fn gsk_rounded_rect_normalize(self_: *mut GskRoundedRect) -> *mut GskRoundedRect;
1824 pub fn gsk_rounded_rect_offset(
1825 self_: *mut GskRoundedRect,
1826 dx: c_float,
1827 dy: c_float,
1828 ) -> *mut GskRoundedRect;
1829 pub fn gsk_rounded_rect_shrink(
1830 self_: *mut GskRoundedRect,
1831 top: c_float,
1832 right: c_float,
1833 bottom: c_float,
1834 left: c_float,
1835 ) -> *mut GskRoundedRect;
1836
1837 pub fn gsk_shader_args_builder_get_type() -> GType;
1841 pub fn gsk_shader_args_builder_new(
1842 shader: *mut GskGLShader,
1843 initial_values: *mut glib::GBytes,
1844 ) -> *mut GskShaderArgsBuilder;
1845 pub fn gsk_shader_args_builder_free_to_args(
1846 builder: *mut GskShaderArgsBuilder,
1847 ) -> *mut glib::GBytes;
1848 pub fn gsk_shader_args_builder_ref(
1849 builder: *mut GskShaderArgsBuilder,
1850 ) -> *mut GskShaderArgsBuilder;
1851 pub fn gsk_shader_args_builder_set_bool(
1852 builder: *mut GskShaderArgsBuilder,
1853 idx: c_int,
1854 value: gboolean,
1855 );
1856 pub fn gsk_shader_args_builder_set_float(
1857 builder: *mut GskShaderArgsBuilder,
1858 idx: c_int,
1859 value: c_float,
1860 );
1861 pub fn gsk_shader_args_builder_set_int(
1862 builder: *mut GskShaderArgsBuilder,
1863 idx: c_int,
1864 value: i32,
1865 );
1866 pub fn gsk_shader_args_builder_set_uint(
1867 builder: *mut GskShaderArgsBuilder,
1868 idx: c_int,
1869 value: u32,
1870 );
1871 pub fn gsk_shader_args_builder_set_vec2(
1872 builder: *mut GskShaderArgsBuilder,
1873 idx: c_int,
1874 value: *const graphene::graphene_vec2_t,
1875 );
1876 pub fn gsk_shader_args_builder_set_vec3(
1877 builder: *mut GskShaderArgsBuilder,
1878 idx: c_int,
1879 value: *const graphene::graphene_vec3_t,
1880 );
1881 pub fn gsk_shader_args_builder_set_vec4(
1882 builder: *mut GskShaderArgsBuilder,
1883 idx: c_int,
1884 value: *const graphene::graphene_vec4_t,
1885 );
1886 pub fn gsk_shader_args_builder_to_args(builder: *mut GskShaderArgsBuilder)
1887 -> *mut glib::GBytes;
1888 pub fn gsk_shader_args_builder_unref(builder: *mut GskShaderArgsBuilder);
1889
1890 #[cfg(feature = "v4_14")]
1894 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1895 pub fn gsk_stroke_get_type() -> GType;
1896 #[cfg(feature = "v4_14")]
1897 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1898 pub fn gsk_stroke_new(line_width: c_float) -> *mut GskStroke;
1899 #[cfg(feature = "v4_14")]
1900 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1901 pub fn gsk_stroke_copy(other: *const GskStroke) -> *mut GskStroke;
1902 #[cfg(feature = "v4_14")]
1903 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1904 pub fn gsk_stroke_free(self_: *mut GskStroke);
1905 #[cfg(feature = "v4_14")]
1906 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1907 pub fn gsk_stroke_get_dash(self_: *const GskStroke, n_dash: *mut size_t) -> *const c_float;
1908 #[cfg(feature = "v4_14")]
1909 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1910 pub fn gsk_stroke_get_dash_offset(self_: *const GskStroke) -> c_float;
1911 #[cfg(feature = "v4_14")]
1912 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1913 pub fn gsk_stroke_get_line_cap(self_: *const GskStroke) -> GskLineCap;
1914 #[cfg(feature = "v4_14")]
1915 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1916 pub fn gsk_stroke_get_line_join(self_: *const GskStroke) -> GskLineJoin;
1917 #[cfg(feature = "v4_14")]
1918 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1919 pub fn gsk_stroke_get_line_width(self_: *const GskStroke) -> c_float;
1920 #[cfg(feature = "v4_14")]
1921 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1922 pub fn gsk_stroke_get_miter_limit(self_: *const GskStroke) -> c_float;
1923 #[cfg(feature = "v4_14")]
1924 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1925 pub fn gsk_stroke_set_dash(self_: *mut GskStroke, dash: *const c_float, n_dash: size_t);
1926 #[cfg(feature = "v4_14")]
1927 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1928 pub fn gsk_stroke_set_dash_offset(self_: *mut GskStroke, offset: c_float);
1929 #[cfg(feature = "v4_14")]
1930 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1931 pub fn gsk_stroke_set_line_cap(self_: *mut GskStroke, line_cap: GskLineCap);
1932 #[cfg(feature = "v4_14")]
1933 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1934 pub fn gsk_stroke_set_line_join(self_: *mut GskStroke, line_join: GskLineJoin);
1935 #[cfg(feature = "v4_14")]
1936 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1937 pub fn gsk_stroke_set_line_width(self_: *mut GskStroke, line_width: c_float);
1938 #[cfg(feature = "v4_14")]
1939 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1940 pub fn gsk_stroke_set_miter_limit(self_: *mut GskStroke, limit: c_float);
1941 #[cfg(feature = "v4_14")]
1942 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1943 pub fn gsk_stroke_to_cairo(self_: *const GskStroke, cr: *mut cairo::cairo_t);
1944 #[cfg(feature = "v4_14")]
1945 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1946 pub fn gsk_stroke_equal(stroke1: gconstpointer, stroke2: gconstpointer) -> gboolean;
1947
1948 pub fn gsk_transform_get_type() -> GType;
1952 pub fn gsk_transform_new() -> *mut GskTransform;
1953 pub fn gsk_transform_equal(first: *mut GskTransform, second: *mut GskTransform) -> gboolean;
1954 pub fn gsk_transform_get_category(self_: *mut GskTransform) -> GskTransformCategory;
1955 pub fn gsk_transform_invert(self_: *mut GskTransform) -> *mut GskTransform;
1956 pub fn gsk_transform_matrix(
1957 next: *mut GskTransform,
1958 matrix: *const graphene::graphene_matrix_t,
1959 ) -> *mut GskTransform;
1960 #[cfg(feature = "v4_20")]
1961 #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
1962 pub fn gsk_transform_matrix_2d(
1963 next: *mut GskTransform,
1964 xx: c_float,
1965 yx: c_float,
1966 xy: c_float,
1967 yy: c_float,
1968 dx: c_float,
1969 dy: c_float,
1970 ) -> *mut GskTransform;
1971 pub fn gsk_transform_perspective(next: *mut GskTransform, depth: c_float) -> *mut GskTransform;
1972 pub fn gsk_transform_print(self_: *mut GskTransform, string: *mut glib::GString);
1973 pub fn gsk_transform_ref(self_: *mut GskTransform) -> *mut GskTransform;
1974 pub fn gsk_transform_rotate(next: *mut GskTransform, angle: c_float) -> *mut GskTransform;
1975 pub fn gsk_transform_rotate_3d(
1976 next: *mut GskTransform,
1977 angle: c_float,
1978 axis: *const graphene::graphene_vec3_t,
1979 ) -> *mut GskTransform;
1980 pub fn gsk_transform_scale(
1981 next: *mut GskTransform,
1982 factor_x: c_float,
1983 factor_y: c_float,
1984 ) -> *mut GskTransform;
1985 pub fn gsk_transform_scale_3d(
1986 next: *mut GskTransform,
1987 factor_x: c_float,
1988 factor_y: c_float,
1989 factor_z: c_float,
1990 ) -> *mut GskTransform;
1991 #[cfg(feature = "v4_6")]
1992 #[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
1993 pub fn gsk_transform_skew(
1994 next: *mut GskTransform,
1995 skew_x: c_float,
1996 skew_y: c_float,
1997 ) -> *mut GskTransform;
1998 pub fn gsk_transform_to_2d(
1999 self_: *mut GskTransform,
2000 out_xx: *mut c_float,
2001 out_yx: *mut c_float,
2002 out_xy: *mut c_float,
2003 out_yy: *mut c_float,
2004 out_dx: *mut c_float,
2005 out_dy: *mut c_float,
2006 );
2007 #[cfg(feature = "v4_6")]
2008 #[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
2009 pub fn gsk_transform_to_2d_components(
2010 self_: *mut GskTransform,
2011 out_skew_x: *mut c_float,
2012 out_skew_y: *mut c_float,
2013 out_scale_x: *mut c_float,
2014 out_scale_y: *mut c_float,
2015 out_angle: *mut c_float,
2016 out_dx: *mut c_float,
2017 out_dy: *mut c_float,
2018 );
2019 pub fn gsk_transform_to_affine(
2020 self_: *mut GskTransform,
2021 out_scale_x: *mut c_float,
2022 out_scale_y: *mut c_float,
2023 out_dx: *mut c_float,
2024 out_dy: *mut c_float,
2025 );
2026 pub fn gsk_transform_to_matrix(
2027 self_: *mut GskTransform,
2028 out_matrix: *mut graphene::graphene_matrix_t,
2029 );
2030 pub fn gsk_transform_to_string(self_: *mut GskTransform) -> *mut c_char;
2031 pub fn gsk_transform_to_translate(
2032 self_: *mut GskTransform,
2033 out_dx: *mut c_float,
2034 out_dy: *mut c_float,
2035 );
2036 pub fn gsk_transform_transform(
2037 next: *mut GskTransform,
2038 other: *mut GskTransform,
2039 ) -> *mut GskTransform;
2040 pub fn gsk_transform_transform_bounds(
2041 self_: *mut GskTransform,
2042 rect: *const graphene::graphene_rect_t,
2043 out_rect: *mut graphene::graphene_rect_t,
2044 );
2045 pub fn gsk_transform_transform_point(
2046 self_: *mut GskTransform,
2047 point: *const graphene::graphene_point_t,
2048 out_point: *mut graphene::graphene_point_t,
2049 );
2050 pub fn gsk_transform_translate(
2051 next: *mut GskTransform,
2052 point: *const graphene::graphene_point_t,
2053 ) -> *mut GskTransform;
2054 pub fn gsk_transform_translate_3d(
2055 next: *mut GskTransform,
2056 point: *const graphene::graphene_point3d_t,
2057 ) -> *mut GskTransform;
2058 pub fn gsk_transform_unref(self_: *mut GskTransform);
2059 pub fn gsk_transform_parse(
2060 string: *const c_char,
2061 out_transform: *mut *mut GskTransform,
2062 ) -> gboolean;
2063
2064 pub fn gsk_blend_node_get_type() -> GType;
2068 pub fn gsk_blend_node_new(
2069 bottom: *mut GskRenderNode,
2070 top: *mut GskRenderNode,
2071 blend_mode: GskBlendMode,
2072 ) -> *mut GskBlendNode;
2073 pub fn gsk_blend_node_get_blend_mode(node: *const GskBlendNode) -> GskBlendMode;
2074 pub fn gsk_blend_node_get_bottom_child(node: *const GskBlendNode) -> *mut GskRenderNode;
2075 pub fn gsk_blend_node_get_top_child(node: *const GskBlendNode) -> *mut GskRenderNode;
2076
2077 pub fn gsk_blur_node_get_type() -> GType;
2081 pub fn gsk_blur_node_new(child: *mut GskRenderNode, radius: c_float) -> *mut GskBlurNode;
2082 pub fn gsk_blur_node_get_child(node: *const GskBlurNode) -> *mut GskRenderNode;
2083 pub fn gsk_blur_node_get_radius(node: *const GskBlurNode) -> c_float;
2084
2085 pub fn gsk_border_node_get_type() -> GType;
2089 pub fn gsk_border_node_new(
2090 outline: *const GskRoundedRect,
2091 border_width: *const [c_float; 4],
2092 border_color: *const [gdk::GdkRGBA; 4],
2093 ) -> *mut GskBorderNode;
2094 pub fn gsk_border_node_get_colors(node: *const GskBorderNode) -> *const [gdk::GdkRGBA; 4];
2095 pub fn gsk_border_node_get_outline(node: *const GskBorderNode) -> *const GskRoundedRect;
2096 pub fn gsk_border_node_get_widths(node: *const GskBorderNode) -> *const [c_float; 4];
2097
2098 #[cfg(feature = "broadway")]
2102 #[cfg_attr(docsrs, doc(cfg(feature = "broadway")))]
2103 pub fn gsk_broadway_renderer_get_type() -> GType;
2104 #[cfg(feature = "broadway")]
2105 #[cfg_attr(docsrs, doc(cfg(feature = "broadway")))]
2106 pub fn gsk_broadway_renderer_new() -> *mut GskRenderer;
2107
2108 pub fn gsk_cairo_node_get_type() -> GType;
2112 pub fn gsk_cairo_node_new(bounds: *const graphene::graphene_rect_t) -> *mut GskCairoNode;
2113 pub fn gsk_cairo_node_get_draw_context(node: *mut GskCairoNode) -> *mut cairo::cairo_t;
2114 pub fn gsk_cairo_node_get_surface(node: *mut GskCairoNode) -> *mut cairo::cairo_surface_t;
2115
2116 pub fn gsk_cairo_renderer_get_type() -> GType;
2120 pub fn gsk_cairo_renderer_new() -> *mut GskRenderer;
2121
2122 pub fn gsk_clip_node_get_type() -> GType;
2126 pub fn gsk_clip_node_new(
2127 child: *mut GskRenderNode,
2128 clip: *const graphene::graphene_rect_t,
2129 ) -> *mut GskClipNode;
2130 pub fn gsk_clip_node_get_child(node: *const GskClipNode) -> *mut GskRenderNode;
2131 pub fn gsk_clip_node_get_clip(node: *const GskClipNode) -> *const graphene::graphene_rect_t;
2132
2133 pub fn gsk_color_matrix_node_get_type() -> GType;
2137 pub fn gsk_color_matrix_node_new(
2138 child: *mut GskRenderNode,
2139 color_matrix: *const graphene::graphene_matrix_t,
2140 color_offset: *const graphene::graphene_vec4_t,
2141 ) -> *mut GskColorMatrixNode;
2142 pub fn gsk_color_matrix_node_get_child(node: *const GskColorMatrixNode) -> *mut GskRenderNode;
2143 pub fn gsk_color_matrix_node_get_color_matrix(
2144 node: *const GskColorMatrixNode,
2145 ) -> *const graphene::graphene_matrix_t;
2146 pub fn gsk_color_matrix_node_get_color_offset(
2147 node: *const GskColorMatrixNode,
2148 ) -> *const graphene::graphene_vec4_t;
2149
2150 pub fn gsk_color_node_get_type() -> GType;
2154 pub fn gsk_color_node_new(
2155 rgba: *const gdk::GdkRGBA,
2156 bounds: *const graphene::graphene_rect_t,
2157 ) -> *mut GskColorNode;
2158 pub fn gsk_color_node_get_color(node: *const GskColorNode) -> *const gdk::GdkRGBA;
2159
2160 #[cfg(feature = "v4_20")]
2164 #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
2165 pub fn gsk_component_transfer_node_get_type() -> GType;
2166 #[cfg(feature = "v4_20")]
2167 #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
2168 pub fn gsk_component_transfer_node_new(
2169 child: *mut GskRenderNode,
2170 r: *const GskComponentTransfer,
2171 g: *const GskComponentTransfer,
2172 b: *const GskComponentTransfer,
2173 a: *const GskComponentTransfer,
2174 ) -> *mut GskComponentTransferNode;
2175 #[cfg(feature = "v4_20")]
2176 #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
2177 pub fn gsk_component_transfer_node_get_child(
2178 node: *const GskComponentTransferNode,
2179 ) -> *mut GskRenderNode;
2180 #[cfg(feature = "v4_20")]
2181 #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
2182 pub fn gsk_component_transfer_node_get_transfer(
2183 node: *const GskComponentTransferNode,
2184 component: c_uint,
2185 ) -> *const GskComponentTransfer;
2186
2187 #[cfg(feature = "v4_22")]
2191 #[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
2192 pub fn gsk_composite_node_get_type() -> GType;
2193 #[cfg(feature = "v4_22")]
2194 #[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
2195 pub fn gsk_composite_node_new(
2196 child: *mut GskRenderNode,
2197 mask: *mut GskRenderNode,
2198 op: GskPorterDuff,
2199 ) -> *mut GskCompositeNode;
2200 #[cfg(feature = "v4_22")]
2201 #[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
2202 pub fn gsk_composite_node_get_child(node: *const GskCompositeNode) -> *mut GskRenderNode;
2203 #[cfg(feature = "v4_22")]
2204 #[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
2205 pub fn gsk_composite_node_get_mask(node: *const GskCompositeNode) -> *mut GskRenderNode;
2206 #[cfg(feature = "v4_22")]
2207 #[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
2208 pub fn gsk_composite_node_get_operator(node: *const GskCompositeNode) -> GskPorterDuff;
2209
2210 pub fn gsk_conic_gradient_node_get_type() -> GType;
2214 pub fn gsk_conic_gradient_node_new(
2215 bounds: *const graphene::graphene_rect_t,
2216 center: *const graphene::graphene_point_t,
2217 rotation: c_float,
2218 color_stops: *const GskColorStop,
2219 n_color_stops: size_t,
2220 ) -> *mut GskConicGradientNode;
2221 #[cfg(feature = "v4_2")]
2222 #[cfg_attr(docsrs, doc(cfg(feature = "v4_2")))]
2223 pub fn gsk_conic_gradient_node_get_angle(node: *const GskConicGradientNode) -> c_float;
2224 pub fn gsk_conic_gradient_node_get_center(
2225 node: *const GskConicGradientNode,
2226 ) -> *const graphene::graphene_point_t;
2227 pub fn gsk_conic_gradient_node_get_color_stops(
2228 node: *const GskConicGradientNode,
2229 n_stops: *mut size_t,
2230 ) -> *const GskColorStop;
2231 pub fn gsk_conic_gradient_node_get_n_color_stops(node: *const GskConicGradientNode) -> size_t;
2232 pub fn gsk_conic_gradient_node_get_rotation(node: *const GskConicGradientNode) -> c_float;
2233
2234 pub fn gsk_container_node_get_type() -> GType;
2238 pub fn gsk_container_node_new(
2239 children: *mut *mut GskRenderNode,
2240 n_children: c_uint,
2241 ) -> *mut GskContainerNode;
2242 pub fn gsk_container_node_get_child(
2243 node: *const GskContainerNode,
2244 idx: c_uint,
2245 ) -> *mut GskRenderNode;
2246 pub fn gsk_container_node_get_n_children(node: *const GskContainerNode) -> c_uint;
2247
2248 #[cfg(feature = "v4_22")]
2252 #[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
2253 pub fn gsk_copy_node_get_type() -> GType;
2254 #[cfg(feature = "v4_22")]
2255 #[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
2256 pub fn gsk_copy_node_new(child: *mut GskRenderNode) -> *mut GskCopyNode;
2257 #[cfg(feature = "v4_22")]
2258 #[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
2259 pub fn gsk_copy_node_get_child(node: *const GskCopyNode) -> *mut GskRenderNode;
2260
2261 pub fn gsk_cross_fade_node_get_type() -> GType;
2265 pub fn gsk_cross_fade_node_new(
2266 start: *mut GskRenderNode,
2267 end: *mut GskRenderNode,
2268 progress: c_float,
2269 ) -> *mut GskCrossFadeNode;
2270 pub fn gsk_cross_fade_node_get_end_child(node: *const GskCrossFadeNode) -> *mut GskRenderNode;
2271 pub fn gsk_cross_fade_node_get_progress(node: *const GskCrossFadeNode) -> c_float;
2272 pub fn gsk_cross_fade_node_get_start_child(node: *const GskCrossFadeNode)
2273 -> *mut GskRenderNode;
2274
2275 pub fn gsk_debug_node_get_type() -> GType;
2279 pub fn gsk_debug_node_new(child: *mut GskRenderNode, message: *mut c_char)
2280 -> *mut GskDebugNode;
2281 pub fn gsk_debug_node_get_child(node: *const GskDebugNode) -> *mut GskRenderNode;
2282 pub fn gsk_debug_node_get_message(node: *const GskDebugNode) -> *const c_char;
2283
2284 #[cfg(feature = "v4_14")]
2288 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
2289 pub fn gsk_fill_node_get_type() -> GType;
2290 #[cfg(feature = "v4_14")]
2291 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
2292 pub fn gsk_fill_node_new(
2293 child: *mut GskRenderNode,
2294 path: *mut GskPath,
2295 fill_rule: GskFillRule,
2296 ) -> *mut GskFillNode;
2297 #[cfg(feature = "v4_14")]
2298 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
2299 pub fn gsk_fill_node_get_child(node: *const GskFillNode) -> *mut GskRenderNode;
2300 #[cfg(feature = "v4_14")]
2301 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
2302 pub fn gsk_fill_node_get_fill_rule(node: *const GskFillNode) -> GskFillRule;
2303 #[cfg(feature = "v4_14")]
2304 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
2305 pub fn gsk_fill_node_get_path(node: *const GskFillNode) -> *mut GskPath;
2306
2307 #[cfg(feature = "v4_2")]
2311 #[cfg_attr(docsrs, doc(cfg(feature = "v4_2")))]
2312 pub fn gsk_gl_renderer_get_type() -> GType;
2313 #[cfg(feature = "v4_2")]
2314 #[cfg_attr(docsrs, doc(cfg(feature = "v4_2")))]
2315 pub fn gsk_gl_renderer_new() -> *mut GskRenderer;
2316
2317 pub fn gsk_gl_shader_get_type() -> GType;
2321 pub fn gsk_gl_shader_new_from_bytes(sourcecode: *mut glib::GBytes) -> *mut GskGLShader;
2322 pub fn gsk_gl_shader_new_from_resource(resource_path: *const c_char) -> *mut GskGLShader;
2323 pub fn gsk_gl_shader_compile(
2324 shader: *mut GskGLShader,
2325 renderer: *mut GskRenderer,
2326 error: *mut *mut glib::GError,
2327 ) -> gboolean;
2328 pub fn gsk_gl_shader_find_uniform_by_name(
2329 shader: *mut GskGLShader,
2330 name: *const c_char,
2331 ) -> c_int;
2332 pub fn gsk_gl_shader_format_args(shader: *mut GskGLShader, ...) -> *mut glib::GBytes;
2333 pub fn gsk_gl_shader_get_arg_bool(
2335 shader: *mut GskGLShader,
2336 args: *mut glib::GBytes,
2337 idx: c_int,
2338 ) -> gboolean;
2339 pub fn gsk_gl_shader_get_arg_float(
2340 shader: *mut GskGLShader,
2341 args: *mut glib::GBytes,
2342 idx: c_int,
2343 ) -> c_float;
2344 pub fn gsk_gl_shader_get_arg_int(
2345 shader: *mut GskGLShader,
2346 args: *mut glib::GBytes,
2347 idx: c_int,
2348 ) -> i32;
2349 pub fn gsk_gl_shader_get_arg_uint(
2350 shader: *mut GskGLShader,
2351 args: *mut glib::GBytes,
2352 idx: c_int,
2353 ) -> u32;
2354 pub fn gsk_gl_shader_get_arg_vec2(
2355 shader: *mut GskGLShader,
2356 args: *mut glib::GBytes,
2357 idx: c_int,
2358 out_value: *mut graphene::graphene_vec2_t,
2359 );
2360 pub fn gsk_gl_shader_get_arg_vec3(
2361 shader: *mut GskGLShader,
2362 args: *mut glib::GBytes,
2363 idx: c_int,
2364 out_value: *mut graphene::graphene_vec3_t,
2365 );
2366 pub fn gsk_gl_shader_get_arg_vec4(
2367 shader: *mut GskGLShader,
2368 args: *mut glib::GBytes,
2369 idx: c_int,
2370 out_value: *mut graphene::graphene_vec4_t,
2371 );
2372 pub fn gsk_gl_shader_get_args_size(shader: *mut GskGLShader) -> size_t;
2373 pub fn gsk_gl_shader_get_n_textures(shader: *mut GskGLShader) -> c_int;
2374 pub fn gsk_gl_shader_get_n_uniforms(shader: *mut GskGLShader) -> c_int;
2375 pub fn gsk_gl_shader_get_resource(shader: *mut GskGLShader) -> *const c_char;
2376 pub fn gsk_gl_shader_get_source(shader: *mut GskGLShader) -> *mut glib::GBytes;
2377 pub fn gsk_gl_shader_get_uniform_name(shader: *mut GskGLShader, idx: c_int) -> *const c_char;
2378 pub fn gsk_gl_shader_get_uniform_offset(shader: *mut GskGLShader, idx: c_int) -> c_int;
2379 pub fn gsk_gl_shader_get_uniform_type(shader: *mut GskGLShader, idx: c_int)
2380 -> GskGLUniformType;
2381
2382 pub fn gsk_gl_shader_node_get_type() -> GType;
2386 pub fn gsk_gl_shader_node_new(
2387 shader: *mut GskGLShader,
2388 bounds: *const graphene::graphene_rect_t,
2389 args: *mut glib::GBytes,
2390 children: *mut *mut GskRenderNode,
2391 n_children: c_uint,
2392 ) -> *mut GskGLShaderNode;
2393 pub fn gsk_gl_shader_node_get_args(node: *const GskGLShaderNode) -> *mut glib::GBytes;
2394 pub fn gsk_gl_shader_node_get_child(
2395 node: *const GskGLShaderNode,
2396 idx: c_uint,
2397 ) -> *mut GskRenderNode;
2398 pub fn gsk_gl_shader_node_get_n_children(node: *const GskGLShaderNode) -> c_uint;
2399 pub fn gsk_gl_shader_node_get_shader(node: *const GskGLShaderNode) -> *mut GskGLShader;
2400
2401 pub fn gsk_inset_shadow_node_get_type() -> GType;
2405 pub fn gsk_inset_shadow_node_new(
2406 outline: *const GskRoundedRect,
2407 color: *const gdk::GdkRGBA,
2408 dx: c_float,
2409 dy: c_float,
2410 spread: c_float,
2411 blur_radius: c_float,
2412 ) -> *mut GskInsetShadowNode;
2413 pub fn gsk_inset_shadow_node_get_blur_radius(node: *const GskInsetShadowNode) -> c_float;
2414 pub fn gsk_inset_shadow_node_get_color(node: *const GskInsetShadowNode) -> *const gdk::GdkRGBA;
2415 pub fn gsk_inset_shadow_node_get_dx(node: *const GskInsetShadowNode) -> c_float;
2416 pub fn gsk_inset_shadow_node_get_dy(node: *const GskInsetShadowNode) -> c_float;
2417 pub fn gsk_inset_shadow_node_get_outline(
2418 node: *const GskInsetShadowNode,
2419 ) -> *const GskRoundedRect;
2420 pub fn gsk_inset_shadow_node_get_spread(node: *const GskInsetShadowNode) -> c_float;
2421
2422 #[cfg(feature = "v4_22")]
2426 #[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
2427 pub fn gsk_isolation_node_get_type() -> GType;
2428 #[cfg(feature = "v4_22")]
2429 #[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
2430 pub fn gsk_isolation_node_new(
2431 child: *mut GskRenderNode,
2432 isolations: GskIsolation,
2433 ) -> *mut GskIsolationNode;
2434 #[cfg(feature = "v4_22")]
2435 #[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
2436 pub fn gsk_isolation_node_get_child(node: *const GskIsolationNode) -> *mut GskRenderNode;
2437 #[cfg(feature = "v4_22")]
2438 #[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
2439 pub fn gsk_isolation_node_get_isolations(node: *const GskIsolationNode) -> GskIsolation;
2440
2441 pub fn gsk_linear_gradient_node_get_type() -> GType;
2445 pub fn gsk_linear_gradient_node_new(
2446 bounds: *const graphene::graphene_rect_t,
2447 start: *const graphene::graphene_point_t,
2448 end: *const graphene::graphene_point_t,
2449 color_stops: *const GskColorStop,
2450 n_color_stops: size_t,
2451 ) -> *mut GskLinearGradientNode;
2452 pub fn gsk_linear_gradient_node_get_color_stops(
2453 node: *const GskLinearGradientNode,
2454 n_stops: *mut size_t,
2455 ) -> *const GskColorStop;
2456 pub fn gsk_linear_gradient_node_get_end(
2457 node: *const GskLinearGradientNode,
2458 ) -> *const graphene::graphene_point_t;
2459 pub fn gsk_linear_gradient_node_get_n_color_stops(node: *const GskLinearGradientNode)
2460 -> size_t;
2461 pub fn gsk_linear_gradient_node_get_start(
2462 node: *const GskLinearGradientNode,
2463 ) -> *const graphene::graphene_point_t;
2464
2465 #[cfg(feature = "v4_10")]
2469 #[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
2470 pub fn gsk_mask_node_get_type() -> GType;
2471 #[cfg(feature = "v4_10")]
2472 #[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
2473 pub fn gsk_mask_node_new(
2474 source: *mut GskRenderNode,
2475 mask: *mut GskRenderNode,
2476 mask_mode: GskMaskMode,
2477 ) -> *mut GskMaskNode;
2478 #[cfg(feature = "v4_10")]
2479 #[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
2480 pub fn gsk_mask_node_get_mask(node: *const GskMaskNode) -> *mut GskRenderNode;
2481 #[cfg(feature = "v4_10")]
2482 #[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
2483 pub fn gsk_mask_node_get_mask_mode(node: *const GskMaskNode) -> GskMaskMode;
2484 #[cfg(feature = "v4_10")]
2485 #[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
2486 pub fn gsk_mask_node_get_source(node: *const GskMaskNode) -> *mut GskRenderNode;
2487
2488 pub fn gsk_ngl_renderer_get_type() -> GType;
2492 pub fn gsk_ngl_renderer_new() -> *mut GskRenderer;
2493
2494 pub fn gsk_opacity_node_get_type() -> GType;
2498 pub fn gsk_opacity_node_new(child: *mut GskRenderNode, opacity: c_float)
2499 -> *mut GskOpacityNode;
2500 pub fn gsk_opacity_node_get_child(node: *const GskOpacityNode) -> *mut GskRenderNode;
2501 pub fn gsk_opacity_node_get_opacity(node: *const GskOpacityNode) -> c_float;
2502
2503 pub fn gsk_outset_shadow_node_get_type() -> GType;
2507 pub fn gsk_outset_shadow_node_new(
2508 outline: *const GskRoundedRect,
2509 color: *const gdk::GdkRGBA,
2510 dx: c_float,
2511 dy: c_float,
2512 spread: c_float,
2513 blur_radius: c_float,
2514 ) -> *mut GskOutsetShadowNode;
2515 pub fn gsk_outset_shadow_node_get_blur_radius(node: *const GskOutsetShadowNode) -> c_float;
2516 pub fn gsk_outset_shadow_node_get_color(
2517 node: *const GskOutsetShadowNode,
2518 ) -> *const gdk::GdkRGBA;
2519 pub fn gsk_outset_shadow_node_get_dx(node: *const GskOutsetShadowNode) -> c_float;
2520 pub fn gsk_outset_shadow_node_get_dy(node: *const GskOutsetShadowNode) -> c_float;
2521 pub fn gsk_outset_shadow_node_get_outline(
2522 node: *const GskOutsetShadowNode,
2523 ) -> *const GskRoundedRect;
2524 pub fn gsk_outset_shadow_node_get_spread(node: *const GskOutsetShadowNode) -> c_float;
2525
2526 #[cfg(feature = "v4_22")]
2530 #[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
2531 pub fn gsk_paste_node_get_type() -> GType;
2532 #[cfg(feature = "v4_22")]
2533 #[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
2534 pub fn gsk_paste_node_new(
2535 bounds: *const graphene::graphene_rect_t,
2536 depth: size_t,
2537 ) -> *mut GskPasteNode;
2538 #[cfg(feature = "v4_22")]
2539 #[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
2540 pub fn gsk_paste_node_get_depth(node: *const GskPasteNode) -> size_t;
2541
2542 pub fn gsk_radial_gradient_node_get_type() -> GType;
2546 pub fn gsk_radial_gradient_node_new(
2547 bounds: *const graphene::graphene_rect_t,
2548 center: *const graphene::graphene_point_t,
2549 hradius: c_float,
2550 vradius: c_float,
2551 start: c_float,
2552 end: c_float,
2553 color_stops: *const GskColorStop,
2554 n_color_stops: size_t,
2555 ) -> *mut GskRadialGradientNode;
2556 pub fn gsk_radial_gradient_node_get_center(
2557 node: *const GskRadialGradientNode,
2558 ) -> *const graphene::graphene_point_t;
2559 pub fn gsk_radial_gradient_node_get_color_stops(
2560 node: *const GskRadialGradientNode,
2561 n_stops: *mut size_t,
2562 ) -> *const GskColorStop;
2563 pub fn gsk_radial_gradient_node_get_end(node: *const GskRadialGradientNode) -> c_float;
2564 pub fn gsk_radial_gradient_node_get_hradius(node: *const GskRadialGradientNode) -> c_float;
2565 pub fn gsk_radial_gradient_node_get_n_color_stops(node: *const GskRadialGradientNode)
2566 -> size_t;
2567 pub fn gsk_radial_gradient_node_get_start(node: *const GskRadialGradientNode) -> c_float;
2568 pub fn gsk_radial_gradient_node_get_vradius(node: *const GskRadialGradientNode) -> c_float;
2569
2570 pub fn gsk_render_node_get_type() -> GType;
2574 pub fn gsk_render_node_deserialize(
2575 bytes: *mut glib::GBytes,
2576 error_func: GskParseErrorFunc,
2577 user_data: gpointer,
2578 ) -> *mut GskRenderNode;
2579 pub fn gsk_render_node_draw(node: *mut GskRenderNode, cr: *mut cairo::cairo_t);
2580 pub fn gsk_render_node_get_bounds(
2581 node: *mut GskRenderNode,
2582 bounds: *mut graphene::graphene_rect_t,
2583 );
2584 pub fn gsk_render_node_get_node_type(node: *const GskRenderNode) -> GskRenderNodeType;
2585 #[cfg(feature = "v4_16")]
2586 #[cfg_attr(docsrs, doc(cfg(feature = "v4_16")))]
2587 pub fn gsk_render_node_get_opaque_rect(
2588 self_: *mut GskRenderNode,
2589 out_opaque: *mut graphene::graphene_rect_t,
2590 ) -> gboolean;
2591 pub fn gsk_render_node_ref(node: *mut GskRenderNode) -> *mut GskRenderNode;
2592 pub fn gsk_render_node_serialize(node: *mut GskRenderNode) -> *mut glib::GBytes;
2593 pub fn gsk_render_node_unref(node: *mut GskRenderNode);
2594 pub fn gsk_render_node_write_to_file(
2595 node: *mut GskRenderNode,
2596 filename: *const c_char,
2597 error: *mut *mut glib::GError,
2598 ) -> gboolean;
2599
2600 pub fn gsk_renderer_get_type() -> GType;
2604 pub fn gsk_renderer_new_for_surface(surface: *mut gdk::GdkSurface) -> *mut GskRenderer;
2605 pub fn gsk_renderer_get_surface(renderer: *mut GskRenderer) -> *mut gdk::GdkSurface;
2606 pub fn gsk_renderer_is_realized(renderer: *mut GskRenderer) -> gboolean;
2607 pub fn gsk_renderer_realize(
2608 renderer: *mut GskRenderer,
2609 surface: *mut gdk::GdkSurface,
2610 error: *mut *mut glib::GError,
2611 ) -> gboolean;
2612 #[cfg(feature = "v4_14")]
2613 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
2614 pub fn gsk_renderer_realize_for_display(
2615 renderer: *mut GskRenderer,
2616 display: *mut gdk::GdkDisplay,
2617 error: *mut *mut glib::GError,
2618 ) -> gboolean;
2619 pub fn gsk_renderer_render(
2620 renderer: *mut GskRenderer,
2621 root: *mut GskRenderNode,
2622 region: *const cairo::cairo_region_t,
2623 );
2624 pub fn gsk_renderer_render_texture(
2625 renderer: *mut GskRenderer,
2626 root: *mut GskRenderNode,
2627 viewport: *const graphene::graphene_rect_t,
2628 ) -> *mut gdk::GdkTexture;
2629 pub fn gsk_renderer_unrealize(renderer: *mut GskRenderer);
2630
2631 pub fn gsk_repeat_node_get_type() -> GType;
2635 pub fn gsk_repeat_node_new(
2636 bounds: *const graphene::graphene_rect_t,
2637 child: *mut GskRenderNode,
2638 child_bounds: *const graphene::graphene_rect_t,
2639 ) -> *mut GskRepeatNode;
2640 pub fn gsk_repeat_node_get_child(node: *const GskRepeatNode) -> *mut GskRenderNode;
2641 pub fn gsk_repeat_node_get_child_bounds(
2642 node: *const GskRepeatNode,
2643 ) -> *const graphene::graphene_rect_t;
2644
2645 pub fn gsk_repeating_linear_gradient_node_get_type() -> GType;
2649 pub fn gsk_repeating_linear_gradient_node_new(
2650 bounds: *const graphene::graphene_rect_t,
2651 start: *const graphene::graphene_point_t,
2652 end: *const graphene::graphene_point_t,
2653 color_stops: *const GskColorStop,
2654 n_color_stops: size_t,
2655 ) -> *mut GskRepeatingLinearGradientNode;
2656
2657 pub fn gsk_repeating_radial_gradient_node_get_type() -> GType;
2661 pub fn gsk_repeating_radial_gradient_node_new(
2662 bounds: *const graphene::graphene_rect_t,
2663 center: *const graphene::graphene_point_t,
2664 hradius: c_float,
2665 vradius: c_float,
2666 start: c_float,
2667 end: c_float,
2668 color_stops: *const GskColorStop,
2669 n_color_stops: size_t,
2670 ) -> *mut GskRepeatingRadialGradientNode;
2671
2672 pub fn gsk_rounded_clip_node_get_type() -> GType;
2676 pub fn gsk_rounded_clip_node_new(
2677 child: *mut GskRenderNode,
2678 clip: *const GskRoundedRect,
2679 ) -> *mut GskRoundedClipNode;
2680 pub fn gsk_rounded_clip_node_get_child(node: *const GskRoundedClipNode) -> *mut GskRenderNode;
2681 pub fn gsk_rounded_clip_node_get_clip(node: *const GskRoundedClipNode)
2682 -> *const GskRoundedRect;
2683
2684 pub fn gsk_shadow_node_get_type() -> GType;
2688 pub fn gsk_shadow_node_new(
2689 child: *mut GskRenderNode,
2690 shadows: *const GskShadow,
2691 n_shadows: size_t,
2692 ) -> *mut GskShadowNode;
2693 pub fn gsk_shadow_node_get_child(node: *const GskShadowNode) -> *mut GskRenderNode;
2694 pub fn gsk_shadow_node_get_n_shadows(node: *const GskShadowNode) -> size_t;
2695 pub fn gsk_shadow_node_get_shadow(node: *const GskShadowNode, i: size_t) -> *const GskShadow;
2696
2697 #[cfg(feature = "v4_14")]
2701 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
2702 pub fn gsk_stroke_node_get_type() -> GType;
2703 #[cfg(feature = "v4_14")]
2704 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
2705 pub fn gsk_stroke_node_new(
2706 child: *mut GskRenderNode,
2707 path: *mut GskPath,
2708 stroke: *const GskStroke,
2709 ) -> *mut GskStrokeNode;
2710 #[cfg(feature = "v4_14")]
2711 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
2712 pub fn gsk_stroke_node_get_child(node: *const GskStrokeNode) -> *mut GskRenderNode;
2713 #[cfg(feature = "v4_14")]
2714 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
2715 pub fn gsk_stroke_node_get_path(node: *const GskStrokeNode) -> *mut GskPath;
2716 #[cfg(feature = "v4_14")]
2717 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
2718 pub fn gsk_stroke_node_get_stroke(node: *const GskStrokeNode) -> *const GskStroke;
2719
2720 #[cfg(feature = "v4_14")]
2724 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
2725 pub fn gsk_subsurface_node_get_type() -> GType;
2726 #[cfg(feature = "v4_14")]
2727 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
2728 pub fn gsk_subsurface_node_new(
2729 child: *mut GskRenderNode,
2730 subsurface: gpointer,
2731 ) -> *mut GskSubsurfaceNode;
2732 #[cfg(feature = "v4_14")]
2733 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
2734 pub fn gsk_subsurface_node_get_subsurface(node: *const GskDebugNode) -> gpointer;
2735 #[cfg(feature = "v4_14")]
2736 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
2737 pub fn gsk_subsurface_node_get_child(node: *const GskSubsurfaceNode) -> *mut GskRenderNode;
2738
2739 pub fn gsk_text_node_get_type() -> GType;
2743 pub fn gsk_text_node_new(
2744 font: *mut pango::PangoFont,
2745 glyphs: *mut pango::PangoGlyphString,
2746 color: *const gdk::GdkRGBA,
2747 offset: *const graphene::graphene_point_t,
2748 ) -> *mut GskTextNode;
2749 pub fn gsk_text_node_get_color(node: *const GskTextNode) -> *const gdk::GdkRGBA;
2750 pub fn gsk_text_node_get_font(node: *const GskTextNode) -> *mut pango::PangoFont;
2751 pub fn gsk_text_node_get_glyphs(
2752 node: *const GskTextNode,
2753 n_glyphs: *mut c_uint,
2754 ) -> *const pango::PangoGlyphInfo;
2755 pub fn gsk_text_node_get_num_glyphs(node: *const GskTextNode) -> c_uint;
2756 pub fn gsk_text_node_get_offset(node: *const GskTextNode) -> *const graphene::graphene_point_t;
2757 #[cfg(feature = "v4_2")]
2758 #[cfg_attr(docsrs, doc(cfg(feature = "v4_2")))]
2759 pub fn gsk_text_node_has_color_glyphs(node: *const GskTextNode) -> gboolean;
2760
2761 pub fn gsk_texture_node_get_type() -> GType;
2765 pub fn gsk_texture_node_new(
2766 texture: *mut gdk::GdkTexture,
2767 bounds: *const graphene::graphene_rect_t,
2768 ) -> *mut GskTextureNode;
2769 pub fn gsk_texture_node_get_texture(node: *const GskTextureNode) -> *mut gdk::GdkTexture;
2770
2771 #[cfg(feature = "v4_10")]
2775 #[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
2776 pub fn gsk_texture_scale_node_get_type() -> GType;
2777 #[cfg(feature = "v4_10")]
2778 #[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
2779 pub fn gsk_texture_scale_node_new(
2780 texture: *mut gdk::GdkTexture,
2781 bounds: *const graphene::graphene_rect_t,
2782 filter: GskScalingFilter,
2783 ) -> *mut GskTextureScaleNode;
2784 #[cfg(feature = "v4_10")]
2785 #[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
2786 pub fn gsk_texture_scale_node_get_filter(node: *const GskTextureScaleNode) -> GskScalingFilter;
2787 #[cfg(feature = "v4_10")]
2788 #[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
2789 pub fn gsk_texture_scale_node_get_texture(
2790 node: *const GskTextureScaleNode,
2791 ) -> *mut gdk::GdkTexture;
2792
2793 pub fn gsk_transform_node_get_type() -> GType;
2797 pub fn gsk_transform_node_new(
2798 child: *mut GskRenderNode,
2799 transform: *mut GskTransform,
2800 ) -> *mut GskTransformNode;
2801 pub fn gsk_transform_node_get_child(node: *const GskTransformNode) -> *mut GskRenderNode;
2802 pub fn gsk_transform_node_get_transform(node: *const GskTransformNode) -> *mut GskTransform;
2803
2804 #[cfg(feature = "vulkan")]
2808 #[cfg_attr(docsrs, doc(cfg(feature = "vulkan")))]
2809 pub fn gsk_vulkan_renderer_get_type() -> GType;
2810 #[cfg(feature = "vulkan")]
2811 #[cfg_attr(docsrs, doc(cfg(feature = "vulkan")))]
2812 pub fn gsk_vulkan_renderer_new() -> *mut GskRenderer;
2813
2814 #[cfg(feature = "v4_6")]
2818 #[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
2819 pub fn gsk_value_dup_render_node(value: *const gobject::GValue) -> *mut GskRenderNode;
2820 #[cfg(feature = "v4_6")]
2821 #[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
2822 pub fn gsk_value_get_render_node(value: *const gobject::GValue) -> *mut GskRenderNode;
2823 #[cfg(feature = "v4_6")]
2824 #[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
2825 pub fn gsk_value_set_render_node(value: *mut gobject::GValue, node: *mut GskRenderNode);
2826 #[cfg(feature = "v4_6")]
2827 #[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
2828 pub fn gsk_value_take_render_node(value: *mut gobject::GValue, node: *mut GskRenderNode);
2829
2830}