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