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 GskRenderNodeType = c_int;
110pub const GSK_NOT_A_RENDER_NODE: GskRenderNodeType = 0;
111pub const GSK_CONTAINER_NODE: GskRenderNodeType = 1;
112pub const GSK_CAIRO_NODE: GskRenderNodeType = 2;
113pub const GSK_COLOR_NODE: GskRenderNodeType = 3;
114pub const GSK_LINEAR_GRADIENT_NODE: GskRenderNodeType = 4;
115pub const GSK_REPEATING_LINEAR_GRADIENT_NODE: GskRenderNodeType = 5;
116pub const GSK_RADIAL_GRADIENT_NODE: GskRenderNodeType = 6;
117pub const GSK_REPEATING_RADIAL_GRADIENT_NODE: GskRenderNodeType = 7;
118pub const GSK_CONIC_GRADIENT_NODE: GskRenderNodeType = 8;
119pub const GSK_BORDER_NODE: GskRenderNodeType = 9;
120pub const GSK_TEXTURE_NODE: GskRenderNodeType = 10;
121pub const GSK_INSET_SHADOW_NODE: GskRenderNodeType = 11;
122pub const GSK_OUTSET_SHADOW_NODE: GskRenderNodeType = 12;
123pub const GSK_TRANSFORM_NODE: GskRenderNodeType = 13;
124pub const GSK_OPACITY_NODE: GskRenderNodeType = 14;
125pub const GSK_COLOR_MATRIX_NODE: GskRenderNodeType = 15;
126pub const GSK_REPEAT_NODE: GskRenderNodeType = 16;
127pub const GSK_CLIP_NODE: GskRenderNodeType = 17;
128pub const GSK_ROUNDED_CLIP_NODE: GskRenderNodeType = 18;
129pub const GSK_SHADOW_NODE: GskRenderNodeType = 19;
130pub const GSK_BLEND_NODE: GskRenderNodeType = 20;
131pub const GSK_CROSS_FADE_NODE: GskRenderNodeType = 21;
132pub const GSK_TEXT_NODE: GskRenderNodeType = 22;
133pub const GSK_BLUR_NODE: GskRenderNodeType = 23;
134pub const GSK_DEBUG_NODE: GskRenderNodeType = 24;
135pub const GSK_GL_SHADER_NODE: GskRenderNodeType = 25;
136#[cfg(feature = "v4_10")]
137#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
138pub const GSK_TEXTURE_SCALE_NODE: GskRenderNodeType = 26;
139#[cfg(feature = "v4_10")]
140#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
141pub const GSK_MASK_NODE: GskRenderNodeType = 27;
142#[cfg(feature = "v4_14")]
143#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
144pub const GSK_FILL_NODE: GskRenderNodeType = 28;
145#[cfg(feature = "v4_14")]
146#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
147pub const GSK_STROKE_NODE: GskRenderNodeType = 29;
148#[cfg(feature = "v4_14")]
149#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
150pub const GSK_SUBSURFACE_NODE: GskRenderNodeType = 30;
151#[cfg(feature = "v4_20")]
152#[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
153pub const GSK_COMPONENT_TRANSFER_NODE: GskRenderNodeType = 31;
154
155pub type GskScalingFilter = c_int;
156pub const GSK_SCALING_FILTER_LINEAR: GskScalingFilter = 0;
157pub const GSK_SCALING_FILTER_NEAREST: GskScalingFilter = 1;
158pub const GSK_SCALING_FILTER_TRILINEAR: GskScalingFilter = 2;
159
160pub type GskSerializationError = c_int;
161pub const GSK_SERIALIZATION_UNSUPPORTED_FORMAT: GskSerializationError = 0;
162pub const GSK_SERIALIZATION_UNSUPPORTED_VERSION: GskSerializationError = 1;
163pub const GSK_SERIALIZATION_INVALID_DATA: GskSerializationError = 2;
164
165pub type GskTransformCategory = c_int;
166pub const GSK_TRANSFORM_CATEGORY_UNKNOWN: GskTransformCategory = 0;
167pub const GSK_TRANSFORM_CATEGORY_ANY: GskTransformCategory = 1;
168pub const GSK_TRANSFORM_CATEGORY_3D: GskTransformCategory = 2;
169pub const GSK_TRANSFORM_CATEGORY_2D: GskTransformCategory = 3;
170pub const GSK_TRANSFORM_CATEGORY_2D_AFFINE: GskTransformCategory = 4;
171pub const GSK_TRANSFORM_CATEGORY_2D_TRANSLATE: GskTransformCategory = 5;
172pub const GSK_TRANSFORM_CATEGORY_IDENTITY: GskTransformCategory = 6;
173
174pub type GskPathForeachFlags = c_uint;
176pub const GSK_PATH_FOREACH_ALLOW_ONLY_LINES: GskPathForeachFlags = 0;
177pub const GSK_PATH_FOREACH_ALLOW_QUAD: GskPathForeachFlags = 1;
178pub const GSK_PATH_FOREACH_ALLOW_CUBIC: GskPathForeachFlags = 2;
179pub const GSK_PATH_FOREACH_ALLOW_CONIC: GskPathForeachFlags = 4;
180
181#[derive(Copy, Clone)]
183#[repr(C)]
184pub union GskPathPoint_u1 {
185 pub s1: GskPathPoint__s1,
186 pub padding: [gpointer; 8],
187 pub alignment: graphene::graphene_vec4_t,
188}
189
190impl ::std::fmt::Debug for GskPathPoint_u1 {
191 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
192 f.debug_struct(&format!("GskPathPoint_u1 @ {self:p}"))
193 .field("s1", unsafe { &self.s1 })
194 .field("padding", unsafe { &self.padding })
195 .field("alignment", unsafe { &self.alignment })
196 .finish()
197 }
198}
199
200pub type GskParseErrorFunc = Option<
202 unsafe extern "C" fn(
203 *const GskParseLocation,
204 *const GskParseLocation,
205 *const glib::GError,
206 gpointer,
207 ),
208>;
209pub type GskPathForeachFunc = Option<
210 unsafe extern "C" fn(
211 GskPathOperation,
212 *const graphene::graphene_point_t,
213 size_t,
214 c_float,
215 gpointer,
216 ) -> gboolean,
217>;
218pub type GskPathIntersectionFunc = Option<
219 unsafe extern "C" fn(
220 *mut GskPath,
221 *const GskPathPoint,
222 *mut GskPath,
223 *const GskPathPoint,
224 GskPathIntersection,
225 gpointer,
226 ) -> gboolean,
227>;
228
229#[cfg(feature = "broadway")]
231#[cfg_attr(docsrs, doc(cfg(feature = "broadway")))]
232#[repr(C)]
233#[allow(dead_code)]
234pub struct _GskBroadwayRendererClass {
235 _data: [u8; 0],
236 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
237}
238
239#[cfg(feature = "broadway")]
240#[cfg_attr(docsrs, doc(cfg(feature = "broadway")))]
241pub type GskBroadwayRendererClass = _GskBroadwayRendererClass;
242
243#[repr(C)]
244#[allow(dead_code)]
245pub struct _GskCairoRendererClass {
246 _data: [u8; 0],
247 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
248}
249
250pub type GskCairoRendererClass = _GskCairoRendererClass;
251
252#[derive(Copy, Clone)]
253#[repr(C)]
254pub struct GskColorStop {
255 pub offset: c_float,
256 pub color: gdk::GdkRGBA,
257}
258
259impl ::std::fmt::Debug for GskColorStop {
260 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
261 f.debug_struct(&format!("GskColorStop @ {self:p}"))
262 .field("offset", &self.offset)
263 .field("color", &self.color)
264 .finish()
265 }
266}
267
268#[repr(C)]
269#[allow(dead_code)]
270pub struct GskComponentTransfer {
271 _data: [u8; 0],
272 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
273}
274
275impl ::std::fmt::Debug for GskComponentTransfer {
276 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
277 f.debug_struct(&format!("GskComponentTransfer @ {self:p}"))
278 .finish()
279 }
280}
281
282#[repr(C)]
283#[allow(dead_code)]
284pub struct _GskGLRendererClass {
285 _data: [u8; 0],
286 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
287}
288
289pub type GskGLRendererClass = _GskGLRendererClass;
290
291#[derive(Copy, Clone)]
292#[repr(C)]
293pub struct GskGLShaderClass {
294 pub parent_class: gobject::GObjectClass,
295}
296
297impl ::std::fmt::Debug for GskGLShaderClass {
298 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
299 f.debug_struct(&format!("GskGLShaderClass @ {self:p}"))
300 .field("parent_class", &self.parent_class)
301 .finish()
302 }
303}
304
305#[derive(Copy, Clone)]
306#[repr(C)]
307pub struct GskParseLocation {
308 pub bytes: size_t,
309 pub chars: size_t,
310 pub lines: size_t,
311 pub line_bytes: size_t,
312 pub line_chars: size_t,
313}
314
315impl ::std::fmt::Debug for GskParseLocation {
316 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
317 f.debug_struct(&format!("GskParseLocation @ {self:p}"))
318 .field("bytes", &self.bytes)
319 .field("chars", &self.chars)
320 .field("lines", &self.lines)
321 .field("line_bytes", &self.line_bytes)
322 .field("line_chars", &self.line_chars)
323 .finish()
324 }
325}
326
327#[repr(C)]
328#[allow(dead_code)]
329pub struct GskPath {
330 _data: [u8; 0],
331 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
332}
333
334impl ::std::fmt::Debug for GskPath {
335 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
336 f.debug_struct(&format!("GskPath @ {self:p}")).finish()
337 }
338}
339
340#[repr(C)]
341#[allow(dead_code)]
342pub struct GskPathBuilder {
343 _data: [u8; 0],
344 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
345}
346
347impl ::std::fmt::Debug for GskPathBuilder {
348 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
349 f.debug_struct(&format!("GskPathBuilder @ {self:p}"))
350 .finish()
351 }
352}
353
354#[repr(C)]
355#[allow(dead_code)]
356pub struct GskPathMeasure {
357 _data: [u8; 0],
358 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
359}
360
361impl ::std::fmt::Debug for GskPathMeasure {
362 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
363 f.debug_struct(&format!("GskPathMeasure @ {self:p}"))
364 .finish()
365 }
366}
367
368#[derive(Copy, Clone)]
369#[repr(C)]
370pub struct GskPathPoint {
371 pub u1: GskPathPoint_u1,
372}
373
374impl ::std::fmt::Debug for GskPathPoint {
375 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
376 f.debug_struct(&format!("GskPathPoint @ {self:p}"))
377 .field("u1", &self.u1)
378 .finish()
379 }
380}
381
382#[derive(Copy, Clone)]
383#[repr(C)]
384pub struct GskPathPoint__s1 {
385 pub contour: size_t,
386 pub idx: size_t,
387 pub t: c_float,
388}
389
390impl ::std::fmt::Debug for GskPathPoint__s1 {
391 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
392 f.debug_struct(&format!("GskPathPoint__s1 @ {self:p}"))
393 .field("contour", &self.contour)
394 .field("idx", &self.idx)
395 .field("t", &self.t)
396 .finish()
397 }
398}
399
400#[repr(C)]
401#[allow(dead_code)]
402pub struct _GskRendererClass {
403 _data: [u8; 0],
404 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
405}
406
407pub type GskRendererClass = _GskRendererClass;
408
409#[derive(Copy, Clone)]
410#[repr(C)]
411pub struct GskRoundedRect {
412 pub bounds: graphene::graphene_rect_t,
413 pub corner: [graphene::graphene_size_t; 4],
414}
415
416impl ::std::fmt::Debug for GskRoundedRect {
417 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
418 f.debug_struct(&format!("GskRoundedRect @ {self:p}"))
419 .field("bounds", &self.bounds)
420 .field("corner", &self.corner)
421 .finish()
422 }
423}
424
425#[repr(C)]
426#[allow(dead_code)]
427pub struct GskShaderArgsBuilder {
428 _data: [u8; 0],
429 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
430}
431
432impl ::std::fmt::Debug for GskShaderArgsBuilder {
433 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
434 f.debug_struct(&format!("GskShaderArgsBuilder @ {self:p}"))
435 .finish()
436 }
437}
438
439#[derive(Copy, Clone)]
440#[repr(C)]
441pub struct GskShadow {
442 pub color: gdk::GdkRGBA,
443 pub dx: c_float,
444 pub dy: c_float,
445 pub radius: c_float,
446}
447
448impl ::std::fmt::Debug for GskShadow {
449 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
450 f.debug_struct(&format!("GskShadow @ {self:p}"))
451 .field("color", &self.color)
452 .field("dx", &self.dx)
453 .field("dy", &self.dy)
454 .field("radius", &self.radius)
455 .finish()
456 }
457}
458
459#[repr(C)]
460#[allow(dead_code)]
461pub struct GskStroke {
462 _data: [u8; 0],
463 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
464}
465
466impl ::std::fmt::Debug for GskStroke {
467 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
468 f.debug_struct(&format!("GskStroke @ {self:p}")).finish()
469 }
470}
471
472#[repr(C)]
473#[allow(dead_code)]
474pub struct GskTransform {
475 _data: [u8; 0],
476 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
477}
478
479impl ::std::fmt::Debug for GskTransform {
480 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
481 f.debug_struct(&format!("GskTransform @ {self:p}")).finish()
482 }
483}
484
485#[cfg(feature = "vulkan")]
486#[cfg_attr(docsrs, doc(cfg(feature = "vulkan")))]
487#[repr(C)]
488#[allow(dead_code)]
489pub struct _GskVulkanRendererClass {
490 _data: [u8; 0],
491 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
492}
493
494#[cfg(feature = "vulkan")]
495#[cfg_attr(docsrs, doc(cfg(feature = "vulkan")))]
496pub type GskVulkanRendererClass = _GskVulkanRendererClass;
497
498#[repr(C)]
500#[allow(dead_code)]
501pub struct GskBlendNode {
502 _data: [u8; 0],
503 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
504}
505
506impl ::std::fmt::Debug for GskBlendNode {
507 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
508 f.debug_struct(&format!("GskBlendNode @ {self:p}")).finish()
509 }
510}
511
512#[repr(C)]
513#[allow(dead_code)]
514pub struct GskBlurNode {
515 _data: [u8; 0],
516 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
517}
518
519impl ::std::fmt::Debug for GskBlurNode {
520 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
521 f.debug_struct(&format!("GskBlurNode @ {self:p}")).finish()
522 }
523}
524
525#[repr(C)]
526#[allow(dead_code)]
527pub struct GskBorderNode {
528 _data: [u8; 0],
529 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
530}
531
532impl ::std::fmt::Debug for GskBorderNode {
533 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
534 f.debug_struct(&format!("GskBorderNode @ {self:p}"))
535 .finish()
536 }
537}
538
539#[cfg(feature = "broadway")]
540#[cfg_attr(docsrs, doc(cfg(feature = "broadway")))]
541#[repr(C)]
542#[allow(dead_code)]
543pub struct GskBroadwayRenderer {
544 _data: [u8; 0],
545 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
546}
547
548#[cfg(feature = "broadway")]
549#[cfg_attr(docsrs, doc(cfg(feature = "broadway")))]
550impl ::std::fmt::Debug for GskBroadwayRenderer {
551 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
552 f.debug_struct(&format!("GskBroadwayRenderer @ {self:p}"))
553 .finish()
554 }
555}
556
557#[repr(C)]
558#[allow(dead_code)]
559pub struct GskCairoNode {
560 _data: [u8; 0],
561 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
562}
563
564impl ::std::fmt::Debug for GskCairoNode {
565 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
566 f.debug_struct(&format!("GskCairoNode @ {self:p}")).finish()
567 }
568}
569
570#[repr(C)]
571#[allow(dead_code)]
572pub struct GskCairoRenderer {
573 _data: [u8; 0],
574 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
575}
576
577impl ::std::fmt::Debug for GskCairoRenderer {
578 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
579 f.debug_struct(&format!("GskCairoRenderer @ {self:p}"))
580 .finish()
581 }
582}
583
584#[repr(C)]
585#[allow(dead_code)]
586pub struct GskClipNode {
587 _data: [u8; 0],
588 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
589}
590
591impl ::std::fmt::Debug for GskClipNode {
592 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
593 f.debug_struct(&format!("GskClipNode @ {self:p}")).finish()
594 }
595}
596
597#[repr(C)]
598#[allow(dead_code)]
599pub struct GskColorMatrixNode {
600 _data: [u8; 0],
601 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
602}
603
604impl ::std::fmt::Debug for GskColorMatrixNode {
605 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
606 f.debug_struct(&format!("GskColorMatrixNode @ {self:p}"))
607 .finish()
608 }
609}
610
611#[repr(C)]
612#[allow(dead_code)]
613pub struct GskColorNode {
614 _data: [u8; 0],
615 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
616}
617
618impl ::std::fmt::Debug for GskColorNode {
619 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
620 f.debug_struct(&format!("GskColorNode @ {self:p}")).finish()
621 }
622}
623
624#[repr(C)]
625#[allow(dead_code)]
626pub struct GskComponentTransferNode {
627 _data: [u8; 0],
628 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
629}
630
631impl ::std::fmt::Debug for GskComponentTransferNode {
632 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
633 f.debug_struct(&format!("GskComponentTransferNode @ {self:p}"))
634 .finish()
635 }
636}
637
638#[repr(C)]
639#[allow(dead_code)]
640pub struct GskConicGradientNode {
641 _data: [u8; 0],
642 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
643}
644
645impl ::std::fmt::Debug for GskConicGradientNode {
646 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
647 f.debug_struct(&format!("GskConicGradientNode @ {self:p}"))
648 .finish()
649 }
650}
651
652#[repr(C)]
653#[allow(dead_code)]
654pub struct GskContainerNode {
655 _data: [u8; 0],
656 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
657}
658
659impl ::std::fmt::Debug for GskContainerNode {
660 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
661 f.debug_struct(&format!("GskContainerNode @ {self:p}"))
662 .finish()
663 }
664}
665
666#[repr(C)]
667#[allow(dead_code)]
668pub struct GskCrossFadeNode {
669 _data: [u8; 0],
670 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
671}
672
673impl ::std::fmt::Debug for GskCrossFadeNode {
674 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
675 f.debug_struct(&format!("GskCrossFadeNode @ {self:p}"))
676 .finish()
677 }
678}
679
680#[repr(C)]
681#[allow(dead_code)]
682pub struct GskDebugNode {
683 _data: [u8; 0],
684 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
685}
686
687impl ::std::fmt::Debug for GskDebugNode {
688 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
689 f.debug_struct(&format!("GskDebugNode @ {self:p}")).finish()
690 }
691}
692
693#[repr(C)]
694#[allow(dead_code)]
695pub struct GskFillNode {
696 _data: [u8; 0],
697 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
698}
699
700impl ::std::fmt::Debug for GskFillNode {
701 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
702 f.debug_struct(&format!("GskFillNode @ {self:p}")).finish()
703 }
704}
705
706#[repr(C)]
707#[allow(dead_code)]
708pub struct GskGLRenderer {
709 _data: [u8; 0],
710 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
711}
712
713impl ::std::fmt::Debug for GskGLRenderer {
714 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
715 f.debug_struct(&format!("GskGLRenderer @ {self:p}"))
716 .finish()
717 }
718}
719
720#[repr(C)]
721#[allow(dead_code)]
722pub struct GskGLShader {
723 _data: [u8; 0],
724 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
725}
726
727impl ::std::fmt::Debug for GskGLShader {
728 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
729 f.debug_struct(&format!("GskGLShader @ {self:p}")).finish()
730 }
731}
732
733#[repr(C)]
734#[allow(dead_code)]
735pub struct GskGLShaderNode {
736 _data: [u8; 0],
737 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
738}
739
740impl ::std::fmt::Debug for GskGLShaderNode {
741 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
742 f.debug_struct(&format!("GskGLShaderNode @ {self:p}"))
743 .finish()
744 }
745}
746
747#[repr(C)]
748#[allow(dead_code)]
749pub struct GskInsetShadowNode {
750 _data: [u8; 0],
751 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
752}
753
754impl ::std::fmt::Debug for GskInsetShadowNode {
755 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
756 f.debug_struct(&format!("GskInsetShadowNode @ {self:p}"))
757 .finish()
758 }
759}
760
761#[repr(C)]
762#[allow(dead_code)]
763pub struct GskLinearGradientNode {
764 _data: [u8; 0],
765 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
766}
767
768impl ::std::fmt::Debug for GskLinearGradientNode {
769 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
770 f.debug_struct(&format!("GskLinearGradientNode @ {self:p}"))
771 .finish()
772 }
773}
774
775#[repr(C)]
776#[allow(dead_code)]
777pub struct GskMaskNode {
778 _data: [u8; 0],
779 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
780}
781
782impl ::std::fmt::Debug for GskMaskNode {
783 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
784 f.debug_struct(&format!("GskMaskNode @ {self:p}")).finish()
785 }
786}
787
788#[repr(C)]
789#[allow(dead_code)]
790pub struct GskNglRenderer {
791 _data: [u8; 0],
792 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
793}
794
795impl ::std::fmt::Debug for GskNglRenderer {
796 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
797 f.debug_struct(&format!("GskNglRenderer @ {self:p}"))
798 .finish()
799 }
800}
801
802#[repr(C)]
803#[allow(dead_code)]
804pub struct GskOpacityNode {
805 _data: [u8; 0],
806 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
807}
808
809impl ::std::fmt::Debug for GskOpacityNode {
810 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
811 f.debug_struct(&format!("GskOpacityNode @ {self:p}"))
812 .finish()
813 }
814}
815
816#[repr(C)]
817#[allow(dead_code)]
818pub struct GskOutsetShadowNode {
819 _data: [u8; 0],
820 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
821}
822
823impl ::std::fmt::Debug for GskOutsetShadowNode {
824 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
825 f.debug_struct(&format!("GskOutsetShadowNode @ {self:p}"))
826 .finish()
827 }
828}
829
830#[repr(C)]
831#[allow(dead_code)]
832pub struct GskRadialGradientNode {
833 _data: [u8; 0],
834 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
835}
836
837impl ::std::fmt::Debug for GskRadialGradientNode {
838 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
839 f.debug_struct(&format!("GskRadialGradientNode @ {self:p}"))
840 .finish()
841 }
842}
843
844#[repr(C)]
845#[allow(dead_code)]
846pub struct GskRenderNode {
847 _data: [u8; 0],
848 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
849}
850
851impl ::std::fmt::Debug for GskRenderNode {
852 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
853 f.debug_struct(&format!("GskRenderNode @ {self:p}"))
854 .finish()
855 }
856}
857
858#[repr(C)]
859#[allow(dead_code)]
860pub struct GskRenderer {
861 _data: [u8; 0],
862 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
863}
864
865impl ::std::fmt::Debug for GskRenderer {
866 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
867 f.debug_struct(&format!("GskRenderer @ {self:p}")).finish()
868 }
869}
870
871#[repr(C)]
872#[allow(dead_code)]
873pub struct GskRepeatNode {
874 _data: [u8; 0],
875 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
876}
877
878impl ::std::fmt::Debug for GskRepeatNode {
879 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
880 f.debug_struct(&format!("GskRepeatNode @ {self:p}"))
881 .finish()
882 }
883}
884
885#[repr(C)]
886#[allow(dead_code)]
887pub struct GskRepeatingLinearGradientNode {
888 _data: [u8; 0],
889 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
890}
891
892impl ::std::fmt::Debug for GskRepeatingLinearGradientNode {
893 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
894 f.debug_struct(&format!("GskRepeatingLinearGradientNode @ {self:p}"))
895 .finish()
896 }
897}
898
899#[repr(C)]
900#[allow(dead_code)]
901pub struct GskRepeatingRadialGradientNode {
902 _data: [u8; 0],
903 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
904}
905
906impl ::std::fmt::Debug for GskRepeatingRadialGradientNode {
907 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
908 f.debug_struct(&format!("GskRepeatingRadialGradientNode @ {self:p}"))
909 .finish()
910 }
911}
912
913#[repr(C)]
914#[allow(dead_code)]
915pub struct GskRoundedClipNode {
916 _data: [u8; 0],
917 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
918}
919
920impl ::std::fmt::Debug for GskRoundedClipNode {
921 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
922 f.debug_struct(&format!("GskRoundedClipNode @ {self:p}"))
923 .finish()
924 }
925}
926
927#[repr(C)]
928#[allow(dead_code)]
929pub struct GskShadowNode {
930 _data: [u8; 0],
931 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
932}
933
934impl ::std::fmt::Debug for GskShadowNode {
935 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
936 f.debug_struct(&format!("GskShadowNode @ {self:p}"))
937 .finish()
938 }
939}
940
941#[repr(C)]
942#[allow(dead_code)]
943pub struct GskStrokeNode {
944 _data: [u8; 0],
945 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
946}
947
948impl ::std::fmt::Debug for GskStrokeNode {
949 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
950 f.debug_struct(&format!("GskStrokeNode @ {self:p}"))
951 .finish()
952 }
953}
954
955#[repr(C)]
956#[allow(dead_code)]
957pub struct GskSubsurfaceNode {
958 _data: [u8; 0],
959 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
960}
961
962impl ::std::fmt::Debug for GskSubsurfaceNode {
963 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
964 f.debug_struct(&format!("GskSubsurfaceNode @ {self:p}"))
965 .finish()
966 }
967}
968
969#[repr(C)]
970#[allow(dead_code)]
971pub struct GskTextNode {
972 _data: [u8; 0],
973 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
974}
975
976impl ::std::fmt::Debug for GskTextNode {
977 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
978 f.debug_struct(&format!("GskTextNode @ {self:p}")).finish()
979 }
980}
981
982#[repr(C)]
983#[allow(dead_code)]
984pub struct GskTextureNode {
985 _data: [u8; 0],
986 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
987}
988
989impl ::std::fmt::Debug for GskTextureNode {
990 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
991 f.debug_struct(&format!("GskTextureNode @ {self:p}"))
992 .finish()
993 }
994}
995
996#[repr(C)]
997#[allow(dead_code)]
998pub struct GskTextureScaleNode {
999 _data: [u8; 0],
1000 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1001}
1002
1003impl ::std::fmt::Debug for GskTextureScaleNode {
1004 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1005 f.debug_struct(&format!("GskTextureScaleNode @ {self:p}"))
1006 .finish()
1007 }
1008}
1009
1010#[repr(C)]
1011#[allow(dead_code)]
1012pub struct GskTransformNode {
1013 _data: [u8; 0],
1014 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1015}
1016
1017impl ::std::fmt::Debug for GskTransformNode {
1018 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1019 f.debug_struct(&format!("GskTransformNode @ {self:p}"))
1020 .finish()
1021 }
1022}
1023
1024#[cfg(feature = "vulkan")]
1025#[cfg_attr(docsrs, doc(cfg(feature = "vulkan")))]
1026#[repr(C)]
1027#[allow(dead_code)]
1028pub struct GskVulkanRenderer {
1029 _data: [u8; 0],
1030 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1031}
1032
1033#[cfg(feature = "vulkan")]
1034#[cfg_attr(docsrs, doc(cfg(feature = "vulkan")))]
1035impl ::std::fmt::Debug for GskVulkanRenderer {
1036 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1037 f.debug_struct(&format!("GskVulkanRenderer @ {self:p}"))
1038 .finish()
1039 }
1040}
1041
1042extern "C" {
1043
1044 pub fn gsk_blend_mode_get_type() -> GType;
1048
1049 pub fn gsk_corner_get_type() -> GType;
1053
1054 #[cfg(feature = "v4_14")]
1058 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1059 pub fn gsk_fill_rule_get_type() -> GType;
1060
1061 pub fn gsk_gl_uniform_type_get_type() -> GType;
1065
1066 #[cfg(feature = "v4_14")]
1070 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1071 pub fn gsk_line_cap_get_type() -> GType;
1072
1073 #[cfg(feature = "v4_14")]
1077 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1078 pub fn gsk_line_join_get_type() -> GType;
1079
1080 #[cfg(feature = "v4_10")]
1084 #[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
1085 pub fn gsk_mask_mode_get_type() -> GType;
1086
1087 #[cfg(feature = "v4_14")]
1091 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1092 pub fn gsk_path_direction_get_type() -> GType;
1093
1094 #[cfg(feature = "v4_20")]
1098 #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
1099 pub fn gsk_path_intersection_get_type() -> GType;
1100
1101 #[cfg(feature = "v4_14")]
1105 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1106 pub fn gsk_path_operation_get_type() -> GType;
1107
1108 pub fn gsk_render_node_type_get_type() -> GType;
1112
1113 pub fn gsk_scaling_filter_get_type() -> GType;
1117
1118 pub fn gsk_serialization_error_get_type() -> GType;
1122 pub fn gsk_serialization_error_quark() -> glib::GQuark;
1123
1124 pub fn gsk_transform_category_get_type() -> GType;
1128
1129 #[cfg(feature = "v4_14")]
1133 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1134 pub fn gsk_path_foreach_flags_get_type() -> GType;
1135
1136 #[cfg(feature = "v4_20")]
1140 #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
1141 pub fn gsk_component_transfer_get_type() -> GType;
1142 #[cfg(feature = "v4_20")]
1143 #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
1144 pub fn gsk_component_transfer_new_discrete(
1145 n: c_uint,
1146 values: *mut c_float,
1147 ) -> *mut GskComponentTransfer;
1148 #[cfg(feature = "v4_20")]
1149 #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
1150 pub fn gsk_component_transfer_new_gamma(
1151 amp: c_float,
1152 exp: c_float,
1153 ofs: c_float,
1154 ) -> *mut GskComponentTransfer;
1155 #[cfg(feature = "v4_20")]
1156 #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
1157 pub fn gsk_component_transfer_new_identity() -> *mut GskComponentTransfer;
1158 #[cfg(feature = "v4_20")]
1159 #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
1160 pub fn gsk_component_transfer_new_levels(n: c_float) -> *mut GskComponentTransfer;
1161 #[cfg(feature = "v4_20")]
1162 #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
1163 pub fn gsk_component_transfer_new_linear(m: c_float, b: c_float) -> *mut GskComponentTransfer;
1164 #[cfg(feature = "v4_20")]
1165 #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
1166 pub fn gsk_component_transfer_new_table(
1167 n: c_uint,
1168 values: *mut c_float,
1169 ) -> *mut GskComponentTransfer;
1170 #[cfg(feature = "v4_20")]
1171 #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
1172 pub fn gsk_component_transfer_copy(
1173 other: *const GskComponentTransfer,
1174 ) -> *mut GskComponentTransfer;
1175 #[cfg(feature = "v4_20")]
1176 #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
1177 pub fn gsk_component_transfer_free(self_: *mut GskComponentTransfer);
1178 #[cfg(feature = "v4_20")]
1179 #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
1180 pub fn gsk_component_transfer_equal(self_: gconstpointer, other: gconstpointer) -> gboolean;
1181
1182 #[cfg(feature = "v4_14")]
1186 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1187 pub fn gsk_path_get_type() -> GType;
1188 #[cfg(feature = "v4_14")]
1189 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1190 pub fn gsk_path_foreach(
1191 self_: *mut GskPath,
1192 flags: GskPathForeachFlags,
1193 func: GskPathForeachFunc,
1194 user_data: gpointer,
1195 ) -> gboolean;
1196 #[cfg(feature = "v4_20")]
1197 #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
1198 pub fn gsk_path_foreach_intersection(
1199 path1: *mut GskPath,
1200 path2: *mut GskPath,
1201 func: GskPathIntersectionFunc,
1202 user_data: gpointer,
1203 ) -> gboolean;
1204 #[cfg(feature = "v4_14")]
1205 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1206 pub fn gsk_path_get_bounds(
1207 self_: *mut GskPath,
1208 bounds: *mut graphene::graphene_rect_t,
1209 ) -> gboolean;
1210 #[cfg(feature = "v4_14")]
1211 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1212 pub fn gsk_path_get_closest_point(
1213 self_: *mut GskPath,
1214 point: *const graphene::graphene_point_t,
1215 threshold: c_float,
1216 result: *mut GskPathPoint,
1217 distance: *mut c_float,
1218 ) -> gboolean;
1219 #[cfg(feature = "v4_14")]
1220 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1221 pub fn gsk_path_get_end_point(self_: *mut GskPath, result: *mut GskPathPoint) -> gboolean;
1222 #[cfg(feature = "v4_14")]
1223 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1224 pub fn gsk_path_get_start_point(self_: *mut GskPath, result: *mut GskPathPoint) -> gboolean;
1225 #[cfg(feature = "v4_14")]
1226 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1227 pub fn gsk_path_get_stroke_bounds(
1228 self_: *mut GskPath,
1229 stroke: *const GskStroke,
1230 bounds: *mut graphene::graphene_rect_t,
1231 ) -> gboolean;
1232 #[cfg(feature = "v4_14")]
1233 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1234 pub fn gsk_path_in_fill(
1235 self_: *mut GskPath,
1236 point: *const graphene::graphene_point_t,
1237 fill_rule: GskFillRule,
1238 ) -> gboolean;
1239 #[cfg(feature = "v4_14")]
1240 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1241 pub fn gsk_path_is_closed(self_: *mut GskPath) -> gboolean;
1242 #[cfg(feature = "v4_14")]
1243 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1244 pub fn gsk_path_is_empty(self_: *mut GskPath) -> gboolean;
1245 #[cfg(feature = "v4_14")]
1246 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1247 pub fn gsk_path_print(self_: *mut GskPath, string: *mut glib::GString);
1248 #[cfg(feature = "v4_14")]
1249 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1250 pub fn gsk_path_ref(self_: *mut GskPath) -> *mut GskPath;
1251 #[cfg(feature = "v4_14")]
1252 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1253 pub fn gsk_path_to_cairo(self_: *mut GskPath, cr: *mut cairo::cairo_t);
1254 #[cfg(feature = "v4_14")]
1255 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1256 pub fn gsk_path_to_string(self_: *mut GskPath) -> *mut c_char;
1257 #[cfg(feature = "v4_14")]
1258 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1259 pub fn gsk_path_unref(self_: *mut GskPath);
1260 #[cfg(feature = "v4_14")]
1261 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1262 pub fn gsk_path_parse(string: *const c_char) -> *mut GskPath;
1263
1264 #[cfg(feature = "v4_14")]
1268 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1269 pub fn gsk_path_builder_get_type() -> GType;
1270 #[cfg(feature = "v4_14")]
1271 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1272 pub fn gsk_path_builder_new() -> *mut GskPathBuilder;
1273 #[cfg(feature = "v4_14")]
1274 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1275 pub fn gsk_path_builder_add_cairo_path(
1276 self_: *mut GskPathBuilder,
1277 path: *const cairo::cairo_path_t,
1278 );
1279 #[cfg(feature = "v4_14")]
1280 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1281 pub fn gsk_path_builder_add_circle(
1282 self_: *mut GskPathBuilder,
1283 center: *const graphene::graphene_point_t,
1284 radius: c_float,
1285 );
1286 #[cfg(feature = "v4_14")]
1287 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1288 pub fn gsk_path_builder_add_layout(self_: *mut GskPathBuilder, layout: *mut pango::PangoLayout);
1289 #[cfg(feature = "v4_14")]
1290 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1291 pub fn gsk_path_builder_add_path(self_: *mut GskPathBuilder, path: *mut GskPath);
1292 #[cfg(feature = "v4_14")]
1293 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1294 pub fn gsk_path_builder_add_rect(
1295 self_: *mut GskPathBuilder,
1296 rect: *const graphene::graphene_rect_t,
1297 );
1298 #[cfg(feature = "v4_14")]
1299 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1300 pub fn gsk_path_builder_add_reverse_path(self_: *mut GskPathBuilder, path: *mut GskPath);
1301 #[cfg(feature = "v4_14")]
1302 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1303 pub fn gsk_path_builder_add_rounded_rect(
1304 self_: *mut GskPathBuilder,
1305 rect: *const GskRoundedRect,
1306 );
1307 #[cfg(feature = "v4_14")]
1308 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1309 pub fn gsk_path_builder_add_segment(
1310 self_: *mut GskPathBuilder,
1311 path: *mut GskPath,
1312 start: *const GskPathPoint,
1313 end: *const GskPathPoint,
1314 );
1315 #[cfg(feature = "v4_14")]
1316 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1317 pub fn gsk_path_builder_arc_to(
1318 self_: *mut GskPathBuilder,
1319 x1: c_float,
1320 y1: c_float,
1321 x2: c_float,
1322 y2: c_float,
1323 );
1324 #[cfg(feature = "v4_14")]
1325 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1326 pub fn gsk_path_builder_close(self_: *mut GskPathBuilder);
1327 #[cfg(feature = "v4_14")]
1328 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1329 pub fn gsk_path_builder_conic_to(
1330 self_: *mut GskPathBuilder,
1331 x1: c_float,
1332 y1: c_float,
1333 x2: c_float,
1334 y2: c_float,
1335 weight: c_float,
1336 );
1337 #[cfg(feature = "v4_14")]
1338 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1339 pub fn gsk_path_builder_cubic_to(
1340 self_: *mut GskPathBuilder,
1341 x1: c_float,
1342 y1: c_float,
1343 x2: c_float,
1344 y2: c_float,
1345 x3: c_float,
1346 y3: c_float,
1347 );
1348 #[cfg(feature = "v4_14")]
1349 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1350 pub fn gsk_path_builder_free_to_path(self_: *mut GskPathBuilder) -> *mut GskPath;
1351 #[cfg(feature = "v4_14")]
1352 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1353 pub fn gsk_path_builder_get_current_point(
1354 self_: *mut GskPathBuilder,
1355 ) -> *const graphene::graphene_point_t;
1356 #[cfg(feature = "v4_14")]
1357 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1358 pub fn gsk_path_builder_html_arc_to(
1359 self_: *mut GskPathBuilder,
1360 x1: c_float,
1361 y1: c_float,
1362 x2: c_float,
1363 y2: c_float,
1364 radius: c_float,
1365 );
1366 #[cfg(feature = "v4_14")]
1367 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1368 pub fn gsk_path_builder_line_to(self_: *mut GskPathBuilder, x: c_float, y: c_float);
1369 #[cfg(feature = "v4_14")]
1370 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1371 pub fn gsk_path_builder_move_to(self_: *mut GskPathBuilder, x: c_float, y: c_float);
1372 #[cfg(feature = "v4_14")]
1373 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1374 pub fn gsk_path_builder_quad_to(
1375 self_: *mut GskPathBuilder,
1376 x1: c_float,
1377 y1: c_float,
1378 x2: c_float,
1379 y2: c_float,
1380 );
1381 #[cfg(feature = "v4_14")]
1382 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1383 pub fn gsk_path_builder_ref(self_: *mut GskPathBuilder) -> *mut GskPathBuilder;
1384 #[cfg(feature = "v4_14")]
1385 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1386 pub fn gsk_path_builder_rel_arc_to(
1387 self_: *mut GskPathBuilder,
1388 x1: c_float,
1389 y1: c_float,
1390 x2: c_float,
1391 y2: c_float,
1392 );
1393 #[cfg(feature = "v4_14")]
1394 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1395 pub fn gsk_path_builder_rel_conic_to(
1396 self_: *mut GskPathBuilder,
1397 x1: c_float,
1398 y1: c_float,
1399 x2: c_float,
1400 y2: c_float,
1401 weight: c_float,
1402 );
1403 #[cfg(feature = "v4_14")]
1404 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1405 pub fn gsk_path_builder_rel_cubic_to(
1406 self_: *mut GskPathBuilder,
1407 x1: c_float,
1408 y1: c_float,
1409 x2: c_float,
1410 y2: c_float,
1411 x3: c_float,
1412 y3: c_float,
1413 );
1414 #[cfg(feature = "v4_14")]
1415 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1416 pub fn gsk_path_builder_rel_html_arc_to(
1417 self_: *mut GskPathBuilder,
1418 x1: c_float,
1419 y1: c_float,
1420 x2: c_float,
1421 y2: c_float,
1422 radius: c_float,
1423 );
1424 #[cfg(feature = "v4_14")]
1425 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1426 pub fn gsk_path_builder_rel_line_to(self_: *mut GskPathBuilder, x: c_float, y: c_float);
1427 #[cfg(feature = "v4_14")]
1428 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1429 pub fn gsk_path_builder_rel_move_to(self_: *mut GskPathBuilder, x: c_float, y: c_float);
1430 #[cfg(feature = "v4_14")]
1431 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1432 pub fn gsk_path_builder_rel_quad_to(
1433 self_: *mut GskPathBuilder,
1434 x1: c_float,
1435 y1: c_float,
1436 x2: c_float,
1437 y2: c_float,
1438 );
1439 #[cfg(feature = "v4_14")]
1440 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1441 pub fn gsk_path_builder_rel_svg_arc_to(
1442 self_: *mut GskPathBuilder,
1443 rx: c_float,
1444 ry: c_float,
1445 x_axis_rotation: c_float,
1446 large_arc: gboolean,
1447 positive_sweep: gboolean,
1448 x: c_float,
1449 y: c_float,
1450 );
1451 #[cfg(feature = "v4_14")]
1452 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1453 pub fn gsk_path_builder_svg_arc_to(
1454 self_: *mut GskPathBuilder,
1455 rx: c_float,
1456 ry: c_float,
1457 x_axis_rotation: c_float,
1458 large_arc: gboolean,
1459 positive_sweep: gboolean,
1460 x: c_float,
1461 y: c_float,
1462 );
1463 #[cfg(feature = "v4_14")]
1464 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1465 pub fn gsk_path_builder_to_path(self_: *mut GskPathBuilder) -> *mut GskPath;
1466 #[cfg(feature = "v4_14")]
1467 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1468 pub fn gsk_path_builder_unref(self_: *mut GskPathBuilder);
1469
1470 #[cfg(feature = "v4_14")]
1474 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1475 pub fn gsk_path_measure_get_type() -> GType;
1476 #[cfg(feature = "v4_14")]
1477 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1478 pub fn gsk_path_measure_new(path: *mut GskPath) -> *mut GskPathMeasure;
1479 #[cfg(feature = "v4_14")]
1480 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1481 pub fn gsk_path_measure_new_with_tolerance(
1482 path: *mut GskPath,
1483 tolerance: c_float,
1484 ) -> *mut GskPathMeasure;
1485 #[cfg(feature = "v4_14")]
1486 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1487 pub fn gsk_path_measure_get_length(self_: *mut GskPathMeasure) -> c_float;
1488 #[cfg(feature = "v4_14")]
1489 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1490 pub fn gsk_path_measure_get_path(self_: *mut GskPathMeasure) -> *mut GskPath;
1491 #[cfg(feature = "v4_14")]
1492 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1493 pub fn gsk_path_measure_get_point(
1494 self_: *mut GskPathMeasure,
1495 distance: c_float,
1496 result: *mut GskPathPoint,
1497 ) -> gboolean;
1498 #[cfg(feature = "v4_14")]
1499 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1500 pub fn gsk_path_measure_get_tolerance(self_: *mut GskPathMeasure) -> c_float;
1501 #[cfg(feature = "v4_14")]
1502 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1503 pub fn gsk_path_measure_ref(self_: *mut GskPathMeasure) -> *mut GskPathMeasure;
1504 #[cfg(feature = "v4_14")]
1505 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1506 pub fn gsk_path_measure_unref(self_: *mut GskPathMeasure);
1507
1508 #[cfg(feature = "v4_14")]
1512 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1513 pub fn gsk_path_point_get_type() -> GType;
1514 #[cfg(feature = "v4_14")]
1515 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1516 pub fn gsk_path_point_compare(
1517 point1: *const GskPathPoint,
1518 point2: *const GskPathPoint,
1519 ) -> c_int;
1520 #[cfg(feature = "v4_14")]
1521 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1522 pub fn gsk_path_point_copy(point: *mut GskPathPoint) -> *mut GskPathPoint;
1523 #[cfg(feature = "v4_14")]
1524 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1525 pub fn gsk_path_point_equal(
1526 point1: *const GskPathPoint,
1527 point2: *const GskPathPoint,
1528 ) -> gboolean;
1529 #[cfg(feature = "v4_14")]
1530 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1531 pub fn gsk_path_point_free(point: *mut GskPathPoint);
1532 #[cfg(feature = "v4_14")]
1533 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1534 pub fn gsk_path_point_get_curvature(
1535 point: *const GskPathPoint,
1536 path: *mut GskPath,
1537 direction: GskPathDirection,
1538 center: *mut graphene::graphene_point_t,
1539 ) -> c_float;
1540 #[cfg(feature = "v4_14")]
1541 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1542 pub fn gsk_path_point_get_distance(
1543 point: *const GskPathPoint,
1544 measure: *mut GskPathMeasure,
1545 ) -> c_float;
1546 #[cfg(feature = "v4_14")]
1547 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1548 pub fn gsk_path_point_get_position(
1549 point: *const GskPathPoint,
1550 path: *mut GskPath,
1551 position: *mut graphene::graphene_point_t,
1552 );
1553 #[cfg(feature = "v4_14")]
1554 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1555 pub fn gsk_path_point_get_rotation(
1556 point: *const GskPathPoint,
1557 path: *mut GskPath,
1558 direction: GskPathDirection,
1559 ) -> c_float;
1560 #[cfg(feature = "v4_14")]
1561 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1562 pub fn gsk_path_point_get_tangent(
1563 point: *const GskPathPoint,
1564 path: *mut GskPath,
1565 direction: GskPathDirection,
1566 tangent: *mut graphene::graphene_vec2_t,
1567 );
1568
1569 pub fn gsk_rounded_rect_contains_point(
1573 self_: *const GskRoundedRect,
1574 point: *const graphene::graphene_point_t,
1575 ) -> gboolean;
1576 pub fn gsk_rounded_rect_contains_rect(
1577 self_: *const GskRoundedRect,
1578 rect: *const graphene::graphene_rect_t,
1579 ) -> gboolean;
1580 pub fn gsk_rounded_rect_init(
1581 self_: *mut GskRoundedRect,
1582 bounds: *const graphene::graphene_rect_t,
1583 top_left: *const graphene::graphene_size_t,
1584 top_right: *const graphene::graphene_size_t,
1585 bottom_right: *const graphene::graphene_size_t,
1586 bottom_left: *const graphene::graphene_size_t,
1587 ) -> *mut GskRoundedRect;
1588 pub fn gsk_rounded_rect_init_copy(
1589 self_: *mut GskRoundedRect,
1590 src: *const GskRoundedRect,
1591 ) -> *mut GskRoundedRect;
1592 pub fn gsk_rounded_rect_init_from_rect(
1593 self_: *mut GskRoundedRect,
1594 bounds: *const graphene::graphene_rect_t,
1595 radius: c_float,
1596 ) -> *mut GskRoundedRect;
1597 pub fn gsk_rounded_rect_intersects_rect(
1598 self_: *const GskRoundedRect,
1599 rect: *const graphene::graphene_rect_t,
1600 ) -> gboolean;
1601 pub fn gsk_rounded_rect_is_rectilinear(self_: *const GskRoundedRect) -> gboolean;
1602 pub fn gsk_rounded_rect_normalize(self_: *mut GskRoundedRect) -> *mut GskRoundedRect;
1603 pub fn gsk_rounded_rect_offset(
1604 self_: *mut GskRoundedRect,
1605 dx: c_float,
1606 dy: c_float,
1607 ) -> *mut GskRoundedRect;
1608 pub fn gsk_rounded_rect_shrink(
1609 self_: *mut GskRoundedRect,
1610 top: c_float,
1611 right: c_float,
1612 bottom: c_float,
1613 left: c_float,
1614 ) -> *mut GskRoundedRect;
1615
1616 pub fn gsk_shader_args_builder_get_type() -> GType;
1620 pub fn gsk_shader_args_builder_new(
1621 shader: *mut GskGLShader,
1622 initial_values: *mut glib::GBytes,
1623 ) -> *mut GskShaderArgsBuilder;
1624 pub fn gsk_shader_args_builder_free_to_args(
1625 builder: *mut GskShaderArgsBuilder,
1626 ) -> *mut glib::GBytes;
1627 pub fn gsk_shader_args_builder_ref(
1628 builder: *mut GskShaderArgsBuilder,
1629 ) -> *mut GskShaderArgsBuilder;
1630 pub fn gsk_shader_args_builder_set_bool(
1631 builder: *mut GskShaderArgsBuilder,
1632 idx: c_int,
1633 value: gboolean,
1634 );
1635 pub fn gsk_shader_args_builder_set_float(
1636 builder: *mut GskShaderArgsBuilder,
1637 idx: c_int,
1638 value: c_float,
1639 );
1640 pub fn gsk_shader_args_builder_set_int(
1641 builder: *mut GskShaderArgsBuilder,
1642 idx: c_int,
1643 value: i32,
1644 );
1645 pub fn gsk_shader_args_builder_set_uint(
1646 builder: *mut GskShaderArgsBuilder,
1647 idx: c_int,
1648 value: u32,
1649 );
1650 pub fn gsk_shader_args_builder_set_vec2(
1651 builder: *mut GskShaderArgsBuilder,
1652 idx: c_int,
1653 value: *const graphene::graphene_vec2_t,
1654 );
1655 pub fn gsk_shader_args_builder_set_vec3(
1656 builder: *mut GskShaderArgsBuilder,
1657 idx: c_int,
1658 value: *const graphene::graphene_vec3_t,
1659 );
1660 pub fn gsk_shader_args_builder_set_vec4(
1661 builder: *mut GskShaderArgsBuilder,
1662 idx: c_int,
1663 value: *const graphene::graphene_vec4_t,
1664 );
1665 pub fn gsk_shader_args_builder_to_args(builder: *mut GskShaderArgsBuilder)
1666 -> *mut glib::GBytes;
1667 pub fn gsk_shader_args_builder_unref(builder: *mut GskShaderArgsBuilder);
1668
1669 #[cfg(feature = "v4_14")]
1673 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1674 pub fn gsk_stroke_get_type() -> GType;
1675 #[cfg(feature = "v4_14")]
1676 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1677 pub fn gsk_stroke_new(line_width: c_float) -> *mut GskStroke;
1678 #[cfg(feature = "v4_14")]
1679 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1680 pub fn gsk_stroke_copy(other: *const GskStroke) -> *mut GskStroke;
1681 #[cfg(feature = "v4_14")]
1682 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1683 pub fn gsk_stroke_free(self_: *mut GskStroke);
1684 #[cfg(feature = "v4_14")]
1685 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1686 pub fn gsk_stroke_get_dash(self_: *const GskStroke, n_dash: *mut size_t) -> *const c_float;
1687 #[cfg(feature = "v4_14")]
1688 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1689 pub fn gsk_stroke_get_dash_offset(self_: *const GskStroke) -> c_float;
1690 #[cfg(feature = "v4_14")]
1691 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1692 pub fn gsk_stroke_get_line_cap(self_: *const GskStroke) -> GskLineCap;
1693 #[cfg(feature = "v4_14")]
1694 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1695 pub fn gsk_stroke_get_line_join(self_: *const GskStroke) -> GskLineJoin;
1696 #[cfg(feature = "v4_14")]
1697 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1698 pub fn gsk_stroke_get_line_width(self_: *const GskStroke) -> c_float;
1699 #[cfg(feature = "v4_14")]
1700 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1701 pub fn gsk_stroke_get_miter_limit(self_: *const GskStroke) -> c_float;
1702 #[cfg(feature = "v4_14")]
1703 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1704 pub fn gsk_stroke_set_dash(self_: *mut GskStroke, dash: *const c_float, n_dash: size_t);
1705 #[cfg(feature = "v4_14")]
1706 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1707 pub fn gsk_stroke_set_dash_offset(self_: *mut GskStroke, offset: c_float);
1708 #[cfg(feature = "v4_14")]
1709 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1710 pub fn gsk_stroke_set_line_cap(self_: *mut GskStroke, line_cap: GskLineCap);
1711 #[cfg(feature = "v4_14")]
1712 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1713 pub fn gsk_stroke_set_line_join(self_: *mut GskStroke, line_join: GskLineJoin);
1714 #[cfg(feature = "v4_14")]
1715 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1716 pub fn gsk_stroke_set_line_width(self_: *mut GskStroke, line_width: c_float);
1717 #[cfg(feature = "v4_14")]
1718 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1719 pub fn gsk_stroke_set_miter_limit(self_: *mut GskStroke, limit: c_float);
1720 #[cfg(feature = "v4_14")]
1721 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1722 pub fn gsk_stroke_to_cairo(self_: *const GskStroke, cr: *mut cairo::cairo_t);
1723 #[cfg(feature = "v4_14")]
1724 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1725 pub fn gsk_stroke_equal(stroke1: gconstpointer, stroke2: gconstpointer) -> gboolean;
1726
1727 pub fn gsk_transform_get_type() -> GType;
1731 pub fn gsk_transform_new() -> *mut GskTransform;
1732 pub fn gsk_transform_equal(first: *mut GskTransform, second: *mut GskTransform) -> gboolean;
1733 pub fn gsk_transform_get_category(self_: *mut GskTransform) -> GskTransformCategory;
1734 pub fn gsk_transform_invert(self_: *mut GskTransform) -> *mut GskTransform;
1735 pub fn gsk_transform_matrix(
1736 next: *mut GskTransform,
1737 matrix: *const graphene::graphene_matrix_t,
1738 ) -> *mut GskTransform;
1739 #[cfg(feature = "v4_20")]
1740 #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
1741 pub fn gsk_transform_matrix_2d(
1742 next: *mut GskTransform,
1743 xx: c_float,
1744 yx: c_float,
1745 xy: c_float,
1746 yy: c_float,
1747 dx: c_float,
1748 dy: c_float,
1749 ) -> *mut GskTransform;
1750 pub fn gsk_transform_perspective(next: *mut GskTransform, depth: c_float) -> *mut GskTransform;
1751 pub fn gsk_transform_print(self_: *mut GskTransform, string: *mut glib::GString);
1752 pub fn gsk_transform_ref(self_: *mut GskTransform) -> *mut GskTransform;
1753 pub fn gsk_transform_rotate(next: *mut GskTransform, angle: c_float) -> *mut GskTransform;
1754 pub fn gsk_transform_rotate_3d(
1755 next: *mut GskTransform,
1756 angle: c_float,
1757 axis: *const graphene::graphene_vec3_t,
1758 ) -> *mut GskTransform;
1759 pub fn gsk_transform_scale(
1760 next: *mut GskTransform,
1761 factor_x: c_float,
1762 factor_y: c_float,
1763 ) -> *mut GskTransform;
1764 pub fn gsk_transform_scale_3d(
1765 next: *mut GskTransform,
1766 factor_x: c_float,
1767 factor_y: c_float,
1768 factor_z: c_float,
1769 ) -> *mut GskTransform;
1770 #[cfg(feature = "v4_6")]
1771 #[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
1772 pub fn gsk_transform_skew(
1773 next: *mut GskTransform,
1774 skew_x: c_float,
1775 skew_y: c_float,
1776 ) -> *mut GskTransform;
1777 pub fn gsk_transform_to_2d(
1778 self_: *mut GskTransform,
1779 out_xx: *mut c_float,
1780 out_yx: *mut c_float,
1781 out_xy: *mut c_float,
1782 out_yy: *mut c_float,
1783 out_dx: *mut c_float,
1784 out_dy: *mut c_float,
1785 );
1786 #[cfg(feature = "v4_6")]
1787 #[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
1788 pub fn gsk_transform_to_2d_components(
1789 self_: *mut GskTransform,
1790 out_skew_x: *mut c_float,
1791 out_skew_y: *mut c_float,
1792 out_scale_x: *mut c_float,
1793 out_scale_y: *mut c_float,
1794 out_angle: *mut c_float,
1795 out_dx: *mut c_float,
1796 out_dy: *mut c_float,
1797 );
1798 pub fn gsk_transform_to_affine(
1799 self_: *mut GskTransform,
1800 out_scale_x: *mut c_float,
1801 out_scale_y: *mut c_float,
1802 out_dx: *mut c_float,
1803 out_dy: *mut c_float,
1804 );
1805 pub fn gsk_transform_to_matrix(
1806 self_: *mut GskTransform,
1807 out_matrix: *mut graphene::graphene_matrix_t,
1808 );
1809 pub fn gsk_transform_to_string(self_: *mut GskTransform) -> *mut c_char;
1810 pub fn gsk_transform_to_translate(
1811 self_: *mut GskTransform,
1812 out_dx: *mut c_float,
1813 out_dy: *mut c_float,
1814 );
1815 pub fn gsk_transform_transform(
1816 next: *mut GskTransform,
1817 other: *mut GskTransform,
1818 ) -> *mut GskTransform;
1819 pub fn gsk_transform_transform_bounds(
1820 self_: *mut GskTransform,
1821 rect: *const graphene::graphene_rect_t,
1822 out_rect: *mut graphene::graphene_rect_t,
1823 );
1824 pub fn gsk_transform_transform_point(
1825 self_: *mut GskTransform,
1826 point: *const graphene::graphene_point_t,
1827 out_point: *mut graphene::graphene_point_t,
1828 );
1829 pub fn gsk_transform_translate(
1830 next: *mut GskTransform,
1831 point: *const graphene::graphene_point_t,
1832 ) -> *mut GskTransform;
1833 pub fn gsk_transform_translate_3d(
1834 next: *mut GskTransform,
1835 point: *const graphene::graphene_point3d_t,
1836 ) -> *mut GskTransform;
1837 pub fn gsk_transform_unref(self_: *mut GskTransform);
1838 pub fn gsk_transform_parse(
1839 string: *const c_char,
1840 out_transform: *mut *mut GskTransform,
1841 ) -> gboolean;
1842
1843 pub fn gsk_blend_node_get_type() -> GType;
1847 pub fn gsk_blend_node_new(
1848 bottom: *mut GskRenderNode,
1849 top: *mut GskRenderNode,
1850 blend_mode: GskBlendMode,
1851 ) -> *mut GskBlendNode;
1852 pub fn gsk_blend_node_get_blend_mode(node: *const GskBlendNode) -> GskBlendMode;
1853 pub fn gsk_blend_node_get_bottom_child(node: *const GskBlendNode) -> *mut GskRenderNode;
1854 pub fn gsk_blend_node_get_top_child(node: *const GskBlendNode) -> *mut GskRenderNode;
1855
1856 pub fn gsk_blur_node_get_type() -> GType;
1860 pub fn gsk_blur_node_new(child: *mut GskRenderNode, radius: c_float) -> *mut GskBlurNode;
1861 pub fn gsk_blur_node_get_child(node: *const GskBlurNode) -> *mut GskRenderNode;
1862 pub fn gsk_blur_node_get_radius(node: *const GskBlurNode) -> c_float;
1863
1864 pub fn gsk_border_node_get_type() -> GType;
1868 pub fn gsk_border_node_new(
1869 outline: *const GskRoundedRect,
1870 border_width: *const [c_float; 4],
1871 border_color: *const [gdk::GdkRGBA; 4],
1872 ) -> *mut GskBorderNode;
1873 pub fn gsk_border_node_get_colors(node: *const GskBorderNode) -> *const [gdk::GdkRGBA; 4];
1874 pub fn gsk_border_node_get_outline(node: *const GskBorderNode) -> *const GskRoundedRect;
1875 pub fn gsk_border_node_get_widths(node: *const GskBorderNode) -> *const [c_float; 4];
1876
1877 #[cfg(feature = "broadway")]
1881 #[cfg_attr(docsrs, doc(cfg(feature = "broadway")))]
1882 pub fn gsk_broadway_renderer_get_type() -> GType;
1883 #[cfg(feature = "broadway")]
1884 #[cfg_attr(docsrs, doc(cfg(feature = "broadway")))]
1885 pub fn gsk_broadway_renderer_new() -> *mut GskRenderer;
1886
1887 pub fn gsk_cairo_node_get_type() -> GType;
1891 pub fn gsk_cairo_node_new(bounds: *const graphene::graphene_rect_t) -> *mut GskCairoNode;
1892 pub fn gsk_cairo_node_get_draw_context(node: *mut GskCairoNode) -> *mut cairo::cairo_t;
1893 pub fn gsk_cairo_node_get_surface(node: *mut GskCairoNode) -> *mut cairo::cairo_surface_t;
1894
1895 pub fn gsk_cairo_renderer_get_type() -> GType;
1899 pub fn gsk_cairo_renderer_new() -> *mut GskRenderer;
1900
1901 pub fn gsk_clip_node_get_type() -> GType;
1905 pub fn gsk_clip_node_new(
1906 child: *mut GskRenderNode,
1907 clip: *const graphene::graphene_rect_t,
1908 ) -> *mut GskClipNode;
1909 pub fn gsk_clip_node_get_child(node: *const GskClipNode) -> *mut GskRenderNode;
1910 pub fn gsk_clip_node_get_clip(node: *const GskClipNode) -> *const graphene::graphene_rect_t;
1911
1912 pub fn gsk_color_matrix_node_get_type() -> GType;
1916 pub fn gsk_color_matrix_node_new(
1917 child: *mut GskRenderNode,
1918 color_matrix: *const graphene::graphene_matrix_t,
1919 color_offset: *const graphene::graphene_vec4_t,
1920 ) -> *mut GskColorMatrixNode;
1921 pub fn gsk_color_matrix_node_get_child(node: *const GskColorMatrixNode) -> *mut GskRenderNode;
1922 pub fn gsk_color_matrix_node_get_color_matrix(
1923 node: *const GskColorMatrixNode,
1924 ) -> *const graphene::graphene_matrix_t;
1925 pub fn gsk_color_matrix_node_get_color_offset(
1926 node: *const GskColorMatrixNode,
1927 ) -> *const graphene::graphene_vec4_t;
1928
1929 pub fn gsk_color_node_get_type() -> GType;
1933 pub fn gsk_color_node_new(
1934 rgba: *const gdk::GdkRGBA,
1935 bounds: *const graphene::graphene_rect_t,
1936 ) -> *mut GskColorNode;
1937 pub fn gsk_color_node_get_color(node: *const GskColorNode) -> *const gdk::GdkRGBA;
1938
1939 #[cfg(feature = "v4_20")]
1943 #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
1944 pub fn gsk_component_transfer_node_get_type() -> GType;
1945 #[cfg(feature = "v4_20")]
1946 #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
1947 pub fn gsk_component_transfer_node_new(
1948 child: *mut GskRenderNode,
1949 r: *const GskComponentTransfer,
1950 g: *const GskComponentTransfer,
1951 b: *const GskComponentTransfer,
1952 a: *const GskComponentTransfer,
1953 ) -> *mut GskComponentTransferNode;
1954 #[cfg(feature = "v4_20")]
1955 #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
1956 pub fn gsk_component_transfer_node_get_child(
1957 node: *const GskComponentTransferNode,
1958 ) -> *mut GskRenderNode;
1959 #[cfg(feature = "v4_20")]
1960 #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
1961 pub fn gsk_component_transfer_node_get_transfer(
1962 node: *const GskComponentTransferNode,
1963 component: c_uint,
1964 ) -> *const GskComponentTransfer;
1965
1966 pub fn gsk_conic_gradient_node_get_type() -> GType;
1970 pub fn gsk_conic_gradient_node_new(
1971 bounds: *const graphene::graphene_rect_t,
1972 center: *const graphene::graphene_point_t,
1973 rotation: c_float,
1974 color_stops: *const GskColorStop,
1975 n_color_stops: size_t,
1976 ) -> *mut GskConicGradientNode;
1977 #[cfg(feature = "v4_2")]
1978 #[cfg_attr(docsrs, doc(cfg(feature = "v4_2")))]
1979 pub fn gsk_conic_gradient_node_get_angle(node: *const GskConicGradientNode) -> c_float;
1980 pub fn gsk_conic_gradient_node_get_center(
1981 node: *const GskConicGradientNode,
1982 ) -> *const graphene::graphene_point_t;
1983 pub fn gsk_conic_gradient_node_get_color_stops(
1984 node: *const GskConicGradientNode,
1985 n_stops: *mut size_t,
1986 ) -> *const GskColorStop;
1987 pub fn gsk_conic_gradient_node_get_n_color_stops(node: *const GskConicGradientNode) -> size_t;
1988 pub fn gsk_conic_gradient_node_get_rotation(node: *const GskConicGradientNode) -> c_float;
1989
1990 pub fn gsk_container_node_get_type() -> GType;
1994 pub fn gsk_container_node_new(
1995 children: *mut *mut GskRenderNode,
1996 n_children: c_uint,
1997 ) -> *mut GskContainerNode;
1998 pub fn gsk_container_node_get_child(
1999 node: *const GskContainerNode,
2000 idx: c_uint,
2001 ) -> *mut GskRenderNode;
2002 pub fn gsk_container_node_get_n_children(node: *const GskContainerNode) -> c_uint;
2003
2004 pub fn gsk_cross_fade_node_get_type() -> GType;
2008 pub fn gsk_cross_fade_node_new(
2009 start: *mut GskRenderNode,
2010 end: *mut GskRenderNode,
2011 progress: c_float,
2012 ) -> *mut GskCrossFadeNode;
2013 pub fn gsk_cross_fade_node_get_end_child(node: *const GskCrossFadeNode) -> *mut GskRenderNode;
2014 pub fn gsk_cross_fade_node_get_progress(node: *const GskCrossFadeNode) -> c_float;
2015 pub fn gsk_cross_fade_node_get_start_child(node: *const GskCrossFadeNode)
2016 -> *mut GskRenderNode;
2017
2018 pub fn gsk_debug_node_get_type() -> GType;
2022 pub fn gsk_debug_node_new(child: *mut GskRenderNode, message: *mut c_char)
2023 -> *mut GskDebugNode;
2024 pub fn gsk_debug_node_get_child(node: *const GskDebugNode) -> *mut GskRenderNode;
2025 pub fn gsk_debug_node_get_message(node: *const GskDebugNode) -> *const c_char;
2026
2027 #[cfg(feature = "v4_14")]
2031 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
2032 pub fn gsk_fill_node_get_type() -> GType;
2033 #[cfg(feature = "v4_14")]
2034 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
2035 pub fn gsk_fill_node_new(
2036 child: *mut GskRenderNode,
2037 path: *mut GskPath,
2038 fill_rule: GskFillRule,
2039 ) -> *mut GskFillNode;
2040 #[cfg(feature = "v4_14")]
2041 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
2042 pub fn gsk_fill_node_get_child(node: *const GskFillNode) -> *mut GskRenderNode;
2043 #[cfg(feature = "v4_14")]
2044 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
2045 pub fn gsk_fill_node_get_fill_rule(node: *const GskFillNode) -> GskFillRule;
2046 #[cfg(feature = "v4_14")]
2047 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
2048 pub fn gsk_fill_node_get_path(node: *const GskFillNode) -> *mut GskPath;
2049
2050 #[cfg(feature = "v4_2")]
2054 #[cfg_attr(docsrs, doc(cfg(feature = "v4_2")))]
2055 pub fn gsk_gl_renderer_get_type() -> GType;
2056 #[cfg(feature = "v4_2")]
2057 #[cfg_attr(docsrs, doc(cfg(feature = "v4_2")))]
2058 pub fn gsk_gl_renderer_new() -> *mut GskRenderer;
2059
2060 pub fn gsk_gl_shader_get_type() -> GType;
2064 pub fn gsk_gl_shader_new_from_bytes(sourcecode: *mut glib::GBytes) -> *mut GskGLShader;
2065 pub fn gsk_gl_shader_new_from_resource(resource_path: *const c_char) -> *mut GskGLShader;
2066 pub fn gsk_gl_shader_compile(
2067 shader: *mut GskGLShader,
2068 renderer: *mut GskRenderer,
2069 error: *mut *mut glib::GError,
2070 ) -> gboolean;
2071 pub fn gsk_gl_shader_find_uniform_by_name(
2072 shader: *mut GskGLShader,
2073 name: *const c_char,
2074 ) -> c_int;
2075 pub fn gsk_gl_shader_format_args(shader: *mut GskGLShader, ...) -> *mut glib::GBytes;
2076 pub fn gsk_gl_shader_get_arg_bool(
2078 shader: *mut GskGLShader,
2079 args: *mut glib::GBytes,
2080 idx: c_int,
2081 ) -> gboolean;
2082 pub fn gsk_gl_shader_get_arg_float(
2083 shader: *mut GskGLShader,
2084 args: *mut glib::GBytes,
2085 idx: c_int,
2086 ) -> c_float;
2087 pub fn gsk_gl_shader_get_arg_int(
2088 shader: *mut GskGLShader,
2089 args: *mut glib::GBytes,
2090 idx: c_int,
2091 ) -> i32;
2092 pub fn gsk_gl_shader_get_arg_uint(
2093 shader: *mut GskGLShader,
2094 args: *mut glib::GBytes,
2095 idx: c_int,
2096 ) -> u32;
2097 pub fn gsk_gl_shader_get_arg_vec2(
2098 shader: *mut GskGLShader,
2099 args: *mut glib::GBytes,
2100 idx: c_int,
2101 out_value: *mut graphene::graphene_vec2_t,
2102 );
2103 pub fn gsk_gl_shader_get_arg_vec3(
2104 shader: *mut GskGLShader,
2105 args: *mut glib::GBytes,
2106 idx: c_int,
2107 out_value: *mut graphene::graphene_vec3_t,
2108 );
2109 pub fn gsk_gl_shader_get_arg_vec4(
2110 shader: *mut GskGLShader,
2111 args: *mut glib::GBytes,
2112 idx: c_int,
2113 out_value: *mut graphene::graphene_vec4_t,
2114 );
2115 pub fn gsk_gl_shader_get_args_size(shader: *mut GskGLShader) -> size_t;
2116 pub fn gsk_gl_shader_get_n_textures(shader: *mut GskGLShader) -> c_int;
2117 pub fn gsk_gl_shader_get_n_uniforms(shader: *mut GskGLShader) -> c_int;
2118 pub fn gsk_gl_shader_get_resource(shader: *mut GskGLShader) -> *const c_char;
2119 pub fn gsk_gl_shader_get_source(shader: *mut GskGLShader) -> *mut glib::GBytes;
2120 pub fn gsk_gl_shader_get_uniform_name(shader: *mut GskGLShader, idx: c_int) -> *const c_char;
2121 pub fn gsk_gl_shader_get_uniform_offset(shader: *mut GskGLShader, idx: c_int) -> c_int;
2122 pub fn gsk_gl_shader_get_uniform_type(shader: *mut GskGLShader, idx: c_int)
2123 -> GskGLUniformType;
2124
2125 pub fn gsk_gl_shader_node_get_type() -> GType;
2129 pub fn gsk_gl_shader_node_new(
2130 shader: *mut GskGLShader,
2131 bounds: *const graphene::graphene_rect_t,
2132 args: *mut glib::GBytes,
2133 children: *mut *mut GskRenderNode,
2134 n_children: c_uint,
2135 ) -> *mut GskGLShaderNode;
2136 pub fn gsk_gl_shader_node_get_args(node: *const GskGLShaderNode) -> *mut glib::GBytes;
2137 pub fn gsk_gl_shader_node_get_child(
2138 node: *const GskGLShaderNode,
2139 idx: c_uint,
2140 ) -> *mut GskRenderNode;
2141 pub fn gsk_gl_shader_node_get_n_children(node: *const GskGLShaderNode) -> c_uint;
2142 pub fn gsk_gl_shader_node_get_shader(node: *const GskGLShaderNode) -> *mut GskGLShader;
2143
2144 pub fn gsk_inset_shadow_node_get_type() -> GType;
2148 pub fn gsk_inset_shadow_node_new(
2149 outline: *const GskRoundedRect,
2150 color: *const gdk::GdkRGBA,
2151 dx: c_float,
2152 dy: c_float,
2153 spread: c_float,
2154 blur_radius: c_float,
2155 ) -> *mut GskInsetShadowNode;
2156 pub fn gsk_inset_shadow_node_get_blur_radius(node: *const GskInsetShadowNode) -> c_float;
2157 pub fn gsk_inset_shadow_node_get_color(node: *const GskInsetShadowNode) -> *const gdk::GdkRGBA;
2158 pub fn gsk_inset_shadow_node_get_dx(node: *const GskInsetShadowNode) -> c_float;
2159 pub fn gsk_inset_shadow_node_get_dy(node: *const GskInsetShadowNode) -> c_float;
2160 pub fn gsk_inset_shadow_node_get_outline(
2161 node: *const GskInsetShadowNode,
2162 ) -> *const GskRoundedRect;
2163 pub fn gsk_inset_shadow_node_get_spread(node: *const GskInsetShadowNode) -> c_float;
2164
2165 pub fn gsk_linear_gradient_node_get_type() -> GType;
2169 pub fn gsk_linear_gradient_node_new(
2170 bounds: *const graphene::graphene_rect_t,
2171 start: *const graphene::graphene_point_t,
2172 end: *const graphene::graphene_point_t,
2173 color_stops: *const GskColorStop,
2174 n_color_stops: size_t,
2175 ) -> *mut GskLinearGradientNode;
2176 pub fn gsk_linear_gradient_node_get_color_stops(
2177 node: *const GskLinearGradientNode,
2178 n_stops: *mut size_t,
2179 ) -> *const GskColorStop;
2180 pub fn gsk_linear_gradient_node_get_end(
2181 node: *const GskLinearGradientNode,
2182 ) -> *const graphene::graphene_point_t;
2183 pub fn gsk_linear_gradient_node_get_n_color_stops(node: *const GskLinearGradientNode)
2184 -> size_t;
2185 pub fn gsk_linear_gradient_node_get_start(
2186 node: *const GskLinearGradientNode,
2187 ) -> *const graphene::graphene_point_t;
2188
2189 #[cfg(feature = "v4_10")]
2193 #[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
2194 pub fn gsk_mask_node_get_type() -> GType;
2195 #[cfg(feature = "v4_10")]
2196 #[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
2197 pub fn gsk_mask_node_new(
2198 source: *mut GskRenderNode,
2199 mask: *mut GskRenderNode,
2200 mask_mode: GskMaskMode,
2201 ) -> *mut GskMaskNode;
2202 #[cfg(feature = "v4_10")]
2203 #[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
2204 pub fn gsk_mask_node_get_mask(node: *const GskMaskNode) -> *mut GskRenderNode;
2205 #[cfg(feature = "v4_10")]
2206 #[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
2207 pub fn gsk_mask_node_get_mask_mode(node: *const GskMaskNode) -> GskMaskMode;
2208 #[cfg(feature = "v4_10")]
2209 #[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
2210 pub fn gsk_mask_node_get_source(node: *const GskMaskNode) -> *mut GskRenderNode;
2211
2212 pub fn gsk_ngl_renderer_get_type() -> GType;
2216 pub fn gsk_ngl_renderer_new() -> *mut GskRenderer;
2217
2218 pub fn gsk_opacity_node_get_type() -> GType;
2222 pub fn gsk_opacity_node_new(child: *mut GskRenderNode, opacity: c_float)
2223 -> *mut GskOpacityNode;
2224 pub fn gsk_opacity_node_get_child(node: *const GskOpacityNode) -> *mut GskRenderNode;
2225 pub fn gsk_opacity_node_get_opacity(node: *const GskOpacityNode) -> c_float;
2226
2227 pub fn gsk_outset_shadow_node_get_type() -> GType;
2231 pub fn gsk_outset_shadow_node_new(
2232 outline: *const GskRoundedRect,
2233 color: *const gdk::GdkRGBA,
2234 dx: c_float,
2235 dy: c_float,
2236 spread: c_float,
2237 blur_radius: c_float,
2238 ) -> *mut GskOutsetShadowNode;
2239 pub fn gsk_outset_shadow_node_get_blur_radius(node: *const GskOutsetShadowNode) -> c_float;
2240 pub fn gsk_outset_shadow_node_get_color(
2241 node: *const GskOutsetShadowNode,
2242 ) -> *const gdk::GdkRGBA;
2243 pub fn gsk_outset_shadow_node_get_dx(node: *const GskOutsetShadowNode) -> c_float;
2244 pub fn gsk_outset_shadow_node_get_dy(node: *const GskOutsetShadowNode) -> c_float;
2245 pub fn gsk_outset_shadow_node_get_outline(
2246 node: *const GskOutsetShadowNode,
2247 ) -> *const GskRoundedRect;
2248 pub fn gsk_outset_shadow_node_get_spread(node: *const GskOutsetShadowNode) -> c_float;
2249
2250 pub fn gsk_radial_gradient_node_get_type() -> GType;
2254 pub fn gsk_radial_gradient_node_new(
2255 bounds: *const graphene::graphene_rect_t,
2256 center: *const graphene::graphene_point_t,
2257 hradius: c_float,
2258 vradius: c_float,
2259 start: c_float,
2260 end: c_float,
2261 color_stops: *const GskColorStop,
2262 n_color_stops: size_t,
2263 ) -> *mut GskRadialGradientNode;
2264 pub fn gsk_radial_gradient_node_get_center(
2265 node: *const GskRadialGradientNode,
2266 ) -> *const graphene::graphene_point_t;
2267 pub fn gsk_radial_gradient_node_get_color_stops(
2268 node: *const GskRadialGradientNode,
2269 n_stops: *mut size_t,
2270 ) -> *const GskColorStop;
2271 pub fn gsk_radial_gradient_node_get_end(node: *const GskRadialGradientNode) -> c_float;
2272 pub fn gsk_radial_gradient_node_get_hradius(node: *const GskRadialGradientNode) -> c_float;
2273 pub fn gsk_radial_gradient_node_get_n_color_stops(node: *const GskRadialGradientNode)
2274 -> size_t;
2275 pub fn gsk_radial_gradient_node_get_start(node: *const GskRadialGradientNode) -> c_float;
2276 pub fn gsk_radial_gradient_node_get_vradius(node: *const GskRadialGradientNode) -> c_float;
2277
2278 pub fn gsk_render_node_get_type() -> GType;
2282 pub fn gsk_render_node_deserialize(
2283 bytes: *mut glib::GBytes,
2284 error_func: GskParseErrorFunc,
2285 user_data: gpointer,
2286 ) -> *mut GskRenderNode;
2287 pub fn gsk_render_node_draw(node: *mut GskRenderNode, cr: *mut cairo::cairo_t);
2288 pub fn gsk_render_node_get_bounds(
2289 node: *mut GskRenderNode,
2290 bounds: *mut graphene::graphene_rect_t,
2291 );
2292 pub fn gsk_render_node_get_node_type(node: *const GskRenderNode) -> GskRenderNodeType;
2293 #[cfg(feature = "v4_16")]
2294 #[cfg_attr(docsrs, doc(cfg(feature = "v4_16")))]
2295 pub fn gsk_render_node_get_opaque_rect(
2296 self_: *mut GskRenderNode,
2297 out_opaque: *mut graphene::graphene_rect_t,
2298 ) -> gboolean;
2299 pub fn gsk_render_node_ref(node: *mut GskRenderNode) -> *mut GskRenderNode;
2300 pub fn gsk_render_node_serialize(node: *mut GskRenderNode) -> *mut glib::GBytes;
2301 pub fn gsk_render_node_unref(node: *mut GskRenderNode);
2302 pub fn gsk_render_node_write_to_file(
2303 node: *mut GskRenderNode,
2304 filename: *const c_char,
2305 error: *mut *mut glib::GError,
2306 ) -> gboolean;
2307
2308 pub fn gsk_renderer_get_type() -> GType;
2312 pub fn gsk_renderer_new_for_surface(surface: *mut gdk::GdkSurface) -> *mut GskRenderer;
2313 pub fn gsk_renderer_get_surface(renderer: *mut GskRenderer) -> *mut gdk::GdkSurface;
2314 pub fn gsk_renderer_is_realized(renderer: *mut GskRenderer) -> gboolean;
2315 pub fn gsk_renderer_realize(
2316 renderer: *mut GskRenderer,
2317 surface: *mut gdk::GdkSurface,
2318 error: *mut *mut glib::GError,
2319 ) -> gboolean;
2320 #[cfg(feature = "v4_14")]
2321 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
2322 pub fn gsk_renderer_realize_for_display(
2323 renderer: *mut GskRenderer,
2324 display: *mut gdk::GdkDisplay,
2325 error: *mut *mut glib::GError,
2326 ) -> gboolean;
2327 pub fn gsk_renderer_render(
2328 renderer: *mut GskRenderer,
2329 root: *mut GskRenderNode,
2330 region: *const cairo::cairo_region_t,
2331 );
2332 pub fn gsk_renderer_render_texture(
2333 renderer: *mut GskRenderer,
2334 root: *mut GskRenderNode,
2335 viewport: *const graphene::graphene_rect_t,
2336 ) -> *mut gdk::GdkTexture;
2337 pub fn gsk_renderer_unrealize(renderer: *mut GskRenderer);
2338
2339 pub fn gsk_repeat_node_get_type() -> GType;
2343 pub fn gsk_repeat_node_new(
2344 bounds: *const graphene::graphene_rect_t,
2345 child: *mut GskRenderNode,
2346 child_bounds: *const graphene::graphene_rect_t,
2347 ) -> *mut GskRepeatNode;
2348 pub fn gsk_repeat_node_get_child(node: *const GskRepeatNode) -> *mut GskRenderNode;
2349 pub fn gsk_repeat_node_get_child_bounds(
2350 node: *const GskRepeatNode,
2351 ) -> *const graphene::graphene_rect_t;
2352
2353 pub fn gsk_repeating_linear_gradient_node_get_type() -> GType;
2357 pub fn gsk_repeating_linear_gradient_node_new(
2358 bounds: *const graphene::graphene_rect_t,
2359 start: *const graphene::graphene_point_t,
2360 end: *const graphene::graphene_point_t,
2361 color_stops: *const GskColorStop,
2362 n_color_stops: size_t,
2363 ) -> *mut GskRepeatingLinearGradientNode;
2364
2365 pub fn gsk_repeating_radial_gradient_node_get_type() -> GType;
2369 pub fn gsk_repeating_radial_gradient_node_new(
2370 bounds: *const graphene::graphene_rect_t,
2371 center: *const graphene::graphene_point_t,
2372 hradius: c_float,
2373 vradius: c_float,
2374 start: c_float,
2375 end: c_float,
2376 color_stops: *const GskColorStop,
2377 n_color_stops: size_t,
2378 ) -> *mut GskRepeatingRadialGradientNode;
2379
2380 pub fn gsk_rounded_clip_node_get_type() -> GType;
2384 pub fn gsk_rounded_clip_node_new(
2385 child: *mut GskRenderNode,
2386 clip: *const GskRoundedRect,
2387 ) -> *mut GskRoundedClipNode;
2388 pub fn gsk_rounded_clip_node_get_child(node: *const GskRoundedClipNode) -> *mut GskRenderNode;
2389 pub fn gsk_rounded_clip_node_get_clip(node: *const GskRoundedClipNode)
2390 -> *const GskRoundedRect;
2391
2392 pub fn gsk_shadow_node_get_type() -> GType;
2396 pub fn gsk_shadow_node_new(
2397 child: *mut GskRenderNode,
2398 shadows: *const GskShadow,
2399 n_shadows: size_t,
2400 ) -> *mut GskShadowNode;
2401 pub fn gsk_shadow_node_get_child(node: *const GskShadowNode) -> *mut GskRenderNode;
2402 pub fn gsk_shadow_node_get_n_shadows(node: *const GskShadowNode) -> size_t;
2403 pub fn gsk_shadow_node_get_shadow(node: *const GskShadowNode, i: size_t) -> *const GskShadow;
2404
2405 #[cfg(feature = "v4_14")]
2409 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
2410 pub fn gsk_stroke_node_get_type() -> GType;
2411 #[cfg(feature = "v4_14")]
2412 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
2413 pub fn gsk_stroke_node_new(
2414 child: *mut GskRenderNode,
2415 path: *mut GskPath,
2416 stroke: *const GskStroke,
2417 ) -> *mut GskStrokeNode;
2418 #[cfg(feature = "v4_14")]
2419 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
2420 pub fn gsk_stroke_node_get_child(node: *const GskStrokeNode) -> *mut GskRenderNode;
2421 #[cfg(feature = "v4_14")]
2422 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
2423 pub fn gsk_stroke_node_get_path(node: *const GskStrokeNode) -> *mut GskPath;
2424 #[cfg(feature = "v4_14")]
2425 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
2426 pub fn gsk_stroke_node_get_stroke(node: *const GskStrokeNode) -> *const GskStroke;
2427
2428 #[cfg(feature = "v4_14")]
2432 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
2433 pub fn gsk_subsurface_node_get_type() -> GType;
2434 #[cfg(feature = "v4_14")]
2435 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
2436 pub fn gsk_subsurface_node_new(
2437 child: *mut GskRenderNode,
2438 subsurface: gpointer,
2439 ) -> *mut GskSubsurfaceNode;
2440 #[cfg(feature = "v4_14")]
2441 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
2442 pub fn gsk_subsurface_node_get_subsurface(node: *const GskDebugNode) -> gpointer;
2443 #[cfg(feature = "v4_14")]
2444 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
2445 pub fn gsk_subsurface_node_get_child(node: *const GskSubsurfaceNode) -> *mut GskRenderNode;
2446
2447 pub fn gsk_text_node_get_type() -> GType;
2451 pub fn gsk_text_node_new(
2452 font: *mut pango::PangoFont,
2453 glyphs: *mut pango::PangoGlyphString,
2454 color: *const gdk::GdkRGBA,
2455 offset: *const graphene::graphene_point_t,
2456 ) -> *mut GskTextNode;
2457 pub fn gsk_text_node_get_color(node: *const GskTextNode) -> *const gdk::GdkRGBA;
2458 pub fn gsk_text_node_get_font(node: *const GskTextNode) -> *mut pango::PangoFont;
2459 pub fn gsk_text_node_get_glyphs(
2460 node: *const GskTextNode,
2461 n_glyphs: *mut c_uint,
2462 ) -> *const pango::PangoGlyphInfo;
2463 pub fn gsk_text_node_get_num_glyphs(node: *const GskTextNode) -> c_uint;
2464 pub fn gsk_text_node_get_offset(node: *const GskTextNode) -> *const graphene::graphene_point_t;
2465 #[cfg(feature = "v4_2")]
2466 #[cfg_attr(docsrs, doc(cfg(feature = "v4_2")))]
2467 pub fn gsk_text_node_has_color_glyphs(node: *const GskTextNode) -> gboolean;
2468
2469 pub fn gsk_texture_node_get_type() -> GType;
2473 pub fn gsk_texture_node_new(
2474 texture: *mut gdk::GdkTexture,
2475 bounds: *const graphene::graphene_rect_t,
2476 ) -> *mut GskTextureNode;
2477 pub fn gsk_texture_node_get_texture(node: *const GskTextureNode) -> *mut gdk::GdkTexture;
2478
2479 #[cfg(feature = "v4_10")]
2483 #[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
2484 pub fn gsk_texture_scale_node_get_type() -> GType;
2485 #[cfg(feature = "v4_10")]
2486 #[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
2487 pub fn gsk_texture_scale_node_new(
2488 texture: *mut gdk::GdkTexture,
2489 bounds: *const graphene::graphene_rect_t,
2490 filter: GskScalingFilter,
2491 ) -> *mut GskTextureScaleNode;
2492 #[cfg(feature = "v4_10")]
2493 #[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
2494 pub fn gsk_texture_scale_node_get_filter(node: *const GskTextureScaleNode) -> GskScalingFilter;
2495 #[cfg(feature = "v4_10")]
2496 #[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
2497 pub fn gsk_texture_scale_node_get_texture(
2498 node: *const GskTextureScaleNode,
2499 ) -> *mut gdk::GdkTexture;
2500
2501 pub fn gsk_transform_node_get_type() -> GType;
2505 pub fn gsk_transform_node_new(
2506 child: *mut GskRenderNode,
2507 transform: *mut GskTransform,
2508 ) -> *mut GskTransformNode;
2509 pub fn gsk_transform_node_get_child(node: *const GskTransformNode) -> *mut GskRenderNode;
2510 pub fn gsk_transform_node_get_transform(node: *const GskTransformNode) -> *mut GskTransform;
2511
2512 #[cfg(feature = "vulkan")]
2516 #[cfg_attr(docsrs, doc(cfg(feature = "vulkan")))]
2517 pub fn gsk_vulkan_renderer_get_type() -> GType;
2518 #[cfg(feature = "vulkan")]
2519 #[cfg_attr(docsrs, doc(cfg(feature = "vulkan")))]
2520 pub fn gsk_vulkan_renderer_new() -> *mut GskRenderer;
2521
2522 #[cfg(feature = "v4_6")]
2526 #[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
2527 pub fn gsk_value_dup_render_node(value: *const gobject::GValue) -> *mut GskRenderNode;
2528 #[cfg(feature = "v4_6")]
2529 #[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
2530 pub fn gsk_value_get_render_node(value: *const gobject::GValue) -> *mut GskRenderNode;
2531 #[cfg(feature = "v4_6")]
2532 #[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
2533 pub fn gsk_value_set_render_node(value: *mut gobject::GValue, node: *mut GskRenderNode);
2534 #[cfg(feature = "v4_6")]
2535 #[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
2536 pub fn gsk_value_take_render_node(value: *mut gobject::GValue, node: *mut GskRenderNode);
2537
2538}