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_14")]
1418 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1419 pub fn gsk_path_in_fill(
1420 self_: *mut GskPath,
1421 point: *const graphene::graphene_point_t,
1422 fill_rule: GskFillRule,
1423 ) -> gboolean;
1424 #[cfg(feature = "v4_14")]
1425 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1426 pub fn gsk_path_is_closed(self_: *mut GskPath) -> gboolean;
1427 #[cfg(feature = "v4_14")]
1428 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1429 pub fn gsk_path_is_empty(self_: *mut GskPath) -> gboolean;
1430 #[cfg(feature = "v4_14")]
1431 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1432 pub fn gsk_path_print(self_: *mut GskPath, string: *mut glib::GString);
1433 #[cfg(feature = "v4_14")]
1434 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1435 pub fn gsk_path_ref(self_: *mut GskPath) -> *mut GskPath;
1436 #[cfg(feature = "v4_14")]
1437 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1438 pub fn gsk_path_to_cairo(self_: *mut GskPath, cr: *mut cairo::cairo_t);
1439 #[cfg(feature = "v4_14")]
1440 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1441 pub fn gsk_path_to_string(self_: *mut GskPath) -> *mut c_char;
1442 #[cfg(feature = "v4_14")]
1443 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1444 pub fn gsk_path_unref(self_: *mut GskPath);
1445 #[cfg(feature = "v4_14")]
1446 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1447 pub fn gsk_path_parse(string: *const c_char) -> *mut GskPath;
1448
1449 #[cfg(feature = "v4_14")]
1453 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1454 pub fn gsk_path_builder_get_type() -> GType;
1455 #[cfg(feature = "v4_14")]
1456 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1457 pub fn gsk_path_builder_new() -> *mut GskPathBuilder;
1458 #[cfg(feature = "v4_14")]
1459 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1460 pub fn gsk_path_builder_add_cairo_path(
1461 self_: *mut GskPathBuilder,
1462 path: *const cairo::cairo_path_t,
1463 );
1464 #[cfg(feature = "v4_14")]
1465 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1466 pub fn gsk_path_builder_add_circle(
1467 self_: *mut GskPathBuilder,
1468 center: *const graphene::graphene_point_t,
1469 radius: c_float,
1470 );
1471 #[cfg(feature = "v4_14")]
1472 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1473 pub fn gsk_path_builder_add_layout(self_: *mut GskPathBuilder, layout: *mut pango::PangoLayout);
1474 #[cfg(feature = "v4_14")]
1475 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1476 pub fn gsk_path_builder_add_path(self_: *mut GskPathBuilder, path: *mut GskPath);
1477 #[cfg(feature = "v4_14")]
1478 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1479 pub fn gsk_path_builder_add_rect(
1480 self_: *mut GskPathBuilder,
1481 rect: *const graphene::graphene_rect_t,
1482 );
1483 #[cfg(feature = "v4_14")]
1484 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1485 pub fn gsk_path_builder_add_reverse_path(self_: *mut GskPathBuilder, path: *mut GskPath);
1486 #[cfg(feature = "v4_14")]
1487 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1488 pub fn gsk_path_builder_add_rounded_rect(
1489 self_: *mut GskPathBuilder,
1490 rect: *const GskRoundedRect,
1491 );
1492 #[cfg(feature = "v4_14")]
1493 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1494 pub fn gsk_path_builder_add_segment(
1495 self_: *mut GskPathBuilder,
1496 path: *mut GskPath,
1497 start: *const GskPathPoint,
1498 end: *const GskPathPoint,
1499 );
1500 #[cfg(feature = "v4_14")]
1501 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1502 pub fn gsk_path_builder_arc_to(
1503 self_: *mut GskPathBuilder,
1504 x1: c_float,
1505 y1: c_float,
1506 x2: c_float,
1507 y2: c_float,
1508 );
1509 #[cfg(feature = "v4_14")]
1510 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1511 pub fn gsk_path_builder_close(self_: *mut GskPathBuilder);
1512 #[cfg(feature = "v4_14")]
1513 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1514 pub fn gsk_path_builder_conic_to(
1515 self_: *mut GskPathBuilder,
1516 x1: c_float,
1517 y1: c_float,
1518 x2: c_float,
1519 y2: c_float,
1520 weight: c_float,
1521 );
1522 #[cfg(feature = "v4_14")]
1523 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1524 pub fn gsk_path_builder_cubic_to(
1525 self_: *mut GskPathBuilder,
1526 x1: c_float,
1527 y1: c_float,
1528 x2: c_float,
1529 y2: c_float,
1530 x3: c_float,
1531 y3: c_float,
1532 );
1533 #[cfg(feature = "v4_14")]
1534 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1535 pub fn gsk_path_builder_free_to_path(self_: *mut GskPathBuilder) -> *mut GskPath;
1536 #[cfg(feature = "v4_14")]
1537 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1538 pub fn gsk_path_builder_get_current_point(
1539 self_: *mut GskPathBuilder,
1540 ) -> *const graphene::graphene_point_t;
1541 #[cfg(feature = "v4_14")]
1542 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1543 pub fn gsk_path_builder_html_arc_to(
1544 self_: *mut GskPathBuilder,
1545 x1: c_float,
1546 y1: c_float,
1547 x2: c_float,
1548 y2: c_float,
1549 radius: c_float,
1550 );
1551 #[cfg(feature = "v4_14")]
1552 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1553 pub fn gsk_path_builder_line_to(self_: *mut GskPathBuilder, x: c_float, y: c_float);
1554 #[cfg(feature = "v4_14")]
1555 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1556 pub fn gsk_path_builder_move_to(self_: *mut GskPathBuilder, x: c_float, y: c_float);
1557 #[cfg(feature = "v4_14")]
1558 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1559 pub fn gsk_path_builder_quad_to(
1560 self_: *mut GskPathBuilder,
1561 x1: c_float,
1562 y1: c_float,
1563 x2: c_float,
1564 y2: c_float,
1565 );
1566 #[cfg(feature = "v4_14")]
1567 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1568 pub fn gsk_path_builder_ref(self_: *mut GskPathBuilder) -> *mut GskPathBuilder;
1569 #[cfg(feature = "v4_14")]
1570 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1571 pub fn gsk_path_builder_rel_arc_to(
1572 self_: *mut GskPathBuilder,
1573 x1: c_float,
1574 y1: c_float,
1575 x2: c_float,
1576 y2: c_float,
1577 );
1578 #[cfg(feature = "v4_14")]
1579 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1580 pub fn gsk_path_builder_rel_conic_to(
1581 self_: *mut GskPathBuilder,
1582 x1: c_float,
1583 y1: c_float,
1584 x2: c_float,
1585 y2: c_float,
1586 weight: c_float,
1587 );
1588 #[cfg(feature = "v4_14")]
1589 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1590 pub fn gsk_path_builder_rel_cubic_to(
1591 self_: *mut GskPathBuilder,
1592 x1: c_float,
1593 y1: c_float,
1594 x2: c_float,
1595 y2: c_float,
1596 x3: c_float,
1597 y3: c_float,
1598 );
1599 #[cfg(feature = "v4_14")]
1600 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1601 pub fn gsk_path_builder_rel_html_arc_to(
1602 self_: *mut GskPathBuilder,
1603 x1: c_float,
1604 y1: c_float,
1605 x2: c_float,
1606 y2: c_float,
1607 radius: c_float,
1608 );
1609 #[cfg(feature = "v4_14")]
1610 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1611 pub fn gsk_path_builder_rel_line_to(self_: *mut GskPathBuilder, x: c_float, y: c_float);
1612 #[cfg(feature = "v4_14")]
1613 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1614 pub fn gsk_path_builder_rel_move_to(self_: *mut GskPathBuilder, x: c_float, y: c_float);
1615 #[cfg(feature = "v4_14")]
1616 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1617 pub fn gsk_path_builder_rel_quad_to(
1618 self_: *mut GskPathBuilder,
1619 x1: c_float,
1620 y1: c_float,
1621 x2: c_float,
1622 y2: c_float,
1623 );
1624 #[cfg(feature = "v4_14")]
1625 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1626 pub fn gsk_path_builder_rel_svg_arc_to(
1627 self_: *mut GskPathBuilder,
1628 rx: c_float,
1629 ry: c_float,
1630 x_axis_rotation: c_float,
1631 large_arc: gboolean,
1632 positive_sweep: gboolean,
1633 x: c_float,
1634 y: c_float,
1635 );
1636 #[cfg(feature = "v4_14")]
1637 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1638 pub fn gsk_path_builder_svg_arc_to(
1639 self_: *mut GskPathBuilder,
1640 rx: c_float,
1641 ry: c_float,
1642 x_axis_rotation: c_float,
1643 large_arc: gboolean,
1644 positive_sweep: gboolean,
1645 x: c_float,
1646 y: c_float,
1647 );
1648 #[cfg(feature = "v4_14")]
1649 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1650 pub fn gsk_path_builder_to_path(self_: *mut GskPathBuilder) -> *mut GskPath;
1651 #[cfg(feature = "v4_14")]
1652 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1653 pub fn gsk_path_builder_unref(self_: *mut GskPathBuilder);
1654
1655 #[cfg(feature = "v4_14")]
1659 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1660 pub fn gsk_path_measure_get_type() -> GType;
1661 #[cfg(feature = "v4_14")]
1662 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1663 pub fn gsk_path_measure_new(path: *mut GskPath) -> *mut GskPathMeasure;
1664 #[cfg(feature = "v4_14")]
1665 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1666 pub fn gsk_path_measure_new_with_tolerance(
1667 path: *mut GskPath,
1668 tolerance: c_float,
1669 ) -> *mut GskPathMeasure;
1670 #[cfg(feature = "v4_14")]
1671 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1672 pub fn gsk_path_measure_get_length(self_: *mut GskPathMeasure) -> c_float;
1673 #[cfg(feature = "v4_14")]
1674 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1675 pub fn gsk_path_measure_get_path(self_: *mut GskPathMeasure) -> *mut GskPath;
1676 #[cfg(feature = "v4_14")]
1677 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1678 pub fn gsk_path_measure_get_point(
1679 self_: *mut GskPathMeasure,
1680 distance: c_float,
1681 result: *mut GskPathPoint,
1682 ) -> gboolean;
1683 #[cfg(feature = "v4_14")]
1684 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1685 pub fn gsk_path_measure_get_tolerance(self_: *mut GskPathMeasure) -> c_float;
1686 #[cfg(feature = "v4_14")]
1687 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1688 pub fn gsk_path_measure_ref(self_: *mut GskPathMeasure) -> *mut GskPathMeasure;
1689 #[cfg(feature = "v4_14")]
1690 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1691 pub fn gsk_path_measure_unref(self_: *mut GskPathMeasure);
1692
1693 #[cfg(feature = "v4_14")]
1697 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1698 pub fn gsk_path_point_get_type() -> GType;
1699 #[cfg(feature = "v4_14")]
1700 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1701 pub fn gsk_path_point_compare(
1702 point1: *const GskPathPoint,
1703 point2: *const GskPathPoint,
1704 ) -> c_int;
1705 #[cfg(feature = "v4_14")]
1706 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1707 pub fn gsk_path_point_copy(point: *mut GskPathPoint) -> *mut GskPathPoint;
1708 #[cfg(feature = "v4_14")]
1709 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1710 pub fn gsk_path_point_equal(
1711 point1: *const GskPathPoint,
1712 point2: *const GskPathPoint,
1713 ) -> gboolean;
1714 #[cfg(feature = "v4_14")]
1715 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1716 pub fn gsk_path_point_free(point: *mut GskPathPoint);
1717 #[cfg(feature = "v4_14")]
1718 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1719 pub fn gsk_path_point_get_curvature(
1720 point: *const GskPathPoint,
1721 path: *mut GskPath,
1722 direction: GskPathDirection,
1723 center: *mut graphene::graphene_point_t,
1724 ) -> c_float;
1725 #[cfg(feature = "v4_14")]
1726 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1727 pub fn gsk_path_point_get_distance(
1728 point: *const GskPathPoint,
1729 measure: *mut GskPathMeasure,
1730 ) -> c_float;
1731 #[cfg(feature = "v4_14")]
1732 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1733 pub fn gsk_path_point_get_position(
1734 point: *const GskPathPoint,
1735 path: *mut GskPath,
1736 position: *mut graphene::graphene_point_t,
1737 );
1738 #[cfg(feature = "v4_14")]
1739 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1740 pub fn gsk_path_point_get_rotation(
1741 point: *const GskPathPoint,
1742 path: *mut GskPath,
1743 direction: GskPathDirection,
1744 ) -> c_float;
1745 #[cfg(feature = "v4_14")]
1746 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1747 pub fn gsk_path_point_get_tangent(
1748 point: *const GskPathPoint,
1749 path: *mut GskPath,
1750 direction: GskPathDirection,
1751 tangent: *mut graphene::graphene_vec2_t,
1752 );
1753
1754 #[cfg(feature = "v4_22")]
1758 #[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
1759 pub fn gsk_render_replay_get_type() -> GType;
1760 #[cfg(feature = "v4_22")]
1761 #[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
1762 pub fn gsk_render_replay_new() -> *mut GskRenderReplay;
1763 #[cfg(feature = "v4_22")]
1764 #[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
1765 pub fn gsk_render_replay_default(
1766 self_: *mut GskRenderReplay,
1767 node: *mut GskRenderNode,
1768 ) -> *mut GskRenderNode;
1769 #[cfg(feature = "v4_22")]
1770 #[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
1771 pub fn gsk_render_replay_filter_font(
1772 self_: *mut GskRenderReplay,
1773 font: *mut pango::PangoFont,
1774 ) -> *mut pango::PangoFont;
1775 #[cfg(feature = "v4_22")]
1776 #[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
1777 pub fn gsk_render_replay_filter_node(
1778 self_: *mut GskRenderReplay,
1779 node: *mut GskRenderNode,
1780 ) -> *mut GskRenderNode;
1781 #[cfg(feature = "v4_22")]
1782 #[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
1783 pub fn gsk_render_replay_filter_texture(
1784 self_: *mut GskRenderReplay,
1785 texture: *mut gdk::GdkTexture,
1786 ) -> *mut gdk::GdkTexture;
1787 #[cfg(feature = "v4_22")]
1788 #[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
1789 pub fn gsk_render_replay_free(self_: *mut GskRenderReplay);
1790 #[cfg(feature = "v4_22")]
1791 #[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
1792 pub fn gsk_render_replay_set_font_filter(
1793 self_: *mut GskRenderReplay,
1794 filter: GskRenderReplayFontFilter,
1795 user_data: gpointer,
1796 user_destroy: glib::GDestroyNotify,
1797 );
1798 #[cfg(feature = "v4_22")]
1799 #[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
1800 pub fn gsk_render_replay_set_node_filter(
1801 self_: *mut GskRenderReplay,
1802 filter: GskRenderReplayNodeFilter,
1803 user_data: gpointer,
1804 user_destroy: glib::GDestroyNotify,
1805 );
1806 #[cfg(feature = "v4_22")]
1807 #[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
1808 pub fn gsk_render_replay_set_texture_filter(
1809 self_: *mut GskRenderReplay,
1810 filter: GskRenderReplayTextureFilter,
1811 user_data: gpointer,
1812 user_destroy: glib::GDestroyNotify,
1813 );
1814
1815 pub fn gsk_rounded_rect_contains_point(
1819 self_: *const GskRoundedRect,
1820 point: *const graphene::graphene_point_t,
1821 ) -> gboolean;
1822 pub fn gsk_rounded_rect_contains_rect(
1823 self_: *const GskRoundedRect,
1824 rect: *const graphene::graphene_rect_t,
1825 ) -> gboolean;
1826 pub fn gsk_rounded_rect_init(
1827 self_: *mut GskRoundedRect,
1828 bounds: *const graphene::graphene_rect_t,
1829 top_left: *const graphene::graphene_size_t,
1830 top_right: *const graphene::graphene_size_t,
1831 bottom_right: *const graphene::graphene_size_t,
1832 bottom_left: *const graphene::graphene_size_t,
1833 ) -> *mut GskRoundedRect;
1834 pub fn gsk_rounded_rect_init_copy(
1835 self_: *mut GskRoundedRect,
1836 src: *const GskRoundedRect,
1837 ) -> *mut GskRoundedRect;
1838 pub fn gsk_rounded_rect_init_from_rect(
1839 self_: *mut GskRoundedRect,
1840 bounds: *const graphene::graphene_rect_t,
1841 radius: c_float,
1842 ) -> *mut GskRoundedRect;
1843 pub fn gsk_rounded_rect_intersects_rect(
1844 self_: *const GskRoundedRect,
1845 rect: *const graphene::graphene_rect_t,
1846 ) -> gboolean;
1847 pub fn gsk_rounded_rect_is_rectilinear(self_: *const GskRoundedRect) -> gboolean;
1848 pub fn gsk_rounded_rect_normalize(self_: *mut GskRoundedRect) -> *mut GskRoundedRect;
1849 pub fn gsk_rounded_rect_offset(
1850 self_: *mut GskRoundedRect,
1851 dx: c_float,
1852 dy: c_float,
1853 ) -> *mut GskRoundedRect;
1854 pub fn gsk_rounded_rect_shrink(
1855 self_: *mut GskRoundedRect,
1856 top: c_float,
1857 right: c_float,
1858 bottom: c_float,
1859 left: c_float,
1860 ) -> *mut GskRoundedRect;
1861
1862 pub fn gsk_shader_args_builder_get_type() -> GType;
1866 pub fn gsk_shader_args_builder_new(
1867 shader: *mut GskGLShader,
1868 initial_values: *mut glib::GBytes,
1869 ) -> *mut GskShaderArgsBuilder;
1870 pub fn gsk_shader_args_builder_free_to_args(
1871 builder: *mut GskShaderArgsBuilder,
1872 ) -> *mut glib::GBytes;
1873 pub fn gsk_shader_args_builder_ref(
1874 builder: *mut GskShaderArgsBuilder,
1875 ) -> *mut GskShaderArgsBuilder;
1876 pub fn gsk_shader_args_builder_set_bool(
1877 builder: *mut GskShaderArgsBuilder,
1878 idx: c_int,
1879 value: gboolean,
1880 );
1881 pub fn gsk_shader_args_builder_set_float(
1882 builder: *mut GskShaderArgsBuilder,
1883 idx: c_int,
1884 value: c_float,
1885 );
1886 pub fn gsk_shader_args_builder_set_int(
1887 builder: *mut GskShaderArgsBuilder,
1888 idx: c_int,
1889 value: i32,
1890 );
1891 pub fn gsk_shader_args_builder_set_uint(
1892 builder: *mut GskShaderArgsBuilder,
1893 idx: c_int,
1894 value: u32,
1895 );
1896 pub fn gsk_shader_args_builder_set_vec2(
1897 builder: *mut GskShaderArgsBuilder,
1898 idx: c_int,
1899 value: *const graphene::graphene_vec2_t,
1900 );
1901 pub fn gsk_shader_args_builder_set_vec3(
1902 builder: *mut GskShaderArgsBuilder,
1903 idx: c_int,
1904 value: *const graphene::graphene_vec3_t,
1905 );
1906 pub fn gsk_shader_args_builder_set_vec4(
1907 builder: *mut GskShaderArgsBuilder,
1908 idx: c_int,
1909 value: *const graphene::graphene_vec4_t,
1910 );
1911 pub fn gsk_shader_args_builder_to_args(builder: *mut GskShaderArgsBuilder)
1912 -> *mut glib::GBytes;
1913 pub fn gsk_shader_args_builder_unref(builder: *mut GskShaderArgsBuilder);
1914
1915 #[cfg(feature = "v4_14")]
1919 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1920 pub fn gsk_stroke_get_type() -> GType;
1921 #[cfg(feature = "v4_14")]
1922 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1923 pub fn gsk_stroke_new(line_width: c_float) -> *mut GskStroke;
1924 #[cfg(feature = "v4_14")]
1925 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1926 pub fn gsk_stroke_copy(other: *const GskStroke) -> *mut GskStroke;
1927 #[cfg(feature = "v4_14")]
1928 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1929 pub fn gsk_stroke_free(self_: *mut GskStroke);
1930 #[cfg(feature = "v4_14")]
1931 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1932 pub fn gsk_stroke_get_dash(self_: *const GskStroke, n_dash: *mut size_t) -> *const c_float;
1933 #[cfg(feature = "v4_14")]
1934 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1935 pub fn gsk_stroke_get_dash_offset(self_: *const GskStroke) -> c_float;
1936 #[cfg(feature = "v4_14")]
1937 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1938 pub fn gsk_stroke_get_line_cap(self_: *const GskStroke) -> GskLineCap;
1939 #[cfg(feature = "v4_14")]
1940 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1941 pub fn gsk_stroke_get_line_join(self_: *const GskStroke) -> GskLineJoin;
1942 #[cfg(feature = "v4_14")]
1943 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1944 pub fn gsk_stroke_get_line_width(self_: *const GskStroke) -> c_float;
1945 #[cfg(feature = "v4_14")]
1946 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1947 pub fn gsk_stroke_get_miter_limit(self_: *const GskStroke) -> c_float;
1948 #[cfg(feature = "v4_14")]
1949 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1950 pub fn gsk_stroke_set_dash(self_: *mut GskStroke, dash: *const c_float, n_dash: size_t);
1951 #[cfg(feature = "v4_14")]
1952 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1953 pub fn gsk_stroke_set_dash_offset(self_: *mut GskStroke, offset: c_float);
1954 #[cfg(feature = "v4_14")]
1955 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1956 pub fn gsk_stroke_set_line_cap(self_: *mut GskStroke, line_cap: GskLineCap);
1957 #[cfg(feature = "v4_14")]
1958 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1959 pub fn gsk_stroke_set_line_join(self_: *mut GskStroke, line_join: GskLineJoin);
1960 #[cfg(feature = "v4_14")]
1961 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1962 pub fn gsk_stroke_set_line_width(self_: *mut GskStroke, line_width: c_float);
1963 #[cfg(feature = "v4_14")]
1964 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1965 pub fn gsk_stroke_set_miter_limit(self_: *mut GskStroke, limit: c_float);
1966 #[cfg(feature = "v4_14")]
1967 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1968 pub fn gsk_stroke_to_cairo(self_: *const GskStroke, cr: *mut cairo::cairo_t);
1969 #[cfg(feature = "v4_14")]
1970 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1971 pub fn gsk_stroke_equal(stroke1: gconstpointer, stroke2: gconstpointer) -> gboolean;
1972
1973 pub fn gsk_transform_get_type() -> GType;
1977 pub fn gsk_transform_new() -> *mut GskTransform;
1978 pub fn gsk_transform_equal(first: *mut GskTransform, second: *mut GskTransform) -> gboolean;
1979 pub fn gsk_transform_get_category(self_: *mut GskTransform) -> GskTransformCategory;
1980 pub fn gsk_transform_invert(self_: *mut GskTransform) -> *mut GskTransform;
1981 pub fn gsk_transform_matrix(
1982 next: *mut GskTransform,
1983 matrix: *const graphene::graphene_matrix_t,
1984 ) -> *mut GskTransform;
1985 #[cfg(feature = "v4_20")]
1986 #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
1987 pub fn gsk_transform_matrix_2d(
1988 next: *mut GskTransform,
1989 xx: c_float,
1990 yx: c_float,
1991 xy: c_float,
1992 yy: c_float,
1993 dx: c_float,
1994 dy: c_float,
1995 ) -> *mut GskTransform;
1996 pub fn gsk_transform_perspective(next: *mut GskTransform, depth: c_float) -> *mut GskTransform;
1997 pub fn gsk_transform_print(self_: *mut GskTransform, string: *mut glib::GString);
1998 pub fn gsk_transform_ref(self_: *mut GskTransform) -> *mut GskTransform;
1999 pub fn gsk_transform_rotate(next: *mut GskTransform, angle: c_float) -> *mut GskTransform;
2000 pub fn gsk_transform_rotate_3d(
2001 next: *mut GskTransform,
2002 angle: c_float,
2003 axis: *const graphene::graphene_vec3_t,
2004 ) -> *mut GskTransform;
2005 pub fn gsk_transform_scale(
2006 next: *mut GskTransform,
2007 factor_x: c_float,
2008 factor_y: c_float,
2009 ) -> *mut GskTransform;
2010 pub fn gsk_transform_scale_3d(
2011 next: *mut GskTransform,
2012 factor_x: c_float,
2013 factor_y: c_float,
2014 factor_z: c_float,
2015 ) -> *mut GskTransform;
2016 #[cfg(feature = "v4_6")]
2017 #[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
2018 pub fn gsk_transform_skew(
2019 next: *mut GskTransform,
2020 skew_x: c_float,
2021 skew_y: c_float,
2022 ) -> *mut GskTransform;
2023 pub fn gsk_transform_to_2d(
2024 self_: *mut GskTransform,
2025 out_xx: *mut c_float,
2026 out_yx: *mut c_float,
2027 out_xy: *mut c_float,
2028 out_yy: *mut c_float,
2029 out_dx: *mut c_float,
2030 out_dy: *mut c_float,
2031 );
2032 #[cfg(feature = "v4_6")]
2033 #[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
2034 pub fn gsk_transform_to_2d_components(
2035 self_: *mut GskTransform,
2036 out_skew_x: *mut c_float,
2037 out_skew_y: *mut c_float,
2038 out_scale_x: *mut c_float,
2039 out_scale_y: *mut c_float,
2040 out_angle: *mut c_float,
2041 out_dx: *mut c_float,
2042 out_dy: *mut c_float,
2043 );
2044 pub fn gsk_transform_to_affine(
2045 self_: *mut GskTransform,
2046 out_scale_x: *mut c_float,
2047 out_scale_y: *mut c_float,
2048 out_dx: *mut c_float,
2049 out_dy: *mut c_float,
2050 );
2051 pub fn gsk_transform_to_matrix(
2052 self_: *mut GskTransform,
2053 out_matrix: *mut graphene::graphene_matrix_t,
2054 );
2055 pub fn gsk_transform_to_string(self_: *mut GskTransform) -> *mut c_char;
2056 pub fn gsk_transform_to_translate(
2057 self_: *mut GskTransform,
2058 out_dx: *mut c_float,
2059 out_dy: *mut c_float,
2060 );
2061 pub fn gsk_transform_transform(
2062 next: *mut GskTransform,
2063 other: *mut GskTransform,
2064 ) -> *mut GskTransform;
2065 pub fn gsk_transform_transform_bounds(
2066 self_: *mut GskTransform,
2067 rect: *const graphene::graphene_rect_t,
2068 out_rect: *mut graphene::graphene_rect_t,
2069 );
2070 pub fn gsk_transform_transform_point(
2071 self_: *mut GskTransform,
2072 point: *const graphene::graphene_point_t,
2073 out_point: *mut graphene::graphene_point_t,
2074 );
2075 pub fn gsk_transform_translate(
2076 next: *mut GskTransform,
2077 point: *const graphene::graphene_point_t,
2078 ) -> *mut GskTransform;
2079 pub fn gsk_transform_translate_3d(
2080 next: *mut GskTransform,
2081 point: *const graphene::graphene_point3d_t,
2082 ) -> *mut GskTransform;
2083 pub fn gsk_transform_unref(self_: *mut GskTransform);
2084 pub fn gsk_transform_parse(
2085 string: *const c_char,
2086 out_transform: *mut *mut GskTransform,
2087 ) -> gboolean;
2088
2089 pub fn gsk_blend_node_get_type() -> GType;
2093 pub fn gsk_blend_node_new(
2094 bottom: *mut GskRenderNode,
2095 top: *mut GskRenderNode,
2096 blend_mode: GskBlendMode,
2097 ) -> *mut GskBlendNode;
2098 pub fn gsk_blend_node_get_blend_mode(node: *const GskBlendNode) -> GskBlendMode;
2099 pub fn gsk_blend_node_get_bottom_child(node: *const GskBlendNode) -> *mut GskRenderNode;
2100 pub fn gsk_blend_node_get_top_child(node: *const GskBlendNode) -> *mut GskRenderNode;
2101
2102 pub fn gsk_blur_node_get_type() -> GType;
2106 pub fn gsk_blur_node_new(child: *mut GskRenderNode, radius: c_float) -> *mut GskBlurNode;
2107 pub fn gsk_blur_node_get_child(node: *const GskBlurNode) -> *mut GskRenderNode;
2108 pub fn gsk_blur_node_get_radius(node: *const GskBlurNode) -> c_float;
2109
2110 pub fn gsk_border_node_get_type() -> GType;
2114 pub fn gsk_border_node_new(
2115 outline: *const GskRoundedRect,
2116 border_width: *const [c_float; 4],
2117 border_color: *const [gdk::GdkRGBA; 4],
2118 ) -> *mut GskBorderNode;
2119 #[cfg(feature = "v4_24")]
2120 #[cfg_attr(docsrs, doc(cfg(feature = "v4_24")))]
2121 pub fn gsk_border_node_get_border_snap(node: *const GskBorderNode) -> GskRectSnap;
2122 pub fn gsk_border_node_get_colors(node: *const GskBorderNode) -> *const [gdk::GdkRGBA; 4];
2123 pub fn gsk_border_node_get_outline(node: *const GskBorderNode) -> *const GskRoundedRect;
2124 #[cfg(feature = "v4_24")]
2125 #[cfg_attr(docsrs, doc(cfg(feature = "v4_24")))]
2126 pub fn gsk_border_node_get_snap(node: *const GskBorderNode) -> GskRectSnap;
2127 pub fn gsk_border_node_get_widths(node: *const GskBorderNode) -> *const [c_float; 4];
2128
2129 #[cfg(feature = "broadway")]
2133 #[cfg_attr(docsrs, doc(cfg(feature = "broadway")))]
2134 pub fn gsk_broadway_renderer_get_type() -> GType;
2135 #[cfg(feature = "broadway")]
2136 #[cfg_attr(docsrs, doc(cfg(feature = "broadway")))]
2137 pub fn gsk_broadway_renderer_new() -> *mut GskRenderer;
2138
2139 pub fn gsk_cairo_node_get_type() -> GType;
2143 pub fn gsk_cairo_node_new(bounds: *const graphene::graphene_rect_t) -> *mut GskCairoNode;
2144 pub fn gsk_cairo_node_get_draw_context(node: *mut GskCairoNode) -> *mut cairo::cairo_t;
2145 pub fn gsk_cairo_node_get_surface(node: *mut GskCairoNode) -> *mut cairo::cairo_surface_t;
2146
2147 pub fn gsk_cairo_renderer_get_type() -> GType;
2151 pub fn gsk_cairo_renderer_new() -> *mut GskRenderer;
2152
2153 pub fn gsk_clip_node_get_type() -> GType;
2157 pub fn gsk_clip_node_new(
2158 child: *mut GskRenderNode,
2159 clip: *const graphene::graphene_rect_t,
2160 ) -> *mut GskClipNode;
2161 pub fn gsk_clip_node_get_child(node: *const GskClipNode) -> *mut GskRenderNode;
2162 pub fn gsk_clip_node_get_clip(node: *const GskClipNode) -> *const graphene::graphene_rect_t;
2163 #[cfg(feature = "v4_24")]
2164 #[cfg_attr(docsrs, doc(cfg(feature = "v4_24")))]
2165 pub fn gsk_clip_node_get_snap(node: *const GskClipNode) -> GskRectSnap;
2166
2167 pub fn gsk_color_matrix_node_get_type() -> GType;
2171 pub fn gsk_color_matrix_node_new(
2172 child: *mut GskRenderNode,
2173 color_matrix: *const graphene::graphene_matrix_t,
2174 color_offset: *const graphene::graphene_vec4_t,
2175 ) -> *mut GskColorMatrixNode;
2176 pub fn gsk_color_matrix_node_get_child(node: *const GskColorMatrixNode) -> *mut GskRenderNode;
2177 pub fn gsk_color_matrix_node_get_color_matrix(
2178 node: *const GskColorMatrixNode,
2179 ) -> *const graphene::graphene_matrix_t;
2180 pub fn gsk_color_matrix_node_get_color_offset(
2181 node: *const GskColorMatrixNode,
2182 ) -> *const graphene::graphene_vec4_t;
2183 #[cfg(feature = "v4_24")]
2184 #[cfg_attr(docsrs, doc(cfg(feature = "v4_24")))]
2185 pub fn gsk_color_matrix_node_get_snap(node: *const GskColorMatrixNode) -> GskRectSnap;
2186
2187 pub fn gsk_color_node_get_type() -> GType;
2191 pub fn gsk_color_node_new(
2192 rgba: *const gdk::GdkRGBA,
2193 bounds: *const graphene::graphene_rect_t,
2194 ) -> *mut GskColorNode;
2195 pub fn gsk_color_node_get_color(node: *const GskColorNode) -> *const gdk::GdkRGBA;
2196 #[cfg(feature = "v4_24")]
2197 #[cfg_attr(docsrs, doc(cfg(feature = "v4_24")))]
2198 pub fn gsk_color_node_get_snap(node: *const GskColorNode) -> GskRectSnap;
2199
2200 #[cfg(feature = "v4_20")]
2204 #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
2205 pub fn gsk_component_transfer_node_get_type() -> GType;
2206 #[cfg(feature = "v4_20")]
2207 #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
2208 pub fn gsk_component_transfer_node_new(
2209 child: *mut GskRenderNode,
2210 r: *const GskComponentTransfer,
2211 g: *const GskComponentTransfer,
2212 b: *const GskComponentTransfer,
2213 a: *const GskComponentTransfer,
2214 ) -> *mut GskComponentTransferNode;
2215 #[cfg(feature = "v4_20")]
2216 #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
2217 pub fn gsk_component_transfer_node_get_child(
2218 node: *const GskComponentTransferNode,
2219 ) -> *mut GskRenderNode;
2220 #[cfg(feature = "v4_20")]
2221 #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
2222 pub fn gsk_component_transfer_node_get_transfer(
2223 node: *const GskComponentTransferNode,
2224 component: gdk::GdkColorChannel,
2225 ) -> *const GskComponentTransfer;
2226
2227 #[cfg(feature = "v4_22")]
2231 #[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
2232 pub fn gsk_composite_node_get_type() -> GType;
2233 #[cfg(feature = "v4_22")]
2234 #[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
2235 pub fn gsk_composite_node_new(
2236 child: *mut GskRenderNode,
2237 mask: *mut GskRenderNode,
2238 op: GskPorterDuff,
2239 ) -> *mut GskCompositeNode;
2240 #[cfg(feature = "v4_22")]
2241 #[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
2242 pub fn gsk_composite_node_get_child(node: *const GskCompositeNode) -> *mut GskRenderNode;
2243 #[cfg(feature = "v4_22")]
2244 #[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
2245 pub fn gsk_composite_node_get_mask(node: *const GskCompositeNode) -> *mut GskRenderNode;
2246 #[cfg(feature = "v4_22")]
2247 #[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
2248 pub fn gsk_composite_node_get_operator(node: *const GskCompositeNode) -> GskPorterDuff;
2249
2250 pub fn gsk_conic_gradient_node_get_type() -> GType;
2254 pub fn gsk_conic_gradient_node_new(
2255 bounds: *const graphene::graphene_rect_t,
2256 center: *const graphene::graphene_point_t,
2257 rotation: c_float,
2258 color_stops: *const GskColorStop,
2259 n_color_stops: size_t,
2260 ) -> *mut GskConicGradientNode;
2261 #[cfg(feature = "v4_2")]
2262 #[cfg_attr(docsrs, doc(cfg(feature = "v4_2")))]
2263 pub fn gsk_conic_gradient_node_get_angle(node: *const GskConicGradientNode) -> c_float;
2264 pub fn gsk_conic_gradient_node_get_center(
2265 node: *const GskConicGradientNode,
2266 ) -> *const graphene::graphene_point_t;
2267 pub fn gsk_conic_gradient_node_get_color_stops(
2268 node: *const GskConicGradientNode,
2269 n_stops: *mut size_t,
2270 ) -> *const GskColorStop;
2271 pub fn gsk_conic_gradient_node_get_n_color_stops(node: *const GskConicGradientNode) -> size_t;
2272 pub fn gsk_conic_gradient_node_get_rotation(node: *const GskConicGradientNode) -> c_float;
2273 #[cfg(feature = "v4_24")]
2274 #[cfg_attr(docsrs, doc(cfg(feature = "v4_24")))]
2275 pub fn gsk_conic_gradient_node_get_snap(node: *const GskConicGradientNode) -> GskRectSnap;
2276
2277 pub fn gsk_container_node_get_type() -> GType;
2281 pub fn gsk_container_node_new(
2282 children: *mut *mut GskRenderNode,
2283 n_children: c_uint,
2284 ) -> *mut GskContainerNode;
2285 pub fn gsk_container_node_get_child(
2286 node: *const GskContainerNode,
2287 idx: c_uint,
2288 ) -> *mut GskRenderNode;
2289 pub fn gsk_container_node_get_n_children(node: *const GskContainerNode) -> c_uint;
2290
2291 #[cfg(feature = "v4_22")]
2295 #[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
2296 pub fn gsk_copy_node_get_type() -> GType;
2297 #[cfg(feature = "v4_22")]
2298 #[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
2299 pub fn gsk_copy_node_new(child: *mut GskRenderNode) -> *mut GskCopyNode;
2300 #[cfg(feature = "v4_22")]
2301 #[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
2302 pub fn gsk_copy_node_get_child(node: *const GskCopyNode) -> *mut GskRenderNode;
2303
2304 pub fn gsk_cross_fade_node_get_type() -> GType;
2308 pub fn gsk_cross_fade_node_new(
2309 start: *mut GskRenderNode,
2310 end: *mut GskRenderNode,
2311 progress: c_float,
2312 ) -> *mut GskCrossFadeNode;
2313 pub fn gsk_cross_fade_node_get_end_child(node: *const GskCrossFadeNode) -> *mut GskRenderNode;
2314 pub fn gsk_cross_fade_node_get_progress(node: *const GskCrossFadeNode) -> c_float;
2315 pub fn gsk_cross_fade_node_get_start_child(node: *const GskCrossFadeNode)
2316 -> *mut GskRenderNode;
2317
2318 pub fn gsk_debug_node_get_type() -> GType;
2322 pub fn gsk_debug_node_new(child: *mut GskRenderNode, message: *mut c_char)
2323 -> *mut GskDebugNode;
2324 pub fn gsk_debug_node_get_child(node: *const GskDebugNode) -> *mut GskRenderNode;
2325 pub fn gsk_debug_node_get_message(node: *const GskDebugNode) -> *const c_char;
2326
2327 #[cfg(feature = "v4_14")]
2331 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
2332 pub fn gsk_fill_node_get_type() -> GType;
2333 #[cfg(feature = "v4_14")]
2334 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
2335 pub fn gsk_fill_node_new(
2336 child: *mut GskRenderNode,
2337 path: *mut GskPath,
2338 fill_rule: GskFillRule,
2339 ) -> *mut GskFillNode;
2340 #[cfg(feature = "v4_14")]
2341 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
2342 pub fn gsk_fill_node_get_child(node: *const GskFillNode) -> *mut GskRenderNode;
2343 #[cfg(feature = "v4_14")]
2344 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
2345 pub fn gsk_fill_node_get_fill_rule(node: *const GskFillNode) -> GskFillRule;
2346 #[cfg(feature = "v4_14")]
2347 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
2348 pub fn gsk_fill_node_get_path(node: *const GskFillNode) -> *mut GskPath;
2349
2350 #[cfg(feature = "v4_2")]
2354 #[cfg_attr(docsrs, doc(cfg(feature = "v4_2")))]
2355 pub fn gsk_gl_renderer_get_type() -> GType;
2356 #[cfg(feature = "v4_2")]
2357 #[cfg_attr(docsrs, doc(cfg(feature = "v4_2")))]
2358 pub fn gsk_gl_renderer_new() -> *mut GskRenderer;
2359
2360 pub fn gsk_gl_shader_get_type() -> GType;
2364 pub fn gsk_gl_shader_new_from_bytes(sourcecode: *mut glib::GBytes) -> *mut GskGLShader;
2365 pub fn gsk_gl_shader_new_from_resource(resource_path: *const c_char) -> *mut GskGLShader;
2366 pub fn gsk_gl_shader_compile(
2367 shader: *mut GskGLShader,
2368 renderer: *mut GskRenderer,
2369 error: *mut *mut glib::GError,
2370 ) -> gboolean;
2371 pub fn gsk_gl_shader_find_uniform_by_name(
2372 shader: *mut GskGLShader,
2373 name: *const c_char,
2374 ) -> c_int;
2375 pub fn gsk_gl_shader_format_args(shader: *mut GskGLShader, ...) -> *mut glib::GBytes;
2376 pub fn gsk_gl_shader_get_arg_bool(
2378 shader: *mut GskGLShader,
2379 args: *mut glib::GBytes,
2380 idx: c_int,
2381 ) -> gboolean;
2382 pub fn gsk_gl_shader_get_arg_float(
2383 shader: *mut GskGLShader,
2384 args: *mut glib::GBytes,
2385 idx: c_int,
2386 ) -> c_float;
2387 pub fn gsk_gl_shader_get_arg_int(
2388 shader: *mut GskGLShader,
2389 args: *mut glib::GBytes,
2390 idx: c_int,
2391 ) -> i32;
2392 pub fn gsk_gl_shader_get_arg_uint(
2393 shader: *mut GskGLShader,
2394 args: *mut glib::GBytes,
2395 idx: c_int,
2396 ) -> u32;
2397 pub fn gsk_gl_shader_get_arg_vec2(
2398 shader: *mut GskGLShader,
2399 args: *mut glib::GBytes,
2400 idx: c_int,
2401 out_value: *mut graphene::graphene_vec2_t,
2402 );
2403 pub fn gsk_gl_shader_get_arg_vec3(
2404 shader: *mut GskGLShader,
2405 args: *mut glib::GBytes,
2406 idx: c_int,
2407 out_value: *mut graphene::graphene_vec3_t,
2408 );
2409 pub fn gsk_gl_shader_get_arg_vec4(
2410 shader: *mut GskGLShader,
2411 args: *mut glib::GBytes,
2412 idx: c_int,
2413 out_value: *mut graphene::graphene_vec4_t,
2414 );
2415 pub fn gsk_gl_shader_get_args_size(shader: *mut GskGLShader) -> size_t;
2416 pub fn gsk_gl_shader_get_n_textures(shader: *mut GskGLShader) -> c_int;
2417 pub fn gsk_gl_shader_get_n_uniforms(shader: *mut GskGLShader) -> c_int;
2418 pub fn gsk_gl_shader_get_resource(shader: *mut GskGLShader) -> *const c_char;
2419 pub fn gsk_gl_shader_get_source(shader: *mut GskGLShader) -> *mut glib::GBytes;
2420 pub fn gsk_gl_shader_get_uniform_name(shader: *mut GskGLShader, idx: c_int) -> *const c_char;
2421 pub fn gsk_gl_shader_get_uniform_offset(shader: *mut GskGLShader, idx: c_int) -> c_int;
2422 pub fn gsk_gl_shader_get_uniform_type(shader: *mut GskGLShader, idx: c_int)
2423 -> GskGLUniformType;
2424
2425 pub fn gsk_gl_shader_node_get_type() -> GType;
2429 pub fn gsk_gl_shader_node_new(
2430 shader: *mut GskGLShader,
2431 bounds: *const graphene::graphene_rect_t,
2432 args: *mut glib::GBytes,
2433 children: *mut *mut GskRenderNode,
2434 n_children: c_uint,
2435 ) -> *mut GskGLShaderNode;
2436 pub fn gsk_gl_shader_node_get_args(node: *const GskGLShaderNode) -> *mut glib::GBytes;
2437 pub fn gsk_gl_shader_node_get_child(
2438 node: *const GskGLShaderNode,
2439 idx: c_uint,
2440 ) -> *mut GskRenderNode;
2441 pub fn gsk_gl_shader_node_get_n_children(node: *const GskGLShaderNode) -> c_uint;
2442 pub fn gsk_gl_shader_node_get_shader(node: *const GskGLShaderNode) -> *mut GskGLShader;
2443
2444 pub fn gsk_inset_shadow_node_get_type() -> GType;
2448 pub fn gsk_inset_shadow_node_new(
2449 outline: *const GskRoundedRect,
2450 color: *const gdk::GdkRGBA,
2451 dx: c_float,
2452 dy: c_float,
2453 spread: c_float,
2454 blur_radius: c_float,
2455 ) -> *mut GskInsetShadowNode;
2456 pub fn gsk_inset_shadow_node_get_blur_radius(node: *const GskInsetShadowNode) -> c_float;
2457 pub fn gsk_inset_shadow_node_get_color(node: *const GskInsetShadowNode) -> *const gdk::GdkRGBA;
2458 pub fn gsk_inset_shadow_node_get_dx(node: *const GskInsetShadowNode) -> c_float;
2459 pub fn gsk_inset_shadow_node_get_dy(node: *const GskInsetShadowNode) -> c_float;
2460 pub fn gsk_inset_shadow_node_get_outline(
2461 node: *const GskInsetShadowNode,
2462 ) -> *const GskRoundedRect;
2463 #[cfg(feature = "v4_24")]
2464 #[cfg_attr(docsrs, doc(cfg(feature = "v4_24")))]
2465 pub fn gsk_inset_shadow_node_get_snap(node: *const GskInsetShadowNode) -> GskRectSnap;
2466 pub fn gsk_inset_shadow_node_get_spread(node: *const GskInsetShadowNode) -> c_float;
2467
2468 #[cfg(feature = "v4_22")]
2472 #[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
2473 pub fn gsk_isolation_node_get_type() -> GType;
2474 #[cfg(feature = "v4_22")]
2475 #[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
2476 pub fn gsk_isolation_node_new(
2477 child: *mut GskRenderNode,
2478 isolations: GskIsolation,
2479 ) -> *mut GskIsolationNode;
2480 #[cfg(feature = "v4_22")]
2481 #[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
2482 pub fn gsk_isolation_node_get_child(node: *const GskIsolationNode) -> *mut GskRenderNode;
2483 #[cfg(feature = "v4_22")]
2484 #[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
2485 pub fn gsk_isolation_node_get_isolations(node: *const GskIsolationNode) -> GskIsolation;
2486
2487 pub fn gsk_linear_gradient_node_get_type() -> GType;
2491 pub fn gsk_linear_gradient_node_new(
2492 bounds: *const graphene::graphene_rect_t,
2493 start: *const graphene::graphene_point_t,
2494 end: *const graphene::graphene_point_t,
2495 color_stops: *const GskColorStop,
2496 n_color_stops: size_t,
2497 ) -> *mut GskLinearGradientNode;
2498 pub fn gsk_linear_gradient_node_get_color_stops(
2499 node: *const GskLinearGradientNode,
2500 n_stops: *mut size_t,
2501 ) -> *const GskColorStop;
2502 pub fn gsk_linear_gradient_node_get_end(
2503 node: *const GskLinearGradientNode,
2504 ) -> *const graphene::graphene_point_t;
2505 pub fn gsk_linear_gradient_node_get_n_color_stops(node: *const GskLinearGradientNode)
2506 -> size_t;
2507 #[cfg(feature = "v4_24")]
2508 #[cfg_attr(docsrs, doc(cfg(feature = "v4_24")))]
2509 pub fn gsk_linear_gradient_node_get_snap(node: *const GskLinearGradientNode) -> GskRectSnap;
2510 pub fn gsk_linear_gradient_node_get_start(
2511 node: *const GskLinearGradientNode,
2512 ) -> *const graphene::graphene_point_t;
2513
2514 #[cfg(feature = "v4_10")]
2518 #[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
2519 pub fn gsk_mask_node_get_type() -> GType;
2520 #[cfg(feature = "v4_10")]
2521 #[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
2522 pub fn gsk_mask_node_new(
2523 source: *mut GskRenderNode,
2524 mask: *mut GskRenderNode,
2525 mask_mode: GskMaskMode,
2526 ) -> *mut GskMaskNode;
2527 #[cfg(feature = "v4_10")]
2528 #[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
2529 pub fn gsk_mask_node_get_mask(node: *const GskMaskNode) -> *mut GskRenderNode;
2530 #[cfg(feature = "v4_10")]
2531 #[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
2532 pub fn gsk_mask_node_get_mask_mode(node: *const GskMaskNode) -> GskMaskMode;
2533 #[cfg(feature = "v4_10")]
2534 #[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
2535 pub fn gsk_mask_node_get_source(node: *const GskMaskNode) -> *mut GskRenderNode;
2536
2537 pub fn gsk_ngl_renderer_get_type() -> GType;
2541 pub fn gsk_ngl_renderer_new() -> *mut GskRenderer;
2542
2543 pub fn gsk_opacity_node_get_type() -> GType;
2547 pub fn gsk_opacity_node_new(child: *mut GskRenderNode, opacity: c_float)
2548 -> *mut GskOpacityNode;
2549 pub fn gsk_opacity_node_get_child(node: *const GskOpacityNode) -> *mut GskRenderNode;
2550 pub fn gsk_opacity_node_get_opacity(node: *const GskOpacityNode) -> c_float;
2551
2552 pub fn gsk_outset_shadow_node_get_type() -> GType;
2556 pub fn gsk_outset_shadow_node_new(
2557 outline: *const GskRoundedRect,
2558 color: *const gdk::GdkRGBA,
2559 dx: c_float,
2560 dy: c_float,
2561 spread: c_float,
2562 blur_radius: c_float,
2563 ) -> *mut GskOutsetShadowNode;
2564 pub fn gsk_outset_shadow_node_get_blur_radius(node: *const GskOutsetShadowNode) -> c_float;
2565 pub fn gsk_outset_shadow_node_get_color(
2566 node: *const GskOutsetShadowNode,
2567 ) -> *const gdk::GdkRGBA;
2568 pub fn gsk_outset_shadow_node_get_dx(node: *const GskOutsetShadowNode) -> c_float;
2569 pub fn gsk_outset_shadow_node_get_dy(node: *const GskOutsetShadowNode) -> c_float;
2570 pub fn gsk_outset_shadow_node_get_outline(
2571 node: *const GskOutsetShadowNode,
2572 ) -> *const GskRoundedRect;
2573 #[cfg(feature = "v4_24")]
2574 #[cfg_attr(docsrs, doc(cfg(feature = "v4_24")))]
2575 pub fn gsk_outset_shadow_node_get_snap(node: *const GskOutsetShadowNode) -> GskRectSnap;
2576 pub fn gsk_outset_shadow_node_get_spread(node: *const GskOutsetShadowNode) -> c_float;
2577
2578 #[cfg(feature = "v4_22")]
2582 #[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
2583 pub fn gsk_paste_node_get_type() -> GType;
2584 #[cfg(feature = "v4_22")]
2585 #[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
2586 pub fn gsk_paste_node_new(
2587 bounds: *const graphene::graphene_rect_t,
2588 depth: size_t,
2589 ) -> *mut GskPasteNode;
2590 #[cfg(feature = "v4_22")]
2591 #[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
2592 pub fn gsk_paste_node_get_depth(node: *const GskPasteNode) -> size_t;
2593 #[cfg(feature = "v4_24")]
2594 #[cfg_attr(docsrs, doc(cfg(feature = "v4_24")))]
2595 pub fn gsk_paste_node_get_snap(node: *const GskPasteNode) -> GskRectSnap;
2596
2597 pub fn gsk_radial_gradient_node_get_type() -> GType;
2601 pub fn gsk_radial_gradient_node_new(
2602 bounds: *const graphene::graphene_rect_t,
2603 center: *const graphene::graphene_point_t,
2604 hradius: c_float,
2605 vradius: c_float,
2606 start: c_float,
2607 end: c_float,
2608 color_stops: *const GskColorStop,
2609 n_color_stops: size_t,
2610 ) -> *mut GskRadialGradientNode;
2611 pub fn gsk_radial_gradient_node_get_center(
2612 node: *const GskRadialGradientNode,
2613 ) -> *const graphene::graphene_point_t;
2614 pub fn gsk_radial_gradient_node_get_color_stops(
2615 node: *const GskRadialGradientNode,
2616 n_stops: *mut size_t,
2617 ) -> *const GskColorStop;
2618 pub fn gsk_radial_gradient_node_get_end(node: *const GskRadialGradientNode) -> c_float;
2619 pub fn gsk_radial_gradient_node_get_hradius(node: *const GskRadialGradientNode) -> c_float;
2620 pub fn gsk_radial_gradient_node_get_n_color_stops(node: *const GskRadialGradientNode)
2621 -> size_t;
2622 #[cfg(feature = "v4_24")]
2623 #[cfg_attr(docsrs, doc(cfg(feature = "v4_24")))]
2624 pub fn gsk_radial_gradient_node_get_snap(node: *const GskRadialGradientNode) -> GskRectSnap;
2625 pub fn gsk_radial_gradient_node_get_start(node: *const GskRadialGradientNode) -> c_float;
2626 pub fn gsk_radial_gradient_node_get_vradius(node: *const GskRadialGradientNode) -> c_float;
2627
2628 pub fn gsk_render_node_get_type() -> GType;
2632 pub fn gsk_render_node_deserialize(
2633 bytes: *mut glib::GBytes,
2634 error_func: GskParseErrorFunc,
2635 user_data: gpointer,
2636 ) -> *mut GskRenderNode;
2637 pub fn gsk_render_node_draw(node: *mut GskRenderNode, cr: *mut cairo::cairo_t);
2638 pub fn gsk_render_node_get_bounds(
2639 node: *mut GskRenderNode,
2640 bounds: *mut graphene::graphene_rect_t,
2641 );
2642 #[cfg(feature = "v4_22")]
2643 #[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
2644 pub fn gsk_render_node_get_children(
2645 self_: *mut GskRenderNode,
2646 n_children: *mut size_t,
2647 ) -> *mut *mut GskRenderNode;
2648 pub fn gsk_render_node_get_node_type(node: *const GskRenderNode) -> GskRenderNodeType;
2649 #[cfg(feature = "v4_16")]
2650 #[cfg_attr(docsrs, doc(cfg(feature = "v4_16")))]
2651 pub fn gsk_render_node_get_opaque_rect(
2652 self_: *mut GskRenderNode,
2653 out_opaque: *mut graphene::graphene_rect_t,
2654 ) -> gboolean;
2655 pub fn gsk_render_node_ref(node: *mut GskRenderNode) -> *mut GskRenderNode;
2656 pub fn gsk_render_node_serialize(node: *mut GskRenderNode) -> *mut glib::GBytes;
2657 pub fn gsk_render_node_unref(node: *mut GskRenderNode);
2658 pub fn gsk_render_node_write_to_file(
2659 node: *mut GskRenderNode,
2660 filename: *const c_char,
2661 error: *mut *mut glib::GError,
2662 ) -> gboolean;
2663
2664 pub fn gsk_renderer_get_type() -> GType;
2668 pub fn gsk_renderer_new_for_surface(surface: *mut gdk::GdkSurface) -> *mut GskRenderer;
2669 pub fn gsk_renderer_get_surface(renderer: *mut GskRenderer) -> *mut gdk::GdkSurface;
2670 pub fn gsk_renderer_is_realized(renderer: *mut GskRenderer) -> gboolean;
2671 pub fn gsk_renderer_realize(
2672 renderer: *mut GskRenderer,
2673 surface: *mut gdk::GdkSurface,
2674 error: *mut *mut glib::GError,
2675 ) -> gboolean;
2676 #[cfg(feature = "v4_14")]
2677 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
2678 pub fn gsk_renderer_realize_for_display(
2679 renderer: *mut GskRenderer,
2680 display: *mut gdk::GdkDisplay,
2681 error: *mut *mut glib::GError,
2682 ) -> gboolean;
2683 pub fn gsk_renderer_render(
2684 renderer: *mut GskRenderer,
2685 root: *mut GskRenderNode,
2686 region: *const cairo::cairo_region_t,
2687 );
2688 pub fn gsk_renderer_render_texture(
2689 renderer: *mut GskRenderer,
2690 root: *mut GskRenderNode,
2691 viewport: *const graphene::graphene_rect_t,
2692 ) -> *mut gdk::GdkTexture;
2693 pub fn gsk_renderer_unrealize(renderer: *mut GskRenderer);
2694
2695 pub fn gsk_repeat_node_get_type() -> GType;
2699 pub fn gsk_repeat_node_new(
2700 bounds: *const graphene::graphene_rect_t,
2701 child: *mut GskRenderNode,
2702 child_bounds: *const graphene::graphene_rect_t,
2703 ) -> *mut GskRepeatNode;
2704 pub fn gsk_repeat_node_get_child(node: *const GskRepeatNode) -> *mut GskRenderNode;
2705 pub fn gsk_repeat_node_get_child_bounds(
2706 node: *const GskRepeatNode,
2707 ) -> *const graphene::graphene_rect_t;
2708 #[cfg(feature = "v4_24")]
2709 #[cfg_attr(docsrs, doc(cfg(feature = "v4_24")))]
2710 pub fn gsk_repeat_node_get_child_snap(node: *const GskRepeatNode) -> GskRectSnap;
2711 #[cfg(feature = "v4_24")]
2712 #[cfg_attr(docsrs, doc(cfg(feature = "v4_24")))]
2713 pub fn gsk_repeat_node_get_snap(node: *const GskRepeatNode) -> GskRectSnap;
2714
2715 pub fn gsk_repeating_linear_gradient_node_get_type() -> GType;
2719 pub fn gsk_repeating_linear_gradient_node_new(
2720 bounds: *const graphene::graphene_rect_t,
2721 start: *const graphene::graphene_point_t,
2722 end: *const graphene::graphene_point_t,
2723 color_stops: *const GskColorStop,
2724 n_color_stops: size_t,
2725 ) -> *mut GskRepeatingLinearGradientNode;
2726
2727 pub fn gsk_repeating_radial_gradient_node_get_type() -> GType;
2731 pub fn gsk_repeating_radial_gradient_node_new(
2732 bounds: *const graphene::graphene_rect_t,
2733 center: *const graphene::graphene_point_t,
2734 hradius: c_float,
2735 vradius: c_float,
2736 start: c_float,
2737 end: c_float,
2738 color_stops: *const GskColorStop,
2739 n_color_stops: size_t,
2740 ) -> *mut GskRepeatingRadialGradientNode;
2741
2742 pub fn gsk_rounded_clip_node_get_type() -> GType;
2746 pub fn gsk_rounded_clip_node_new(
2747 child: *mut GskRenderNode,
2748 clip: *const GskRoundedRect,
2749 ) -> *mut GskRoundedClipNode;
2750 pub fn gsk_rounded_clip_node_get_child(node: *const GskRoundedClipNode) -> *mut GskRenderNode;
2751 pub fn gsk_rounded_clip_node_get_clip(node: *const GskRoundedClipNode)
2752 -> *const GskRoundedRect;
2753 #[cfg(feature = "v4_24")]
2754 #[cfg_attr(docsrs, doc(cfg(feature = "v4_24")))]
2755 pub fn gsk_rounded_clip_node_get_snap(node: *const GskRoundedClipNode) -> GskRectSnap;
2756
2757 pub fn gsk_shadow_node_get_type() -> GType;
2761 pub fn gsk_shadow_node_new(
2762 child: *mut GskRenderNode,
2763 shadows: *const GskShadow,
2764 n_shadows: size_t,
2765 ) -> *mut GskShadowNode;
2766 pub fn gsk_shadow_node_get_child(node: *const GskShadowNode) -> *mut GskRenderNode;
2767 pub fn gsk_shadow_node_get_n_shadows(node: *const GskShadowNode) -> size_t;
2768 pub fn gsk_shadow_node_get_shadow(node: *const GskShadowNode, i: size_t) -> *const GskShadow;
2769
2770 #[cfg(feature = "v4_14")]
2774 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
2775 pub fn gsk_stroke_node_get_type() -> GType;
2776 #[cfg(feature = "v4_14")]
2777 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
2778 pub fn gsk_stroke_node_new(
2779 child: *mut GskRenderNode,
2780 path: *mut GskPath,
2781 stroke: *const GskStroke,
2782 ) -> *mut GskStrokeNode;
2783 #[cfg(feature = "v4_14")]
2784 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
2785 pub fn gsk_stroke_node_get_child(node: *const GskStrokeNode) -> *mut GskRenderNode;
2786 #[cfg(feature = "v4_14")]
2787 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
2788 pub fn gsk_stroke_node_get_path(node: *const GskStrokeNode) -> *mut GskPath;
2789 #[cfg(feature = "v4_14")]
2790 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
2791 pub fn gsk_stroke_node_get_stroke(node: *const GskStrokeNode) -> *const GskStroke;
2792
2793 #[cfg(feature = "v4_14")]
2797 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
2798 pub fn gsk_subsurface_node_get_type() -> GType;
2799 #[cfg(feature = "v4_14")]
2800 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
2801 pub fn gsk_subsurface_node_new(
2802 child: *mut GskRenderNode,
2803 subsurface: gpointer,
2804 ) -> *mut GskSubsurfaceNode;
2805 #[cfg(feature = "v4_14")]
2806 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
2807 pub fn gsk_subsurface_node_get_subsurface(node: *const GskDebugNode) -> gpointer;
2808 #[cfg(feature = "v4_14")]
2809 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
2810 pub fn gsk_subsurface_node_get_child(node: *const GskSubsurfaceNode) -> *mut GskRenderNode;
2811
2812 pub fn gsk_text_node_get_type() -> GType;
2816 pub fn gsk_text_node_new(
2817 font: *mut pango::PangoFont,
2818 glyphs: *mut pango::PangoGlyphString,
2819 color: *const gdk::GdkRGBA,
2820 offset: *const graphene::graphene_point_t,
2821 ) -> *mut GskTextNode;
2822 pub fn gsk_text_node_get_color(node: *const GskTextNode) -> *const gdk::GdkRGBA;
2823 pub fn gsk_text_node_get_font(node: *const GskTextNode) -> *mut pango::PangoFont;
2824 pub fn gsk_text_node_get_glyphs(
2825 node: *const GskTextNode,
2826 n_glyphs: *mut c_uint,
2827 ) -> *const pango::PangoGlyphInfo;
2828 pub fn gsk_text_node_get_num_glyphs(node: *const GskTextNode) -> c_uint;
2829 pub fn gsk_text_node_get_offset(node: *const GskTextNode) -> *const graphene::graphene_point_t;
2830 #[cfg(feature = "v4_2")]
2831 #[cfg_attr(docsrs, doc(cfg(feature = "v4_2")))]
2832 pub fn gsk_text_node_has_color_glyphs(node: *const GskTextNode) -> gboolean;
2833
2834 pub fn gsk_texture_node_get_type() -> GType;
2838 pub fn gsk_texture_node_new(
2839 texture: *mut gdk::GdkTexture,
2840 bounds: *const graphene::graphene_rect_t,
2841 ) -> *mut GskTextureNode;
2842 #[cfg(feature = "v4_24")]
2843 #[cfg_attr(docsrs, doc(cfg(feature = "v4_24")))]
2844 pub fn gsk_texture_node_get_snap(node: *const GskTextureNode) -> GskRectSnap;
2845 pub fn gsk_texture_node_get_texture(node: *const GskTextureNode) -> *mut gdk::GdkTexture;
2846
2847 #[cfg(feature = "v4_10")]
2851 #[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
2852 pub fn gsk_texture_scale_node_get_type() -> GType;
2853 #[cfg(feature = "v4_10")]
2854 #[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
2855 pub fn gsk_texture_scale_node_new(
2856 texture: *mut gdk::GdkTexture,
2857 bounds: *const graphene::graphene_rect_t,
2858 filter: GskScalingFilter,
2859 ) -> *mut GskTextureScaleNode;
2860 #[cfg(feature = "v4_10")]
2861 #[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
2862 pub fn gsk_texture_scale_node_get_filter(node: *const GskTextureScaleNode) -> GskScalingFilter;
2863 #[cfg(feature = "v4_24")]
2864 #[cfg_attr(docsrs, doc(cfg(feature = "v4_24")))]
2865 pub fn gsk_texture_scale_node_get_snap(node: *const GskTextureScaleNode) -> GskRectSnap;
2866 #[cfg(feature = "v4_10")]
2867 #[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
2868 pub fn gsk_texture_scale_node_get_texture(
2869 node: *const GskTextureScaleNode,
2870 ) -> *mut gdk::GdkTexture;
2871
2872 pub fn gsk_transform_node_get_type() -> GType;
2876 pub fn gsk_transform_node_new(
2877 child: *mut GskRenderNode,
2878 transform: *mut GskTransform,
2879 ) -> *mut GskTransformNode;
2880 pub fn gsk_transform_node_get_child(node: *const GskTransformNode) -> *mut GskRenderNode;
2881 pub fn gsk_transform_node_get_transform(node: *const GskTransformNode) -> *mut GskTransform;
2882
2883 #[cfg(feature = "vulkan")]
2887 #[cfg_attr(docsrs, doc(cfg(feature = "vulkan")))]
2888 pub fn gsk_vulkan_renderer_get_type() -> GType;
2889 #[cfg(feature = "vulkan")]
2890 #[cfg_attr(docsrs, doc(cfg(feature = "vulkan")))]
2891 pub fn gsk_vulkan_renderer_new() -> *mut GskRenderer;
2892
2893 #[cfg(feature = "v4_24")]
2897 #[cfg_attr(docsrs, doc(cfg(feature = "v4_24")))]
2898 pub fn gsk_rect_snap_get_direction(snap: GskRectSnap, side: GskSide) -> GskSnapDirection;
2899 #[cfg(feature = "v4_24")]
2900 #[cfg_attr(docsrs, doc(cfg(feature = "v4_24")))]
2901 pub fn gsk_rect_snap_new(
2902 top: GskSnapDirection,
2903 right: GskSnapDirection,
2904 bottom: GskSnapDirection,
2905 left: GskSnapDirection,
2906 ) -> GskRectSnap;
2907 #[cfg(feature = "v4_6")]
2908 #[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
2909 pub fn gsk_value_dup_render_node(value: *const gobject::GValue) -> *mut GskRenderNode;
2910 #[cfg(feature = "v4_6")]
2911 #[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
2912 pub fn gsk_value_get_render_node(value: *const gobject::GValue) -> *mut GskRenderNode;
2913 #[cfg(feature = "v4_6")]
2914 #[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
2915 pub fn gsk_value_set_render_node(value: *mut gobject::GValue, node: *mut GskRenderNode);
2916 #[cfg(feature = "v4_6")]
2917 #[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
2918 pub fn gsk_value_take_render_node(value: *mut gobject::GValue, node: *mut GskRenderNode);
2919
2920}