1use crate::ffi;
6use glib::{prelude::*, translate::*};
7
8#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
16#[non_exhaustive]
17#[doc(alias = "GskBlendMode")]
18pub enum BlendMode {
19 #[doc(alias = "GSK_BLEND_MODE_DEFAULT")]
21 Default,
22 #[doc(alias = "GSK_BLEND_MODE_MULTIPLY")]
25 Multiply,
26 #[doc(alias = "GSK_BLEND_MODE_SCREEN")]
29 Screen,
30 #[doc(alias = "GSK_BLEND_MODE_OVERLAY")]
33 Overlay,
34 #[doc(alias = "GSK_BLEND_MODE_DARKEN")]
36 Darken,
37 #[doc(alias = "GSK_BLEND_MODE_LIGHTEN")]
39 Lighten,
40 #[doc(alias = "GSK_BLEND_MODE_COLOR_DODGE")]
42 ColorDodge,
43 #[doc(alias = "GSK_BLEND_MODE_COLOR_BURN")]
45 ColorBurn,
46 #[doc(alias = "GSK_BLEND_MODE_HARD_LIGHT")]
48 HardLight,
49 #[doc(alias = "GSK_BLEND_MODE_SOFT_LIGHT")]
51 SoftLight,
52 #[doc(alias = "GSK_BLEND_MODE_DIFFERENCE")]
54 Difference,
55 #[doc(alias = "GSK_BLEND_MODE_EXCLUSION")]
57 Exclusion,
58 #[doc(alias = "GSK_BLEND_MODE_COLOR")]
60 Color,
61 #[doc(alias = "GSK_BLEND_MODE_HUE")]
63 Hue,
64 #[doc(alias = "GSK_BLEND_MODE_SATURATION")]
66 Saturation,
67 #[doc(alias = "GSK_BLEND_MODE_LUMINOSITY")]
69 Luminosity,
70 #[doc(hidden)]
71 __Unknown(i32),
72}
73
74#[doc(hidden)]
75impl IntoGlib for BlendMode {
76 type GlibType = ffi::GskBlendMode;
77
78 fn into_glib(self) -> ffi::GskBlendMode {
79 match self {
80 Self::Default => ffi::GSK_BLEND_MODE_DEFAULT,
81 Self::Multiply => ffi::GSK_BLEND_MODE_MULTIPLY,
82 Self::Screen => ffi::GSK_BLEND_MODE_SCREEN,
83 Self::Overlay => ffi::GSK_BLEND_MODE_OVERLAY,
84 Self::Darken => ffi::GSK_BLEND_MODE_DARKEN,
85 Self::Lighten => ffi::GSK_BLEND_MODE_LIGHTEN,
86 Self::ColorDodge => ffi::GSK_BLEND_MODE_COLOR_DODGE,
87 Self::ColorBurn => ffi::GSK_BLEND_MODE_COLOR_BURN,
88 Self::HardLight => ffi::GSK_BLEND_MODE_HARD_LIGHT,
89 Self::SoftLight => ffi::GSK_BLEND_MODE_SOFT_LIGHT,
90 Self::Difference => ffi::GSK_BLEND_MODE_DIFFERENCE,
91 Self::Exclusion => ffi::GSK_BLEND_MODE_EXCLUSION,
92 Self::Color => ffi::GSK_BLEND_MODE_COLOR,
93 Self::Hue => ffi::GSK_BLEND_MODE_HUE,
94 Self::Saturation => ffi::GSK_BLEND_MODE_SATURATION,
95 Self::Luminosity => ffi::GSK_BLEND_MODE_LUMINOSITY,
96 Self::__Unknown(value) => value,
97 }
98 }
99}
100
101#[doc(hidden)]
102impl FromGlib<ffi::GskBlendMode> for BlendMode {
103 unsafe fn from_glib(value: ffi::GskBlendMode) -> Self {
104 skip_assert_initialized!();
105
106 match value {
107 ffi::GSK_BLEND_MODE_DEFAULT => Self::Default,
108 ffi::GSK_BLEND_MODE_MULTIPLY => Self::Multiply,
109 ffi::GSK_BLEND_MODE_SCREEN => Self::Screen,
110 ffi::GSK_BLEND_MODE_OVERLAY => Self::Overlay,
111 ffi::GSK_BLEND_MODE_DARKEN => Self::Darken,
112 ffi::GSK_BLEND_MODE_LIGHTEN => Self::Lighten,
113 ffi::GSK_BLEND_MODE_COLOR_DODGE => Self::ColorDodge,
114 ffi::GSK_BLEND_MODE_COLOR_BURN => Self::ColorBurn,
115 ffi::GSK_BLEND_MODE_HARD_LIGHT => Self::HardLight,
116 ffi::GSK_BLEND_MODE_SOFT_LIGHT => Self::SoftLight,
117 ffi::GSK_BLEND_MODE_DIFFERENCE => Self::Difference,
118 ffi::GSK_BLEND_MODE_EXCLUSION => Self::Exclusion,
119 ffi::GSK_BLEND_MODE_COLOR => Self::Color,
120 ffi::GSK_BLEND_MODE_HUE => Self::Hue,
121 ffi::GSK_BLEND_MODE_SATURATION => Self::Saturation,
122 ffi::GSK_BLEND_MODE_LUMINOSITY => Self::Luminosity,
123 value => Self::__Unknown(value),
124 }
125 }
126}
127
128impl StaticType for BlendMode {
129 #[inline]
130 #[doc(alias = "gsk_blend_mode_get_type")]
131 fn static_type() -> glib::Type {
132 unsafe { from_glib(ffi::gsk_blend_mode_get_type()) }
133 }
134}
135
136impl glib::HasParamSpec for BlendMode {
137 type ParamSpec = glib::ParamSpecEnum;
138 type SetValue = Self;
139 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
140
141 fn param_spec_builder() -> Self::BuilderFn {
142 Self::ParamSpec::builder_with_default
143 }
144}
145
146impl glib::value::ValueType for BlendMode {
147 type Type = Self;
148}
149
150unsafe impl<'a> glib::value::FromValue<'a> for BlendMode {
151 type Checker = glib::value::GenericValueTypeChecker<Self>;
152
153 #[inline]
154 unsafe fn from_value(value: &'a glib::Value) -> Self {
155 skip_assert_initialized!();
156 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
157 }
158}
159
160impl ToValue for BlendMode {
161 #[inline]
162 fn to_value(&self) -> glib::Value {
163 let mut value = glib::Value::for_value_type::<Self>();
164 unsafe {
165 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
166 }
167 value
168 }
169
170 #[inline]
171 fn value_type(&self) -> glib::Type {
172 Self::static_type()
173 }
174}
175
176impl From<BlendMode> for glib::Value {
177 #[inline]
178 fn from(v: BlendMode) -> Self {
179 skip_assert_initialized!();
180 ToValue::to_value(&v)
181 }
182}
183
184#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
186#[non_exhaustive]
187#[doc(alias = "GskCorner")]
188pub enum Corner {
189 #[doc(alias = "GSK_CORNER_TOP_LEFT")]
191 TopLeft,
192 #[doc(alias = "GSK_CORNER_TOP_RIGHT")]
194 TopRight,
195 #[doc(alias = "GSK_CORNER_BOTTOM_RIGHT")]
197 BottomRight,
198 #[doc(alias = "GSK_CORNER_BOTTOM_LEFT")]
200 BottomLeft,
201 #[doc(hidden)]
202 __Unknown(i32),
203}
204
205#[doc(hidden)]
206impl IntoGlib for Corner {
207 type GlibType = ffi::GskCorner;
208
209 #[inline]
210 fn into_glib(self) -> ffi::GskCorner {
211 match self {
212 Self::TopLeft => ffi::GSK_CORNER_TOP_LEFT,
213 Self::TopRight => ffi::GSK_CORNER_TOP_RIGHT,
214 Self::BottomRight => ffi::GSK_CORNER_BOTTOM_RIGHT,
215 Self::BottomLeft => ffi::GSK_CORNER_BOTTOM_LEFT,
216 Self::__Unknown(value) => value,
217 }
218 }
219}
220
221#[doc(hidden)]
222impl FromGlib<ffi::GskCorner> for Corner {
223 #[inline]
224 unsafe fn from_glib(value: ffi::GskCorner) -> Self {
225 skip_assert_initialized!();
226
227 match value {
228 ffi::GSK_CORNER_TOP_LEFT => Self::TopLeft,
229 ffi::GSK_CORNER_TOP_RIGHT => Self::TopRight,
230 ffi::GSK_CORNER_BOTTOM_RIGHT => Self::BottomRight,
231 ffi::GSK_CORNER_BOTTOM_LEFT => Self::BottomLeft,
232 value => Self::__Unknown(value),
233 }
234 }
235}
236
237impl StaticType for Corner {
238 #[inline]
239 #[doc(alias = "gsk_corner_get_type")]
240 fn static_type() -> glib::Type {
241 unsafe { from_glib(ffi::gsk_corner_get_type()) }
242 }
243}
244
245impl glib::HasParamSpec for Corner {
246 type ParamSpec = glib::ParamSpecEnum;
247 type SetValue = Self;
248 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
249
250 fn param_spec_builder() -> Self::BuilderFn {
251 Self::ParamSpec::builder_with_default
252 }
253}
254
255impl glib::value::ValueType for Corner {
256 type Type = Self;
257}
258
259unsafe impl<'a> glib::value::FromValue<'a> for Corner {
260 type Checker = glib::value::GenericValueTypeChecker<Self>;
261
262 #[inline]
263 unsafe fn from_value(value: &'a glib::Value) -> Self {
264 skip_assert_initialized!();
265 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
266 }
267}
268
269impl ToValue for Corner {
270 #[inline]
271 fn to_value(&self) -> glib::Value {
272 let mut value = glib::Value::for_value_type::<Self>();
273 unsafe {
274 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
275 }
276 value
277 }
278
279 #[inline]
280 fn value_type(&self) -> glib::Type {
281 Self::static_type()
282 }
283}
284
285impl From<Corner> for glib::Value {
286 #[inline]
287 fn from(v: Corner) -> Self {
288 skip_assert_initialized!();
289 ToValue::to_value(&v)
290 }
291}
292
293#[cfg(feature = "v4_14")]
306#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
307#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
308#[non_exhaustive]
309#[doc(alias = "GskFillRule")]
310pub enum FillRule {
311 #[doc(alias = "GSK_FILL_RULE_WINDING")]
317 Winding,
318 #[doc(alias = "GSK_FILL_RULE_EVEN_ODD")]
323 EvenOdd,
324 #[doc(hidden)]
325 __Unknown(i32),
326}
327
328#[cfg(feature = "v4_14")]
329#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
330#[doc(hidden)]
331impl IntoGlib for FillRule {
332 type GlibType = ffi::GskFillRule;
333
334 #[inline]
335 fn into_glib(self) -> ffi::GskFillRule {
336 match self {
337 Self::Winding => ffi::GSK_FILL_RULE_WINDING,
338 Self::EvenOdd => ffi::GSK_FILL_RULE_EVEN_ODD,
339 Self::__Unknown(value) => value,
340 }
341 }
342}
343
344#[cfg(feature = "v4_14")]
345#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
346#[doc(hidden)]
347impl FromGlib<ffi::GskFillRule> for FillRule {
348 #[inline]
349 unsafe fn from_glib(value: ffi::GskFillRule) -> Self {
350 skip_assert_initialized!();
351
352 match value {
353 ffi::GSK_FILL_RULE_WINDING => Self::Winding,
354 ffi::GSK_FILL_RULE_EVEN_ODD => Self::EvenOdd,
355 value => Self::__Unknown(value),
356 }
357 }
358}
359
360#[cfg(feature = "v4_14")]
361#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
362impl StaticType for FillRule {
363 #[inline]
364 #[doc(alias = "gsk_fill_rule_get_type")]
365 fn static_type() -> glib::Type {
366 unsafe { from_glib(ffi::gsk_fill_rule_get_type()) }
367 }
368}
369
370#[cfg(feature = "v4_14")]
371#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
372impl glib::HasParamSpec for FillRule {
373 type ParamSpec = glib::ParamSpecEnum;
374 type SetValue = Self;
375 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
376
377 fn param_spec_builder() -> Self::BuilderFn {
378 Self::ParamSpec::builder_with_default
379 }
380}
381
382#[cfg(feature = "v4_14")]
383#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
384impl glib::value::ValueType for FillRule {
385 type Type = Self;
386}
387
388#[cfg(feature = "v4_14")]
389#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
390unsafe impl<'a> glib::value::FromValue<'a> for FillRule {
391 type Checker = glib::value::GenericValueTypeChecker<Self>;
392
393 #[inline]
394 unsafe fn from_value(value: &'a glib::Value) -> Self {
395 skip_assert_initialized!();
396 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
397 }
398}
399
400#[cfg(feature = "v4_14")]
401#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
402impl ToValue for FillRule {
403 #[inline]
404 fn to_value(&self) -> glib::Value {
405 let mut value = glib::Value::for_value_type::<Self>();
406 unsafe {
407 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
408 }
409 value
410 }
411
412 #[inline]
413 fn value_type(&self) -> glib::Type {
414 Self::static_type()
415 }
416}
417
418#[cfg(feature = "v4_14")]
419#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
420impl From<FillRule> for glib::Value {
421 #[inline]
422 fn from(v: FillRule) -> Self {
423 skip_assert_initialized!();
424 ToValue::to_value(&v)
425 }
426}
427
428#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
434#[non_exhaustive]
435#[doc(alias = "GskGLUniformType")]
436pub enum GLUniformType {
437 #[doc(alias = "GSK_GL_UNIFORM_TYPE_NONE")]
439 None,
440 #[doc(alias = "GSK_GL_UNIFORM_TYPE_FLOAT")]
442 Float,
443 #[doc(alias = "GSK_GL_UNIFORM_TYPE_INT")]
445 Int,
446 #[doc(alias = "GSK_GL_UNIFORM_TYPE_UINT")]
448 Uint,
449 #[doc(alias = "GSK_GL_UNIFORM_TYPE_BOOL")]
451 Bool,
452 #[doc(alias = "GSK_GL_UNIFORM_TYPE_VEC2")]
454 Vec2,
455 #[doc(alias = "GSK_GL_UNIFORM_TYPE_VEC3")]
457 Vec3,
458 #[doc(alias = "GSK_GL_UNIFORM_TYPE_VEC4")]
460 Vec4,
461 #[doc(hidden)]
462 __Unknown(i32),
463}
464
465#[doc(hidden)]
466impl IntoGlib for GLUniformType {
467 type GlibType = ffi::GskGLUniformType;
468
469 #[inline]
470 fn into_glib(self) -> ffi::GskGLUniformType {
471 match self {
472 Self::None => ffi::GSK_GL_UNIFORM_TYPE_NONE,
473 Self::Float => ffi::GSK_GL_UNIFORM_TYPE_FLOAT,
474 Self::Int => ffi::GSK_GL_UNIFORM_TYPE_INT,
475 Self::Uint => ffi::GSK_GL_UNIFORM_TYPE_UINT,
476 Self::Bool => ffi::GSK_GL_UNIFORM_TYPE_BOOL,
477 Self::Vec2 => ffi::GSK_GL_UNIFORM_TYPE_VEC2,
478 Self::Vec3 => ffi::GSK_GL_UNIFORM_TYPE_VEC3,
479 Self::Vec4 => ffi::GSK_GL_UNIFORM_TYPE_VEC4,
480 Self::__Unknown(value) => value,
481 }
482 }
483}
484
485#[doc(hidden)]
486impl FromGlib<ffi::GskGLUniformType> for GLUniformType {
487 #[inline]
488 unsafe fn from_glib(value: ffi::GskGLUniformType) -> Self {
489 skip_assert_initialized!();
490
491 match value {
492 ffi::GSK_GL_UNIFORM_TYPE_NONE => Self::None,
493 ffi::GSK_GL_UNIFORM_TYPE_FLOAT => Self::Float,
494 ffi::GSK_GL_UNIFORM_TYPE_INT => Self::Int,
495 ffi::GSK_GL_UNIFORM_TYPE_UINT => Self::Uint,
496 ffi::GSK_GL_UNIFORM_TYPE_BOOL => Self::Bool,
497 ffi::GSK_GL_UNIFORM_TYPE_VEC2 => Self::Vec2,
498 ffi::GSK_GL_UNIFORM_TYPE_VEC3 => Self::Vec3,
499 ffi::GSK_GL_UNIFORM_TYPE_VEC4 => Self::Vec4,
500 value => Self::__Unknown(value),
501 }
502 }
503}
504
505impl StaticType for GLUniformType {
506 #[inline]
507 #[doc(alias = "gsk_gl_uniform_type_get_type")]
508 fn static_type() -> glib::Type {
509 unsafe { from_glib(ffi::gsk_gl_uniform_type_get_type()) }
510 }
511}
512
513impl glib::HasParamSpec for GLUniformType {
514 type ParamSpec = glib::ParamSpecEnum;
515 type SetValue = Self;
516 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
517
518 fn param_spec_builder() -> Self::BuilderFn {
519 Self::ParamSpec::builder_with_default
520 }
521}
522
523impl glib::value::ValueType for GLUniformType {
524 type Type = Self;
525}
526
527unsafe impl<'a> glib::value::FromValue<'a> for GLUniformType {
528 type Checker = glib::value::GenericValueTypeChecker<Self>;
529
530 #[inline]
531 unsafe fn from_value(value: &'a glib::Value) -> Self {
532 skip_assert_initialized!();
533 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
534 }
535}
536
537impl ToValue for GLUniformType {
538 #[inline]
539 fn to_value(&self) -> glib::Value {
540 let mut value = glib::Value::for_value_type::<Self>();
541 unsafe {
542 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
543 }
544 value
545 }
546
547 #[inline]
548 fn value_type(&self) -> glib::Type {
549 Self::static_type()
550 }
551}
552
553impl From<GLUniformType> for glib::Value {
554 #[inline]
555 fn from(v: GLUniformType) -> Self {
556 skip_assert_initialized!();
557 ToValue::to_value(&v)
558 }
559}
560
561#[cfg(feature = "v4_14")]
576#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
577#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
578#[non_exhaustive]
579#[doc(alias = "GskLineCap")]
580pub enum LineCap {
581 #[doc(alias = "GSK_LINE_CAP_BUTT")]
584 Butt,
585 #[doc(alias = "GSK_LINE_CAP_ROUND")]
588 Round,
589 #[doc(alias = "GSK_LINE_CAP_SQUARE")]
592 Square,
593 #[doc(hidden)]
594 __Unknown(i32),
595}
596
597#[cfg(feature = "v4_14")]
598#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
599#[doc(hidden)]
600impl IntoGlib for LineCap {
601 type GlibType = ffi::GskLineCap;
602
603 #[inline]
604 fn into_glib(self) -> ffi::GskLineCap {
605 match self {
606 Self::Butt => ffi::GSK_LINE_CAP_BUTT,
607 Self::Round => ffi::GSK_LINE_CAP_ROUND,
608 Self::Square => ffi::GSK_LINE_CAP_SQUARE,
609 Self::__Unknown(value) => value,
610 }
611 }
612}
613
614#[cfg(feature = "v4_14")]
615#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
616#[doc(hidden)]
617impl FromGlib<ffi::GskLineCap> for LineCap {
618 #[inline]
619 unsafe fn from_glib(value: ffi::GskLineCap) -> Self {
620 skip_assert_initialized!();
621
622 match value {
623 ffi::GSK_LINE_CAP_BUTT => Self::Butt,
624 ffi::GSK_LINE_CAP_ROUND => Self::Round,
625 ffi::GSK_LINE_CAP_SQUARE => Self::Square,
626 value => Self::__Unknown(value),
627 }
628 }
629}
630
631#[cfg(feature = "v4_14")]
632#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
633impl StaticType for LineCap {
634 #[inline]
635 #[doc(alias = "gsk_line_cap_get_type")]
636 fn static_type() -> glib::Type {
637 unsafe { from_glib(ffi::gsk_line_cap_get_type()) }
638 }
639}
640
641#[cfg(feature = "v4_14")]
642#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
643impl glib::HasParamSpec for LineCap {
644 type ParamSpec = glib::ParamSpecEnum;
645 type SetValue = Self;
646 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
647
648 fn param_spec_builder() -> Self::BuilderFn {
649 Self::ParamSpec::builder_with_default
650 }
651}
652
653#[cfg(feature = "v4_14")]
654#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
655impl glib::value::ValueType for LineCap {
656 type Type = Self;
657}
658
659#[cfg(feature = "v4_14")]
660#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
661unsafe impl<'a> glib::value::FromValue<'a> for LineCap {
662 type Checker = glib::value::GenericValueTypeChecker<Self>;
663
664 #[inline]
665 unsafe fn from_value(value: &'a glib::Value) -> Self {
666 skip_assert_initialized!();
667 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
668 }
669}
670
671#[cfg(feature = "v4_14")]
672#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
673impl ToValue for LineCap {
674 #[inline]
675 fn to_value(&self) -> glib::Value {
676 let mut value = glib::Value::for_value_type::<Self>();
677 unsafe {
678 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
679 }
680 value
681 }
682
683 #[inline]
684 fn value_type(&self) -> glib::Type {
685 Self::static_type()
686 }
687}
688
689#[cfg(feature = "v4_14")]
690#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
691impl From<LineCap> for glib::Value {
692 #[inline]
693 fn from(v: LineCap) -> Self {
694 skip_assert_initialized!();
695 ToValue::to_value(&v)
696 }
697}
698
699#[cfg(feature = "v4_14")]
713#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
714#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
715#[non_exhaustive]
716#[doc(alias = "GskLineJoin")]
717pub enum LineJoin {
718 #[doc(alias = "GSK_LINE_JOIN_MITER")]
720 Miter,
721 #[doc(alias = "GSK_LINE_JOIN_ROUND")]
724 Round,
725 #[doc(alias = "GSK_LINE_JOIN_BEVEL")]
728 Bevel,
729 #[doc(hidden)]
730 __Unknown(i32),
731}
732
733#[cfg(feature = "v4_14")]
734#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
735#[doc(hidden)]
736impl IntoGlib for LineJoin {
737 type GlibType = ffi::GskLineJoin;
738
739 #[inline]
740 fn into_glib(self) -> ffi::GskLineJoin {
741 match self {
742 Self::Miter => ffi::GSK_LINE_JOIN_MITER,
743 Self::Round => ffi::GSK_LINE_JOIN_ROUND,
744 Self::Bevel => ffi::GSK_LINE_JOIN_BEVEL,
745 Self::__Unknown(value) => value,
746 }
747 }
748}
749
750#[cfg(feature = "v4_14")]
751#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
752#[doc(hidden)]
753impl FromGlib<ffi::GskLineJoin> for LineJoin {
754 #[inline]
755 unsafe fn from_glib(value: ffi::GskLineJoin) -> Self {
756 skip_assert_initialized!();
757
758 match value {
759 ffi::GSK_LINE_JOIN_MITER => Self::Miter,
760 ffi::GSK_LINE_JOIN_ROUND => Self::Round,
761 ffi::GSK_LINE_JOIN_BEVEL => Self::Bevel,
762 value => Self::__Unknown(value),
763 }
764 }
765}
766
767#[cfg(feature = "v4_14")]
768#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
769impl StaticType for LineJoin {
770 #[inline]
771 #[doc(alias = "gsk_line_join_get_type")]
772 fn static_type() -> glib::Type {
773 unsafe { from_glib(ffi::gsk_line_join_get_type()) }
774 }
775}
776
777#[cfg(feature = "v4_14")]
778#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
779impl glib::HasParamSpec for LineJoin {
780 type ParamSpec = glib::ParamSpecEnum;
781 type SetValue = Self;
782 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
783
784 fn param_spec_builder() -> Self::BuilderFn {
785 Self::ParamSpec::builder_with_default
786 }
787}
788
789#[cfg(feature = "v4_14")]
790#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
791impl glib::value::ValueType for LineJoin {
792 type Type = Self;
793}
794
795#[cfg(feature = "v4_14")]
796#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
797unsafe impl<'a> glib::value::FromValue<'a> for LineJoin {
798 type Checker = glib::value::GenericValueTypeChecker<Self>;
799
800 #[inline]
801 unsafe fn from_value(value: &'a glib::Value) -> Self {
802 skip_assert_initialized!();
803 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
804 }
805}
806
807#[cfg(feature = "v4_14")]
808#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
809impl ToValue for LineJoin {
810 #[inline]
811 fn to_value(&self) -> glib::Value {
812 let mut value = glib::Value::for_value_type::<Self>();
813 unsafe {
814 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
815 }
816 value
817 }
818
819 #[inline]
820 fn value_type(&self) -> glib::Type {
821 Self::static_type()
822 }
823}
824
825#[cfg(feature = "v4_14")]
826#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
827impl From<LineJoin> for glib::Value {
828 #[inline]
829 fn from(v: LineJoin) -> Self {
830 skip_assert_initialized!();
831 ToValue::to_value(&v)
832 }
833}
834
835#[cfg(feature = "v4_10")]
837#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
838#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
839#[non_exhaustive]
840#[doc(alias = "GskMaskMode")]
841pub enum MaskMode {
842 #[doc(alias = "GSK_MASK_MODE_ALPHA")]
844 Alpha,
845 #[doc(alias = "GSK_MASK_MODE_INVERTED_ALPHA")]
847 InvertedAlpha,
848 #[doc(alias = "GSK_MASK_MODE_LUMINANCE")]
851 Luminance,
852 #[doc(alias = "GSK_MASK_MODE_INVERTED_LUMINANCE")]
855 InvertedLuminance,
856 #[doc(hidden)]
857 __Unknown(i32),
858}
859
860#[cfg(feature = "v4_10")]
861#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
862#[doc(hidden)]
863impl IntoGlib for MaskMode {
864 type GlibType = ffi::GskMaskMode;
865
866 #[inline]
867 fn into_glib(self) -> ffi::GskMaskMode {
868 match self {
869 Self::Alpha => ffi::GSK_MASK_MODE_ALPHA,
870 Self::InvertedAlpha => ffi::GSK_MASK_MODE_INVERTED_ALPHA,
871 Self::Luminance => ffi::GSK_MASK_MODE_LUMINANCE,
872 Self::InvertedLuminance => ffi::GSK_MASK_MODE_INVERTED_LUMINANCE,
873 Self::__Unknown(value) => value,
874 }
875 }
876}
877
878#[cfg(feature = "v4_10")]
879#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
880#[doc(hidden)]
881impl FromGlib<ffi::GskMaskMode> for MaskMode {
882 #[inline]
883 unsafe fn from_glib(value: ffi::GskMaskMode) -> Self {
884 skip_assert_initialized!();
885
886 match value {
887 ffi::GSK_MASK_MODE_ALPHA => Self::Alpha,
888 ffi::GSK_MASK_MODE_INVERTED_ALPHA => Self::InvertedAlpha,
889 ffi::GSK_MASK_MODE_LUMINANCE => Self::Luminance,
890 ffi::GSK_MASK_MODE_INVERTED_LUMINANCE => Self::InvertedLuminance,
891 value => Self::__Unknown(value),
892 }
893 }
894}
895
896#[cfg(feature = "v4_10")]
897#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
898impl StaticType for MaskMode {
899 #[inline]
900 #[doc(alias = "gsk_mask_mode_get_type")]
901 fn static_type() -> glib::Type {
902 unsafe { from_glib(ffi::gsk_mask_mode_get_type()) }
903 }
904}
905
906#[cfg(feature = "v4_10")]
907#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
908impl glib::HasParamSpec for MaskMode {
909 type ParamSpec = glib::ParamSpecEnum;
910 type SetValue = Self;
911 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
912
913 fn param_spec_builder() -> Self::BuilderFn {
914 Self::ParamSpec::builder_with_default
915 }
916}
917
918#[cfg(feature = "v4_10")]
919#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
920impl glib::value::ValueType for MaskMode {
921 type Type = Self;
922}
923
924#[cfg(feature = "v4_10")]
925#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
926unsafe impl<'a> glib::value::FromValue<'a> for MaskMode {
927 type Checker = glib::value::GenericValueTypeChecker<Self>;
928
929 #[inline]
930 unsafe fn from_value(value: &'a glib::Value) -> Self {
931 skip_assert_initialized!();
932 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
933 }
934}
935
936#[cfg(feature = "v4_10")]
937#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
938impl ToValue for MaskMode {
939 #[inline]
940 fn to_value(&self) -> glib::Value {
941 let mut value = glib::Value::for_value_type::<Self>();
942 unsafe {
943 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
944 }
945 value
946 }
947
948 #[inline]
949 fn value_type(&self) -> glib::Type {
950 Self::static_type()
951 }
952}
953
954#[cfg(feature = "v4_10")]
955#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
956impl From<MaskMode> for glib::Value {
957 #[inline]
958 fn from(v: MaskMode) -> Self {
959 skip_assert_initialized!();
960 ToValue::to_value(&v)
961 }
962}
963
964#[cfg(feature = "v4_14")]
976#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
977#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
978#[non_exhaustive]
979#[doc(alias = "GskPathDirection")]
980pub enum PathDirection {
981 #[doc(alias = "GSK_PATH_FROM_START")]
984 FromStart,
985 #[doc(alias = "GSK_PATH_TO_START")]
988 ToStart,
989 #[doc(alias = "GSK_PATH_TO_END")]
992 ToEnd,
993 #[doc(alias = "GSK_PATH_FROM_END")]
996 FromEnd,
997 #[doc(hidden)]
998 __Unknown(i32),
999}
1000
1001#[cfg(feature = "v4_14")]
1002#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1003#[doc(hidden)]
1004impl IntoGlib for PathDirection {
1005 type GlibType = ffi::GskPathDirection;
1006
1007 #[inline]
1008 fn into_glib(self) -> ffi::GskPathDirection {
1009 match self {
1010 Self::FromStart => ffi::GSK_PATH_FROM_START,
1011 Self::ToStart => ffi::GSK_PATH_TO_START,
1012 Self::ToEnd => ffi::GSK_PATH_TO_END,
1013 Self::FromEnd => ffi::GSK_PATH_FROM_END,
1014 Self::__Unknown(value) => value,
1015 }
1016 }
1017}
1018
1019#[cfg(feature = "v4_14")]
1020#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1021#[doc(hidden)]
1022impl FromGlib<ffi::GskPathDirection> for PathDirection {
1023 #[inline]
1024 unsafe fn from_glib(value: ffi::GskPathDirection) -> Self {
1025 skip_assert_initialized!();
1026
1027 match value {
1028 ffi::GSK_PATH_FROM_START => Self::FromStart,
1029 ffi::GSK_PATH_TO_START => Self::ToStart,
1030 ffi::GSK_PATH_TO_END => Self::ToEnd,
1031 ffi::GSK_PATH_FROM_END => Self::FromEnd,
1032 value => Self::__Unknown(value),
1033 }
1034 }
1035}
1036
1037#[cfg(feature = "v4_14")]
1038#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1039impl StaticType for PathDirection {
1040 #[inline]
1041 #[doc(alias = "gsk_path_direction_get_type")]
1042 fn static_type() -> glib::Type {
1043 unsafe { from_glib(ffi::gsk_path_direction_get_type()) }
1044 }
1045}
1046
1047#[cfg(feature = "v4_14")]
1048#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1049impl glib::HasParamSpec for PathDirection {
1050 type ParamSpec = glib::ParamSpecEnum;
1051 type SetValue = Self;
1052 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1053
1054 fn param_spec_builder() -> Self::BuilderFn {
1055 Self::ParamSpec::builder_with_default
1056 }
1057}
1058
1059#[cfg(feature = "v4_14")]
1060#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1061impl glib::value::ValueType for PathDirection {
1062 type Type = Self;
1063}
1064
1065#[cfg(feature = "v4_14")]
1066#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1067unsafe impl<'a> glib::value::FromValue<'a> for PathDirection {
1068 type Checker = glib::value::GenericValueTypeChecker<Self>;
1069
1070 #[inline]
1071 unsafe fn from_value(value: &'a glib::Value) -> Self {
1072 skip_assert_initialized!();
1073 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
1074 }
1075}
1076
1077#[cfg(feature = "v4_14")]
1078#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1079impl ToValue for PathDirection {
1080 #[inline]
1081 fn to_value(&self) -> glib::Value {
1082 let mut value = glib::Value::for_value_type::<Self>();
1083 unsafe {
1084 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1085 }
1086 value
1087 }
1088
1089 #[inline]
1090 fn value_type(&self) -> glib::Type {
1091 Self::static_type()
1092 }
1093}
1094
1095#[cfg(feature = "v4_14")]
1096#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1097impl From<PathDirection> for glib::Value {
1098 #[inline]
1099 fn from(v: PathDirection) -> Self {
1100 skip_assert_initialized!();
1101 ToValue::to_value(&v)
1102 }
1103}
1104
1105#[cfg(feature = "v4_14")]
1109#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1110#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1111#[non_exhaustive]
1112#[doc(alias = "GskPathOperation")]
1113pub enum PathOperation {
1114 #[doc(alias = "GSK_PATH_MOVE")]
1116 Move,
1117 #[doc(alias = "GSK_PATH_CLOSE")]
1120 Close,
1121 #[doc(alias = "GSK_PATH_LINE")]
1124 Line,
1125 #[doc(alias = "GSK_PATH_QUAD")]
1129 Quad,
1130 #[doc(alias = "GSK_PATH_CUBIC")]
1134 Cubic,
1135 #[doc(alias = "GSK_PATH_CONIC")]
1139 Conic,
1140 #[doc(hidden)]
1141 __Unknown(i32),
1142}
1143
1144#[cfg(feature = "v4_14")]
1145#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1146#[doc(hidden)]
1147impl IntoGlib for PathOperation {
1148 type GlibType = ffi::GskPathOperation;
1149
1150 #[inline]
1151 fn into_glib(self) -> ffi::GskPathOperation {
1152 match self {
1153 Self::Move => ffi::GSK_PATH_MOVE,
1154 Self::Close => ffi::GSK_PATH_CLOSE,
1155 Self::Line => ffi::GSK_PATH_LINE,
1156 Self::Quad => ffi::GSK_PATH_QUAD,
1157 Self::Cubic => ffi::GSK_PATH_CUBIC,
1158 Self::Conic => ffi::GSK_PATH_CONIC,
1159 Self::__Unknown(value) => value,
1160 }
1161 }
1162}
1163
1164#[cfg(feature = "v4_14")]
1165#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1166#[doc(hidden)]
1167impl FromGlib<ffi::GskPathOperation> for PathOperation {
1168 #[inline]
1169 unsafe fn from_glib(value: ffi::GskPathOperation) -> Self {
1170 skip_assert_initialized!();
1171
1172 match value {
1173 ffi::GSK_PATH_MOVE => Self::Move,
1174 ffi::GSK_PATH_CLOSE => Self::Close,
1175 ffi::GSK_PATH_LINE => Self::Line,
1176 ffi::GSK_PATH_QUAD => Self::Quad,
1177 ffi::GSK_PATH_CUBIC => Self::Cubic,
1178 ffi::GSK_PATH_CONIC => Self::Conic,
1179 value => Self::__Unknown(value),
1180 }
1181 }
1182}
1183
1184#[cfg(feature = "v4_14")]
1185#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1186impl StaticType for PathOperation {
1187 #[inline]
1188 #[doc(alias = "gsk_path_operation_get_type")]
1189 fn static_type() -> glib::Type {
1190 unsafe { from_glib(ffi::gsk_path_operation_get_type()) }
1191 }
1192}
1193
1194#[cfg(feature = "v4_14")]
1195#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1196impl glib::HasParamSpec for PathOperation {
1197 type ParamSpec = glib::ParamSpecEnum;
1198 type SetValue = Self;
1199 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1200
1201 fn param_spec_builder() -> Self::BuilderFn {
1202 Self::ParamSpec::builder_with_default
1203 }
1204}
1205
1206#[cfg(feature = "v4_14")]
1207#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1208impl glib::value::ValueType for PathOperation {
1209 type Type = Self;
1210}
1211
1212#[cfg(feature = "v4_14")]
1213#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1214unsafe impl<'a> glib::value::FromValue<'a> for PathOperation {
1215 type Checker = glib::value::GenericValueTypeChecker<Self>;
1216
1217 #[inline]
1218 unsafe fn from_value(value: &'a glib::Value) -> Self {
1219 skip_assert_initialized!();
1220 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
1221 }
1222}
1223
1224#[cfg(feature = "v4_14")]
1225#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1226impl ToValue for PathOperation {
1227 #[inline]
1228 fn to_value(&self) -> glib::Value {
1229 let mut value = glib::Value::for_value_type::<Self>();
1230 unsafe {
1231 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1232 }
1233 value
1234 }
1235
1236 #[inline]
1237 fn value_type(&self) -> glib::Type {
1238 Self::static_type()
1239 }
1240}
1241
1242#[cfg(feature = "v4_14")]
1243#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1244impl From<PathOperation> for glib::Value {
1245 #[inline]
1246 fn from(v: PathOperation) -> Self {
1247 skip_assert_initialized!();
1248 ToValue::to_value(&v)
1249 }
1250}
1251
1252#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1254#[non_exhaustive]
1255#[doc(alias = "GskRenderNodeType")]
1256pub enum RenderNodeType {
1257 #[doc(alias = "GSK_NOT_A_RENDER_NODE")]
1259 NotARenderNode,
1260 #[doc(alias = "GSK_CONTAINER_NODE")]
1262 ContainerNode,
1263 #[doc(alias = "GSK_CAIRO_NODE")]
1265 CairoNode,
1266 #[doc(alias = "GSK_COLOR_NODE")]
1268 ColorNode,
1269 #[doc(alias = "GSK_LINEAR_GRADIENT_NODE")]
1271 LinearGradientNode,
1272 #[doc(alias = "GSK_REPEATING_LINEAR_GRADIENT_NODE")]
1274 RepeatingLinearGradientNode,
1275 #[doc(alias = "GSK_RADIAL_GRADIENT_NODE")]
1277 RadialGradientNode,
1278 #[doc(alias = "GSK_REPEATING_RADIAL_GRADIENT_NODE")]
1280 RepeatingRadialGradientNode,
1281 #[doc(alias = "GSK_CONIC_GRADIENT_NODE")]
1283 ConicGradientNode,
1284 #[doc(alias = "GSK_BORDER_NODE")]
1286 BorderNode,
1287 #[doc(alias = "GSK_TEXTURE_NODE")]
1289 TextureNode,
1290 #[doc(alias = "GSK_INSET_SHADOW_NODE")]
1292 InsetShadowNode,
1293 #[doc(alias = "GSK_OUTSET_SHADOW_NODE")]
1295 OutsetShadowNode,
1296 #[doc(alias = "GSK_TRANSFORM_NODE")]
1298 TransformNode,
1299 #[doc(alias = "GSK_OPACITY_NODE")]
1301 OpacityNode,
1302 #[doc(alias = "GSK_COLOR_MATRIX_NODE")]
1304 ColorMatrixNode,
1305 #[doc(alias = "GSK_REPEAT_NODE")]
1307 RepeatNode,
1308 #[doc(alias = "GSK_CLIP_NODE")]
1310 ClipNode,
1311 #[doc(alias = "GSK_ROUNDED_CLIP_NODE")]
1313 RoundedClipNode,
1314 #[doc(alias = "GSK_SHADOW_NODE")]
1316 ShadowNode,
1317 #[doc(alias = "GSK_BLEND_NODE")]
1319 BlendNode,
1320 #[doc(alias = "GSK_CROSS_FADE_NODE")]
1322 CrossFadeNode,
1323 #[doc(alias = "GSK_TEXT_NODE")]
1325 TextNode,
1326 #[doc(alias = "GSK_BLUR_NODE")]
1328 BlurNode,
1329 #[doc(alias = "GSK_DEBUG_NODE")]
1331 DebugNode,
1332 #[doc(alias = "GSK_GL_SHADER_NODE")]
1334 GlShaderNode,
1335 #[cfg(feature = "v4_10")]
1337 #[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
1338 #[doc(alias = "GSK_TEXTURE_SCALE_NODE")]
1339 TextureScaleNode,
1340 #[cfg(feature = "v4_10")]
1342 #[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
1343 #[doc(alias = "GSK_MASK_NODE")]
1344 MaskNode,
1345 #[cfg(feature = "v4_14")]
1347 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1348 #[doc(alias = "GSK_FILL_NODE")]
1349 FillNode,
1350 #[cfg(feature = "v4_14")]
1352 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1353 #[doc(alias = "GSK_STROKE_NODE")]
1354 StrokeNode,
1355 #[cfg(feature = "v4_14")]
1357 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1358 #[doc(alias = "GSK_SUBSURFACE_NODE")]
1359 SubsurfaceNode,
1360 #[doc(hidden)]
1361 __Unknown(i32),
1362}
1363
1364#[doc(hidden)]
1365impl IntoGlib for RenderNodeType {
1366 type GlibType = ffi::GskRenderNodeType;
1367
1368 fn into_glib(self) -> ffi::GskRenderNodeType {
1369 match self {
1370 Self::NotARenderNode => ffi::GSK_NOT_A_RENDER_NODE,
1371 Self::ContainerNode => ffi::GSK_CONTAINER_NODE,
1372 Self::CairoNode => ffi::GSK_CAIRO_NODE,
1373 Self::ColorNode => ffi::GSK_COLOR_NODE,
1374 Self::LinearGradientNode => ffi::GSK_LINEAR_GRADIENT_NODE,
1375 Self::RepeatingLinearGradientNode => ffi::GSK_REPEATING_LINEAR_GRADIENT_NODE,
1376 Self::RadialGradientNode => ffi::GSK_RADIAL_GRADIENT_NODE,
1377 Self::RepeatingRadialGradientNode => ffi::GSK_REPEATING_RADIAL_GRADIENT_NODE,
1378 Self::ConicGradientNode => ffi::GSK_CONIC_GRADIENT_NODE,
1379 Self::BorderNode => ffi::GSK_BORDER_NODE,
1380 Self::TextureNode => ffi::GSK_TEXTURE_NODE,
1381 Self::InsetShadowNode => ffi::GSK_INSET_SHADOW_NODE,
1382 Self::OutsetShadowNode => ffi::GSK_OUTSET_SHADOW_NODE,
1383 Self::TransformNode => ffi::GSK_TRANSFORM_NODE,
1384 Self::OpacityNode => ffi::GSK_OPACITY_NODE,
1385 Self::ColorMatrixNode => ffi::GSK_COLOR_MATRIX_NODE,
1386 Self::RepeatNode => ffi::GSK_REPEAT_NODE,
1387 Self::ClipNode => ffi::GSK_CLIP_NODE,
1388 Self::RoundedClipNode => ffi::GSK_ROUNDED_CLIP_NODE,
1389 Self::ShadowNode => ffi::GSK_SHADOW_NODE,
1390 Self::BlendNode => ffi::GSK_BLEND_NODE,
1391 Self::CrossFadeNode => ffi::GSK_CROSS_FADE_NODE,
1392 Self::TextNode => ffi::GSK_TEXT_NODE,
1393 Self::BlurNode => ffi::GSK_BLUR_NODE,
1394 Self::DebugNode => ffi::GSK_DEBUG_NODE,
1395 Self::GlShaderNode => ffi::GSK_GL_SHADER_NODE,
1396 #[cfg(feature = "v4_10")]
1397 Self::TextureScaleNode => ffi::GSK_TEXTURE_SCALE_NODE,
1398 #[cfg(feature = "v4_10")]
1399 Self::MaskNode => ffi::GSK_MASK_NODE,
1400 #[cfg(feature = "v4_14")]
1401 Self::FillNode => ffi::GSK_FILL_NODE,
1402 #[cfg(feature = "v4_14")]
1403 Self::StrokeNode => ffi::GSK_STROKE_NODE,
1404 #[cfg(feature = "v4_14")]
1405 Self::SubsurfaceNode => ffi::GSK_SUBSURFACE_NODE,
1406 Self::__Unknown(value) => value,
1407 }
1408 }
1409}
1410
1411#[doc(hidden)]
1412impl FromGlib<ffi::GskRenderNodeType> for RenderNodeType {
1413 unsafe fn from_glib(value: ffi::GskRenderNodeType) -> Self {
1414 skip_assert_initialized!();
1415
1416 match value {
1417 ffi::GSK_NOT_A_RENDER_NODE => Self::NotARenderNode,
1418 ffi::GSK_CONTAINER_NODE => Self::ContainerNode,
1419 ffi::GSK_CAIRO_NODE => Self::CairoNode,
1420 ffi::GSK_COLOR_NODE => Self::ColorNode,
1421 ffi::GSK_LINEAR_GRADIENT_NODE => Self::LinearGradientNode,
1422 ffi::GSK_REPEATING_LINEAR_GRADIENT_NODE => Self::RepeatingLinearGradientNode,
1423 ffi::GSK_RADIAL_GRADIENT_NODE => Self::RadialGradientNode,
1424 ffi::GSK_REPEATING_RADIAL_GRADIENT_NODE => Self::RepeatingRadialGradientNode,
1425 ffi::GSK_CONIC_GRADIENT_NODE => Self::ConicGradientNode,
1426 ffi::GSK_BORDER_NODE => Self::BorderNode,
1427 ffi::GSK_TEXTURE_NODE => Self::TextureNode,
1428 ffi::GSK_INSET_SHADOW_NODE => Self::InsetShadowNode,
1429 ffi::GSK_OUTSET_SHADOW_NODE => Self::OutsetShadowNode,
1430 ffi::GSK_TRANSFORM_NODE => Self::TransformNode,
1431 ffi::GSK_OPACITY_NODE => Self::OpacityNode,
1432 ffi::GSK_COLOR_MATRIX_NODE => Self::ColorMatrixNode,
1433 ffi::GSK_REPEAT_NODE => Self::RepeatNode,
1434 ffi::GSK_CLIP_NODE => Self::ClipNode,
1435 ffi::GSK_ROUNDED_CLIP_NODE => Self::RoundedClipNode,
1436 ffi::GSK_SHADOW_NODE => Self::ShadowNode,
1437 ffi::GSK_BLEND_NODE => Self::BlendNode,
1438 ffi::GSK_CROSS_FADE_NODE => Self::CrossFadeNode,
1439 ffi::GSK_TEXT_NODE => Self::TextNode,
1440 ffi::GSK_BLUR_NODE => Self::BlurNode,
1441 ffi::GSK_DEBUG_NODE => Self::DebugNode,
1442 ffi::GSK_GL_SHADER_NODE => Self::GlShaderNode,
1443 #[cfg(feature = "v4_10")]
1444 ffi::GSK_TEXTURE_SCALE_NODE => Self::TextureScaleNode,
1445 #[cfg(feature = "v4_10")]
1446 ffi::GSK_MASK_NODE => Self::MaskNode,
1447 #[cfg(feature = "v4_14")]
1448 ffi::GSK_FILL_NODE => Self::FillNode,
1449 #[cfg(feature = "v4_14")]
1450 ffi::GSK_STROKE_NODE => Self::StrokeNode,
1451 #[cfg(feature = "v4_14")]
1452 ffi::GSK_SUBSURFACE_NODE => Self::SubsurfaceNode,
1453 value => Self::__Unknown(value),
1454 }
1455 }
1456}
1457
1458impl StaticType for RenderNodeType {
1459 #[inline]
1460 #[doc(alias = "gsk_render_node_type_get_type")]
1461 fn static_type() -> glib::Type {
1462 unsafe { from_glib(ffi::gsk_render_node_type_get_type()) }
1463 }
1464}
1465
1466impl glib::HasParamSpec for RenderNodeType {
1467 type ParamSpec = glib::ParamSpecEnum;
1468 type SetValue = Self;
1469 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1470
1471 fn param_spec_builder() -> Self::BuilderFn {
1472 Self::ParamSpec::builder_with_default
1473 }
1474}
1475
1476impl glib::value::ValueType for RenderNodeType {
1477 type Type = Self;
1478}
1479
1480unsafe impl<'a> glib::value::FromValue<'a> for RenderNodeType {
1481 type Checker = glib::value::GenericValueTypeChecker<Self>;
1482
1483 #[inline]
1484 unsafe fn from_value(value: &'a glib::Value) -> Self {
1485 skip_assert_initialized!();
1486 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
1487 }
1488}
1489
1490impl ToValue for RenderNodeType {
1491 #[inline]
1492 fn to_value(&self) -> glib::Value {
1493 let mut value = glib::Value::for_value_type::<Self>();
1494 unsafe {
1495 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1496 }
1497 value
1498 }
1499
1500 #[inline]
1501 fn value_type(&self) -> glib::Type {
1502 Self::static_type()
1503 }
1504}
1505
1506impl From<RenderNodeType> for glib::Value {
1507 #[inline]
1508 fn from(v: RenderNodeType) -> Self {
1509 skip_assert_initialized!();
1510 ToValue::to_value(&v)
1511 }
1512}
1513
1514#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1519#[non_exhaustive]
1520#[doc(alias = "GskScalingFilter")]
1521pub enum ScalingFilter {
1522 #[doc(alias = "GSK_SCALING_FILTER_LINEAR")]
1524 Linear,
1525 #[doc(alias = "GSK_SCALING_FILTER_NEAREST")]
1527 Nearest,
1528 #[doc(alias = "GSK_SCALING_FILTER_TRILINEAR")]
1532 Trilinear,
1533 #[doc(hidden)]
1534 __Unknown(i32),
1535}
1536
1537#[doc(hidden)]
1538impl IntoGlib for ScalingFilter {
1539 type GlibType = ffi::GskScalingFilter;
1540
1541 #[inline]
1542 fn into_glib(self) -> ffi::GskScalingFilter {
1543 match self {
1544 Self::Linear => ffi::GSK_SCALING_FILTER_LINEAR,
1545 Self::Nearest => ffi::GSK_SCALING_FILTER_NEAREST,
1546 Self::Trilinear => ffi::GSK_SCALING_FILTER_TRILINEAR,
1547 Self::__Unknown(value) => value,
1548 }
1549 }
1550}
1551
1552#[doc(hidden)]
1553impl FromGlib<ffi::GskScalingFilter> for ScalingFilter {
1554 #[inline]
1555 unsafe fn from_glib(value: ffi::GskScalingFilter) -> Self {
1556 skip_assert_initialized!();
1557
1558 match value {
1559 ffi::GSK_SCALING_FILTER_LINEAR => Self::Linear,
1560 ffi::GSK_SCALING_FILTER_NEAREST => Self::Nearest,
1561 ffi::GSK_SCALING_FILTER_TRILINEAR => Self::Trilinear,
1562 value => Self::__Unknown(value),
1563 }
1564 }
1565}
1566
1567impl StaticType for ScalingFilter {
1568 #[inline]
1569 #[doc(alias = "gsk_scaling_filter_get_type")]
1570 fn static_type() -> glib::Type {
1571 unsafe { from_glib(ffi::gsk_scaling_filter_get_type()) }
1572 }
1573}
1574
1575impl glib::HasParamSpec for ScalingFilter {
1576 type ParamSpec = glib::ParamSpecEnum;
1577 type SetValue = Self;
1578 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1579
1580 fn param_spec_builder() -> Self::BuilderFn {
1581 Self::ParamSpec::builder_with_default
1582 }
1583}
1584
1585impl glib::value::ValueType for ScalingFilter {
1586 type Type = Self;
1587}
1588
1589unsafe impl<'a> glib::value::FromValue<'a> for ScalingFilter {
1590 type Checker = glib::value::GenericValueTypeChecker<Self>;
1591
1592 #[inline]
1593 unsafe fn from_value(value: &'a glib::Value) -> Self {
1594 skip_assert_initialized!();
1595 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
1596 }
1597}
1598
1599impl ToValue for ScalingFilter {
1600 #[inline]
1601 fn to_value(&self) -> glib::Value {
1602 let mut value = glib::Value::for_value_type::<Self>();
1603 unsafe {
1604 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1605 }
1606 value
1607 }
1608
1609 #[inline]
1610 fn value_type(&self) -> glib::Type {
1611 Self::static_type()
1612 }
1613}
1614
1615impl From<ScalingFilter> for glib::Value {
1616 #[inline]
1617 fn from(v: ScalingFilter) -> Self {
1618 skip_assert_initialized!();
1619 ToValue::to_value(&v)
1620 }
1621}
1622
1623#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1625#[non_exhaustive]
1626#[doc(alias = "GskSerializationError")]
1627pub enum SerializationError {
1628 #[doc(alias = "GSK_SERIALIZATION_UNSUPPORTED_FORMAT")]
1630 UnsupportedFormat,
1631 #[doc(alias = "GSK_SERIALIZATION_UNSUPPORTED_VERSION")]
1634 UnsupportedVersion,
1635 #[doc(alias = "GSK_SERIALIZATION_INVALID_DATA")]
1638 InvalidData,
1639 #[doc(hidden)]
1640 __Unknown(i32),
1641}
1642
1643#[doc(hidden)]
1644impl IntoGlib for SerializationError {
1645 type GlibType = ffi::GskSerializationError;
1646
1647 #[inline]
1648 fn into_glib(self) -> ffi::GskSerializationError {
1649 match self {
1650 Self::UnsupportedFormat => ffi::GSK_SERIALIZATION_UNSUPPORTED_FORMAT,
1651 Self::UnsupportedVersion => ffi::GSK_SERIALIZATION_UNSUPPORTED_VERSION,
1652 Self::InvalidData => ffi::GSK_SERIALIZATION_INVALID_DATA,
1653 Self::__Unknown(value) => value,
1654 }
1655 }
1656}
1657
1658#[doc(hidden)]
1659impl FromGlib<ffi::GskSerializationError> for SerializationError {
1660 #[inline]
1661 unsafe fn from_glib(value: ffi::GskSerializationError) -> Self {
1662 skip_assert_initialized!();
1663
1664 match value {
1665 ffi::GSK_SERIALIZATION_UNSUPPORTED_FORMAT => Self::UnsupportedFormat,
1666 ffi::GSK_SERIALIZATION_UNSUPPORTED_VERSION => Self::UnsupportedVersion,
1667 ffi::GSK_SERIALIZATION_INVALID_DATA => Self::InvalidData,
1668 value => Self::__Unknown(value),
1669 }
1670 }
1671}
1672
1673impl glib::error::ErrorDomain for SerializationError {
1674 #[inline]
1675 fn domain() -> glib::Quark {
1676 skip_assert_initialized!();
1677
1678 unsafe { from_glib(ffi::gsk_serialization_error_quark()) }
1679 }
1680
1681 #[inline]
1682 fn code(self) -> i32 {
1683 self.into_glib()
1684 }
1685
1686 #[inline]
1687 #[allow(clippy::match_single_binding)]
1688 fn from(code: i32) -> Option<Self> {
1689 skip_assert_initialized!();
1690 match unsafe { from_glib(code) } {
1691 value => Some(value),
1692 }
1693 }
1694}
1695
1696impl StaticType for SerializationError {
1697 #[inline]
1698 #[doc(alias = "gsk_serialization_error_get_type")]
1699 fn static_type() -> glib::Type {
1700 unsafe { from_glib(ffi::gsk_serialization_error_get_type()) }
1701 }
1702}
1703
1704impl glib::HasParamSpec for SerializationError {
1705 type ParamSpec = glib::ParamSpecEnum;
1706 type SetValue = Self;
1707 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1708
1709 fn param_spec_builder() -> Self::BuilderFn {
1710 Self::ParamSpec::builder_with_default
1711 }
1712}
1713
1714impl glib::value::ValueType for SerializationError {
1715 type Type = Self;
1716}
1717
1718unsafe impl<'a> glib::value::FromValue<'a> for SerializationError {
1719 type Checker = glib::value::GenericValueTypeChecker<Self>;
1720
1721 #[inline]
1722 unsafe fn from_value(value: &'a glib::Value) -> Self {
1723 skip_assert_initialized!();
1724 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
1725 }
1726}
1727
1728impl ToValue for SerializationError {
1729 #[inline]
1730 fn to_value(&self) -> glib::Value {
1731 let mut value = glib::Value::for_value_type::<Self>();
1732 unsafe {
1733 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1734 }
1735 value
1736 }
1737
1738 #[inline]
1739 fn value_type(&self) -> glib::Type {
1740 Self::static_type()
1741 }
1742}
1743
1744impl From<SerializationError> for glib::Value {
1745 #[inline]
1746 fn from(v: SerializationError) -> Self {
1747 skip_assert_initialized!();
1748 ToValue::to_value(&v)
1749 }
1750}
1751
1752#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1763#[non_exhaustive]
1764#[doc(alias = "GskTransformCategory")]
1765pub enum TransformCategory {
1766 #[doc(alias = "GSK_TRANSFORM_CATEGORY_UNKNOWN")]
1769 Unknown,
1770 #[doc(alias = "GSK_TRANSFORM_CATEGORY_ANY")]
1773 Any,
1774 #[doc(alias = "GSK_TRANSFORM_CATEGORY_3D")]
1777 _3d,
1778 #[doc(alias = "GSK_TRANSFORM_CATEGORY_2D")]
1782 _2d,
1783 #[doc(alias = "GSK_TRANSFORM_CATEGORY_2D_AFFINE")]
1787 _2dAffine,
1788 #[doc(alias = "GSK_TRANSFORM_CATEGORY_2D_TRANSLATE")]
1790 _2dTranslate,
1791 #[doc(alias = "GSK_TRANSFORM_CATEGORY_IDENTITY")]
1793 Identity,
1794 #[doc(hidden)]
1795 __Unknown(i32),
1796}
1797
1798#[doc(hidden)]
1799impl IntoGlib for TransformCategory {
1800 type GlibType = ffi::GskTransformCategory;
1801
1802 #[inline]
1803 fn into_glib(self) -> ffi::GskTransformCategory {
1804 match self {
1805 Self::Unknown => ffi::GSK_TRANSFORM_CATEGORY_UNKNOWN,
1806 Self::Any => ffi::GSK_TRANSFORM_CATEGORY_ANY,
1807 Self::_3d => ffi::GSK_TRANSFORM_CATEGORY_3D,
1808 Self::_2d => ffi::GSK_TRANSFORM_CATEGORY_2D,
1809 Self::_2dAffine => ffi::GSK_TRANSFORM_CATEGORY_2D_AFFINE,
1810 Self::_2dTranslate => ffi::GSK_TRANSFORM_CATEGORY_2D_TRANSLATE,
1811 Self::Identity => ffi::GSK_TRANSFORM_CATEGORY_IDENTITY,
1812 Self::__Unknown(value) => value,
1813 }
1814 }
1815}
1816
1817#[doc(hidden)]
1818impl FromGlib<ffi::GskTransformCategory> for TransformCategory {
1819 #[inline]
1820 unsafe fn from_glib(value: ffi::GskTransformCategory) -> Self {
1821 skip_assert_initialized!();
1822
1823 match value {
1824 ffi::GSK_TRANSFORM_CATEGORY_UNKNOWN => Self::Unknown,
1825 ffi::GSK_TRANSFORM_CATEGORY_ANY => Self::Any,
1826 ffi::GSK_TRANSFORM_CATEGORY_3D => Self::_3d,
1827 ffi::GSK_TRANSFORM_CATEGORY_2D => Self::_2d,
1828 ffi::GSK_TRANSFORM_CATEGORY_2D_AFFINE => Self::_2dAffine,
1829 ffi::GSK_TRANSFORM_CATEGORY_2D_TRANSLATE => Self::_2dTranslate,
1830 ffi::GSK_TRANSFORM_CATEGORY_IDENTITY => Self::Identity,
1831 value => Self::__Unknown(value),
1832 }
1833 }
1834}
1835
1836impl StaticType for TransformCategory {
1837 #[inline]
1838 #[doc(alias = "gsk_transform_category_get_type")]
1839 fn static_type() -> glib::Type {
1840 unsafe { from_glib(ffi::gsk_transform_category_get_type()) }
1841 }
1842}
1843
1844impl glib::HasParamSpec for TransformCategory {
1845 type ParamSpec = glib::ParamSpecEnum;
1846 type SetValue = Self;
1847 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1848
1849 fn param_spec_builder() -> Self::BuilderFn {
1850 Self::ParamSpec::builder_with_default
1851 }
1852}
1853
1854impl glib::value::ValueType for TransformCategory {
1855 type Type = Self;
1856}
1857
1858unsafe impl<'a> glib::value::FromValue<'a> for TransformCategory {
1859 type Checker = glib::value::GenericValueTypeChecker<Self>;
1860
1861 #[inline]
1862 unsafe fn from_value(value: &'a glib::Value) -> Self {
1863 skip_assert_initialized!();
1864 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
1865 }
1866}
1867
1868impl ToValue for TransformCategory {
1869 #[inline]
1870 fn to_value(&self) -> glib::Value {
1871 let mut value = glib::Value::for_value_type::<Self>();
1872 unsafe {
1873 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1874 }
1875 value
1876 }
1877
1878 #[inline]
1879 fn value_type(&self) -> glib::Type {
1880 Self::static_type()
1881 }
1882}
1883
1884impl From<TransformCategory> for glib::Value {
1885 #[inline]
1886 fn from(v: TransformCategory) -> Self {
1887 skip_assert_initialized!();
1888 ToValue::to_value(&v)
1889 }
1890}