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