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