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