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