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