1use crate::ffi;
6use glib::{prelude::*, translate::*};
7
8#[cfg(feature = "v4_14")]
9#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
10#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
11#[non_exhaustive]
12#[doc(alias = "GtkAccessibleAnnouncementPriority")]
13pub enum AccessibleAnnouncementPriority {
14 #[doc(alias = "GTK_ACCESSIBLE_ANNOUNCEMENT_PRIORITY_LOW")]
15 Low,
16 #[doc(alias = "GTK_ACCESSIBLE_ANNOUNCEMENT_PRIORITY_MEDIUM")]
17 Medium,
18 #[doc(alias = "GTK_ACCESSIBLE_ANNOUNCEMENT_PRIORITY_HIGH")]
19 High,
20 #[doc(hidden)]
21 __Unknown(i32),
22}
23
24#[cfg(feature = "v4_14")]
25#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
26#[doc(hidden)]
27impl IntoGlib for AccessibleAnnouncementPriority {
28 type GlibType = ffi::GtkAccessibleAnnouncementPriority;
29
30 #[inline]
31 fn into_glib(self) -> ffi::GtkAccessibleAnnouncementPriority {
32 match self {
33 Self::Low => ffi::GTK_ACCESSIBLE_ANNOUNCEMENT_PRIORITY_LOW,
34 Self::Medium => ffi::GTK_ACCESSIBLE_ANNOUNCEMENT_PRIORITY_MEDIUM,
35 Self::High => ffi::GTK_ACCESSIBLE_ANNOUNCEMENT_PRIORITY_HIGH,
36 Self::__Unknown(value) => value,
37 }
38 }
39}
40
41#[cfg(feature = "v4_14")]
42#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
43#[doc(hidden)]
44impl FromGlib<ffi::GtkAccessibleAnnouncementPriority> for AccessibleAnnouncementPriority {
45 #[inline]
46 unsafe fn from_glib(value: ffi::GtkAccessibleAnnouncementPriority) -> Self {
47 skip_assert_initialized!();
48
49 match value {
50 ffi::GTK_ACCESSIBLE_ANNOUNCEMENT_PRIORITY_LOW => Self::Low,
51 ffi::GTK_ACCESSIBLE_ANNOUNCEMENT_PRIORITY_MEDIUM => Self::Medium,
52 ffi::GTK_ACCESSIBLE_ANNOUNCEMENT_PRIORITY_HIGH => Self::High,
53 value => Self::__Unknown(value),
54 }
55 }
56}
57
58#[cfg(feature = "v4_14")]
59#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
60impl StaticType for AccessibleAnnouncementPriority {
61 #[inline]
62 #[doc(alias = "gtk_accessible_announcement_priority_get_type")]
63 fn static_type() -> glib::Type {
64 unsafe { from_glib(ffi::gtk_accessible_announcement_priority_get_type()) }
65 }
66}
67
68#[cfg(feature = "v4_14")]
69#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
70impl glib::HasParamSpec for AccessibleAnnouncementPriority {
71 type ParamSpec = glib::ParamSpecEnum;
72 type SetValue = Self;
73 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
74
75 fn param_spec_builder() -> Self::BuilderFn {
76 Self::ParamSpec::builder_with_default
77 }
78}
79
80#[cfg(feature = "v4_14")]
81#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
82impl glib::value::ValueType for AccessibleAnnouncementPriority {
83 type Type = Self;
84}
85
86#[cfg(feature = "v4_14")]
87#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
88unsafe impl<'a> glib::value::FromValue<'a> for AccessibleAnnouncementPriority {
89 type Checker = glib::value::GenericValueTypeChecker<Self>;
90
91 #[inline]
92 unsafe fn from_value(value: &'a glib::Value) -> Self {
93 skip_assert_initialized!();
94 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
95 }
96}
97
98#[cfg(feature = "v4_14")]
99#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
100impl ToValue for AccessibleAnnouncementPriority {
101 #[inline]
102 fn to_value(&self) -> glib::Value {
103 let mut value = glib::Value::for_value_type::<Self>();
104 unsafe {
105 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
106 }
107 value
108 }
109
110 #[inline]
111 fn value_type(&self) -> glib::Type {
112 Self::static_type()
113 }
114}
115
116#[cfg(feature = "v4_14")]
117#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
118impl From<AccessibleAnnouncementPriority> for glib::Value {
119 #[inline]
120 fn from(v: AccessibleAnnouncementPriority) -> Self {
121 skip_assert_initialized!();
122 ToValue::to_value(&v)
123 }
124}
125
126#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
127#[non_exhaustive]
128#[doc(alias = "GtkAccessibleAutocomplete")]
129pub enum AccessibleAutocomplete {
130 #[doc(alias = "GTK_ACCESSIBLE_AUTOCOMPLETE_NONE")]
131 None,
132 #[doc(alias = "GTK_ACCESSIBLE_AUTOCOMPLETE_INLINE")]
133 Inline,
134 #[doc(alias = "GTK_ACCESSIBLE_AUTOCOMPLETE_LIST")]
135 List,
136 #[doc(alias = "GTK_ACCESSIBLE_AUTOCOMPLETE_BOTH")]
137 Both,
138 #[doc(hidden)]
139 __Unknown(i32),
140}
141
142#[doc(hidden)]
143impl IntoGlib for AccessibleAutocomplete {
144 type GlibType = ffi::GtkAccessibleAutocomplete;
145
146 #[inline]
147 fn into_glib(self) -> ffi::GtkAccessibleAutocomplete {
148 match self {
149 Self::None => ffi::GTK_ACCESSIBLE_AUTOCOMPLETE_NONE,
150 Self::Inline => ffi::GTK_ACCESSIBLE_AUTOCOMPLETE_INLINE,
151 Self::List => ffi::GTK_ACCESSIBLE_AUTOCOMPLETE_LIST,
152 Self::Both => ffi::GTK_ACCESSIBLE_AUTOCOMPLETE_BOTH,
153 Self::__Unknown(value) => value,
154 }
155 }
156}
157
158#[doc(hidden)]
159impl FromGlib<ffi::GtkAccessibleAutocomplete> for AccessibleAutocomplete {
160 #[inline]
161 unsafe fn from_glib(value: ffi::GtkAccessibleAutocomplete) -> Self {
162 skip_assert_initialized!();
163
164 match value {
165 ffi::GTK_ACCESSIBLE_AUTOCOMPLETE_NONE => Self::None,
166 ffi::GTK_ACCESSIBLE_AUTOCOMPLETE_INLINE => Self::Inline,
167 ffi::GTK_ACCESSIBLE_AUTOCOMPLETE_LIST => Self::List,
168 ffi::GTK_ACCESSIBLE_AUTOCOMPLETE_BOTH => Self::Both,
169 value => Self::__Unknown(value),
170 }
171 }
172}
173
174impl StaticType for AccessibleAutocomplete {
175 #[inline]
176 #[doc(alias = "gtk_accessible_autocomplete_get_type")]
177 fn static_type() -> glib::Type {
178 unsafe { from_glib(ffi::gtk_accessible_autocomplete_get_type()) }
179 }
180}
181
182impl glib::HasParamSpec for AccessibleAutocomplete {
183 type ParamSpec = glib::ParamSpecEnum;
184 type SetValue = Self;
185 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
186
187 fn param_spec_builder() -> Self::BuilderFn {
188 Self::ParamSpec::builder_with_default
189 }
190}
191
192impl glib::value::ValueType for AccessibleAutocomplete {
193 type Type = Self;
194}
195
196unsafe impl<'a> glib::value::FromValue<'a> for AccessibleAutocomplete {
197 type Checker = glib::value::GenericValueTypeChecker<Self>;
198
199 #[inline]
200 unsafe fn from_value(value: &'a glib::Value) -> Self {
201 skip_assert_initialized!();
202 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
203 }
204}
205
206impl ToValue for AccessibleAutocomplete {
207 #[inline]
208 fn to_value(&self) -> glib::Value {
209 let mut value = glib::Value::for_value_type::<Self>();
210 unsafe {
211 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
212 }
213 value
214 }
215
216 #[inline]
217 fn value_type(&self) -> glib::Type {
218 Self::static_type()
219 }
220}
221
222impl From<AccessibleAutocomplete> for glib::Value {
223 #[inline]
224 fn from(v: AccessibleAutocomplete) -> Self {
225 skip_assert_initialized!();
226 ToValue::to_value(&v)
227 }
228}
229
230#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
231#[non_exhaustive]
232#[doc(alias = "GtkAccessibleInvalidState")]
233pub enum AccessibleInvalidState {
234 #[doc(alias = "GTK_ACCESSIBLE_INVALID_FALSE")]
235 False,
236 #[doc(alias = "GTK_ACCESSIBLE_INVALID_TRUE")]
237 True,
238 #[doc(alias = "GTK_ACCESSIBLE_INVALID_GRAMMAR")]
239 Grammar,
240 #[doc(alias = "GTK_ACCESSIBLE_INVALID_SPELLING")]
241 Spelling,
242 #[doc(hidden)]
243 __Unknown(i32),
244}
245
246#[doc(hidden)]
247impl IntoGlib for AccessibleInvalidState {
248 type GlibType = ffi::GtkAccessibleInvalidState;
249
250 #[inline]
251 fn into_glib(self) -> ffi::GtkAccessibleInvalidState {
252 match self {
253 Self::False => ffi::GTK_ACCESSIBLE_INVALID_FALSE,
254 Self::True => ffi::GTK_ACCESSIBLE_INVALID_TRUE,
255 Self::Grammar => ffi::GTK_ACCESSIBLE_INVALID_GRAMMAR,
256 Self::Spelling => ffi::GTK_ACCESSIBLE_INVALID_SPELLING,
257 Self::__Unknown(value) => value,
258 }
259 }
260}
261
262#[doc(hidden)]
263impl FromGlib<ffi::GtkAccessibleInvalidState> for AccessibleInvalidState {
264 #[inline]
265 unsafe fn from_glib(value: ffi::GtkAccessibleInvalidState) -> Self {
266 skip_assert_initialized!();
267
268 match value {
269 ffi::GTK_ACCESSIBLE_INVALID_FALSE => Self::False,
270 ffi::GTK_ACCESSIBLE_INVALID_TRUE => Self::True,
271 ffi::GTK_ACCESSIBLE_INVALID_GRAMMAR => Self::Grammar,
272 ffi::GTK_ACCESSIBLE_INVALID_SPELLING => Self::Spelling,
273 value => Self::__Unknown(value),
274 }
275 }
276}
277
278impl StaticType for AccessibleInvalidState {
279 #[inline]
280 #[doc(alias = "gtk_accessible_invalid_state_get_type")]
281 fn static_type() -> glib::Type {
282 unsafe { from_glib(ffi::gtk_accessible_invalid_state_get_type()) }
283 }
284}
285
286impl glib::HasParamSpec for AccessibleInvalidState {
287 type ParamSpec = glib::ParamSpecEnum;
288 type SetValue = Self;
289 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
290
291 fn param_spec_builder() -> Self::BuilderFn {
292 Self::ParamSpec::builder_with_default
293 }
294}
295
296impl glib::value::ValueType for AccessibleInvalidState {
297 type Type = Self;
298}
299
300unsafe impl<'a> glib::value::FromValue<'a> for AccessibleInvalidState {
301 type Checker = glib::value::GenericValueTypeChecker<Self>;
302
303 #[inline]
304 unsafe fn from_value(value: &'a glib::Value) -> Self {
305 skip_assert_initialized!();
306 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
307 }
308}
309
310impl ToValue for AccessibleInvalidState {
311 #[inline]
312 fn to_value(&self) -> glib::Value {
313 let mut value = glib::Value::for_value_type::<Self>();
314 unsafe {
315 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
316 }
317 value
318 }
319
320 #[inline]
321 fn value_type(&self) -> glib::Type {
322 Self::static_type()
323 }
324}
325
326impl From<AccessibleInvalidState> for glib::Value {
327 #[inline]
328 fn from(v: AccessibleInvalidState) -> Self {
329 skip_assert_initialized!();
330 ToValue::to_value(&v)
331 }
332}
333
334#[cfg(feature = "v4_10")]
335#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
336#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
337#[non_exhaustive]
338#[doc(alias = "GtkAccessiblePlatformState")]
339pub enum AccessiblePlatformState {
340 #[doc(alias = "GTK_ACCESSIBLE_PLATFORM_STATE_FOCUSABLE")]
341 Focusable,
342 #[doc(alias = "GTK_ACCESSIBLE_PLATFORM_STATE_FOCUSED")]
343 Focused,
344 #[doc(alias = "GTK_ACCESSIBLE_PLATFORM_STATE_ACTIVE")]
345 Active,
346 #[doc(hidden)]
347 __Unknown(i32),
348}
349
350#[cfg(feature = "v4_10")]
351#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
352#[doc(hidden)]
353impl IntoGlib for AccessiblePlatformState {
354 type GlibType = ffi::GtkAccessiblePlatformState;
355
356 #[inline]
357 fn into_glib(self) -> ffi::GtkAccessiblePlatformState {
358 match self {
359 Self::Focusable => ffi::GTK_ACCESSIBLE_PLATFORM_STATE_FOCUSABLE,
360 Self::Focused => ffi::GTK_ACCESSIBLE_PLATFORM_STATE_FOCUSED,
361 Self::Active => ffi::GTK_ACCESSIBLE_PLATFORM_STATE_ACTIVE,
362 Self::__Unknown(value) => value,
363 }
364 }
365}
366
367#[cfg(feature = "v4_10")]
368#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
369#[doc(hidden)]
370impl FromGlib<ffi::GtkAccessiblePlatformState> for AccessiblePlatformState {
371 #[inline]
372 unsafe fn from_glib(value: ffi::GtkAccessiblePlatformState) -> Self {
373 skip_assert_initialized!();
374
375 match value {
376 ffi::GTK_ACCESSIBLE_PLATFORM_STATE_FOCUSABLE => Self::Focusable,
377 ffi::GTK_ACCESSIBLE_PLATFORM_STATE_FOCUSED => Self::Focused,
378 ffi::GTK_ACCESSIBLE_PLATFORM_STATE_ACTIVE => Self::Active,
379 value => Self::__Unknown(value),
380 }
381 }
382}
383
384#[cfg(feature = "v4_10")]
385#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
386impl StaticType for AccessiblePlatformState {
387 #[inline]
388 #[doc(alias = "gtk_accessible_platform_state_get_type")]
389 fn static_type() -> glib::Type {
390 unsafe { from_glib(ffi::gtk_accessible_platform_state_get_type()) }
391 }
392}
393
394#[cfg(feature = "v4_10")]
395#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
396impl glib::HasParamSpec for AccessiblePlatformState {
397 type ParamSpec = glib::ParamSpecEnum;
398 type SetValue = Self;
399 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
400
401 fn param_spec_builder() -> Self::BuilderFn {
402 Self::ParamSpec::builder_with_default
403 }
404}
405
406#[cfg(feature = "v4_10")]
407#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
408impl glib::value::ValueType for AccessiblePlatformState {
409 type Type = Self;
410}
411
412#[cfg(feature = "v4_10")]
413#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
414unsafe impl<'a> glib::value::FromValue<'a> for AccessiblePlatformState {
415 type Checker = glib::value::GenericValueTypeChecker<Self>;
416
417 #[inline]
418 unsafe fn from_value(value: &'a glib::Value) -> Self {
419 skip_assert_initialized!();
420 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
421 }
422}
423
424#[cfg(feature = "v4_10")]
425#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
426impl ToValue for AccessiblePlatformState {
427 #[inline]
428 fn to_value(&self) -> glib::Value {
429 let mut value = glib::Value::for_value_type::<Self>();
430 unsafe {
431 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
432 }
433 value
434 }
435
436 #[inline]
437 fn value_type(&self) -> glib::Type {
438 Self::static_type()
439 }
440}
441
442#[cfg(feature = "v4_10")]
443#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
444impl From<AccessiblePlatformState> for glib::Value {
445 #[inline]
446 fn from(v: AccessiblePlatformState) -> Self {
447 skip_assert_initialized!();
448 ToValue::to_value(&v)
449 }
450}
451
452#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
453#[non_exhaustive]
454#[doc(alias = "GtkAccessibleProperty")]
455pub enum AccessibleProperty {
456 #[doc(alias = "GTK_ACCESSIBLE_PROPERTY_AUTOCOMPLETE")]
457 Autocomplete,
458 #[doc(alias = "GTK_ACCESSIBLE_PROPERTY_DESCRIPTION")]
459 Description,
460 #[doc(alias = "GTK_ACCESSIBLE_PROPERTY_HAS_POPUP")]
461 HasPopup,
462 #[doc(alias = "GTK_ACCESSIBLE_PROPERTY_KEY_SHORTCUTS")]
463 KeyShortcuts,
464 #[doc(alias = "GTK_ACCESSIBLE_PROPERTY_LABEL")]
465 Label,
466 #[doc(alias = "GTK_ACCESSIBLE_PROPERTY_LEVEL")]
467 Level,
468 #[doc(alias = "GTK_ACCESSIBLE_PROPERTY_MODAL")]
469 Modal,
470 #[doc(alias = "GTK_ACCESSIBLE_PROPERTY_MULTI_LINE")]
471 MultiLine,
472 #[doc(alias = "GTK_ACCESSIBLE_PROPERTY_MULTI_SELECTABLE")]
473 MultiSelectable,
474 #[doc(alias = "GTK_ACCESSIBLE_PROPERTY_ORIENTATION")]
475 Orientation,
476 #[doc(alias = "GTK_ACCESSIBLE_PROPERTY_PLACEHOLDER")]
477 Placeholder,
478 #[doc(alias = "GTK_ACCESSIBLE_PROPERTY_READ_ONLY")]
479 ReadOnly,
480 #[doc(alias = "GTK_ACCESSIBLE_PROPERTY_REQUIRED")]
481 Required,
482 #[doc(alias = "GTK_ACCESSIBLE_PROPERTY_ROLE_DESCRIPTION")]
483 RoleDescription,
484 #[doc(alias = "GTK_ACCESSIBLE_PROPERTY_SORT")]
485 Sort,
486 #[doc(alias = "GTK_ACCESSIBLE_PROPERTY_VALUE_MAX")]
487 ValueMax,
488 #[doc(alias = "GTK_ACCESSIBLE_PROPERTY_VALUE_MIN")]
489 ValueMin,
490 #[doc(alias = "GTK_ACCESSIBLE_PROPERTY_VALUE_NOW")]
491 ValueNow,
492 #[doc(alias = "GTK_ACCESSIBLE_PROPERTY_VALUE_TEXT")]
493 ValueText,
494 #[cfg(feature = "v4_16")]
495 #[cfg_attr(docsrs, doc(cfg(feature = "v4_16")))]
496 #[doc(alias = "GTK_ACCESSIBLE_PROPERTY_HELP_TEXT")]
497 HelpText,
498 #[doc(hidden)]
499 __Unknown(i32),
500}
501
502impl AccessibleProperty {
503 #[doc(alias = "gtk_accessible_property_init_value")]
504 pub fn init_value(self, value: &mut glib::Value) {
505 assert_initialized_main_thread!();
506 unsafe {
507 ffi::gtk_accessible_property_init_value(self.into_glib(), value.to_glib_none_mut().0);
508 }
509 }
510}
511
512#[doc(hidden)]
513impl IntoGlib for AccessibleProperty {
514 type GlibType = ffi::GtkAccessibleProperty;
515
516 fn into_glib(self) -> ffi::GtkAccessibleProperty {
517 match self {
518 Self::Autocomplete => ffi::GTK_ACCESSIBLE_PROPERTY_AUTOCOMPLETE,
519 Self::Description => ffi::GTK_ACCESSIBLE_PROPERTY_DESCRIPTION,
520 Self::HasPopup => ffi::GTK_ACCESSIBLE_PROPERTY_HAS_POPUP,
521 Self::KeyShortcuts => ffi::GTK_ACCESSIBLE_PROPERTY_KEY_SHORTCUTS,
522 Self::Label => ffi::GTK_ACCESSIBLE_PROPERTY_LABEL,
523 Self::Level => ffi::GTK_ACCESSIBLE_PROPERTY_LEVEL,
524 Self::Modal => ffi::GTK_ACCESSIBLE_PROPERTY_MODAL,
525 Self::MultiLine => ffi::GTK_ACCESSIBLE_PROPERTY_MULTI_LINE,
526 Self::MultiSelectable => ffi::GTK_ACCESSIBLE_PROPERTY_MULTI_SELECTABLE,
527 Self::Orientation => ffi::GTK_ACCESSIBLE_PROPERTY_ORIENTATION,
528 Self::Placeholder => ffi::GTK_ACCESSIBLE_PROPERTY_PLACEHOLDER,
529 Self::ReadOnly => ffi::GTK_ACCESSIBLE_PROPERTY_READ_ONLY,
530 Self::Required => ffi::GTK_ACCESSIBLE_PROPERTY_REQUIRED,
531 Self::RoleDescription => ffi::GTK_ACCESSIBLE_PROPERTY_ROLE_DESCRIPTION,
532 Self::Sort => ffi::GTK_ACCESSIBLE_PROPERTY_SORT,
533 Self::ValueMax => ffi::GTK_ACCESSIBLE_PROPERTY_VALUE_MAX,
534 Self::ValueMin => ffi::GTK_ACCESSIBLE_PROPERTY_VALUE_MIN,
535 Self::ValueNow => ffi::GTK_ACCESSIBLE_PROPERTY_VALUE_NOW,
536 Self::ValueText => ffi::GTK_ACCESSIBLE_PROPERTY_VALUE_TEXT,
537 #[cfg(feature = "v4_16")]
538 Self::HelpText => ffi::GTK_ACCESSIBLE_PROPERTY_HELP_TEXT,
539 Self::__Unknown(value) => value,
540 }
541 }
542}
543
544#[doc(hidden)]
545impl FromGlib<ffi::GtkAccessibleProperty> for AccessibleProperty {
546 unsafe fn from_glib(value: ffi::GtkAccessibleProperty) -> Self {
547 skip_assert_initialized!();
548
549 match value {
550 ffi::GTK_ACCESSIBLE_PROPERTY_AUTOCOMPLETE => Self::Autocomplete,
551 ffi::GTK_ACCESSIBLE_PROPERTY_DESCRIPTION => Self::Description,
552 ffi::GTK_ACCESSIBLE_PROPERTY_HAS_POPUP => Self::HasPopup,
553 ffi::GTK_ACCESSIBLE_PROPERTY_KEY_SHORTCUTS => Self::KeyShortcuts,
554 ffi::GTK_ACCESSIBLE_PROPERTY_LABEL => Self::Label,
555 ffi::GTK_ACCESSIBLE_PROPERTY_LEVEL => Self::Level,
556 ffi::GTK_ACCESSIBLE_PROPERTY_MODAL => Self::Modal,
557 ffi::GTK_ACCESSIBLE_PROPERTY_MULTI_LINE => Self::MultiLine,
558 ffi::GTK_ACCESSIBLE_PROPERTY_MULTI_SELECTABLE => Self::MultiSelectable,
559 ffi::GTK_ACCESSIBLE_PROPERTY_ORIENTATION => Self::Orientation,
560 ffi::GTK_ACCESSIBLE_PROPERTY_PLACEHOLDER => Self::Placeholder,
561 ffi::GTK_ACCESSIBLE_PROPERTY_READ_ONLY => Self::ReadOnly,
562 ffi::GTK_ACCESSIBLE_PROPERTY_REQUIRED => Self::Required,
563 ffi::GTK_ACCESSIBLE_PROPERTY_ROLE_DESCRIPTION => Self::RoleDescription,
564 ffi::GTK_ACCESSIBLE_PROPERTY_SORT => Self::Sort,
565 ffi::GTK_ACCESSIBLE_PROPERTY_VALUE_MAX => Self::ValueMax,
566 ffi::GTK_ACCESSIBLE_PROPERTY_VALUE_MIN => Self::ValueMin,
567 ffi::GTK_ACCESSIBLE_PROPERTY_VALUE_NOW => Self::ValueNow,
568 ffi::GTK_ACCESSIBLE_PROPERTY_VALUE_TEXT => Self::ValueText,
569 #[cfg(feature = "v4_16")]
570 ffi::GTK_ACCESSIBLE_PROPERTY_HELP_TEXT => Self::HelpText,
571 value => Self::__Unknown(value),
572 }
573 }
574}
575
576impl StaticType for AccessibleProperty {
577 #[inline]
578 #[doc(alias = "gtk_accessible_property_get_type")]
579 fn static_type() -> glib::Type {
580 unsafe { from_glib(ffi::gtk_accessible_property_get_type()) }
581 }
582}
583
584impl glib::HasParamSpec for AccessibleProperty {
585 type ParamSpec = glib::ParamSpecEnum;
586 type SetValue = Self;
587 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
588
589 fn param_spec_builder() -> Self::BuilderFn {
590 Self::ParamSpec::builder_with_default
591 }
592}
593
594impl glib::value::ValueType for AccessibleProperty {
595 type Type = Self;
596}
597
598unsafe impl<'a> glib::value::FromValue<'a> for AccessibleProperty {
599 type Checker = glib::value::GenericValueTypeChecker<Self>;
600
601 #[inline]
602 unsafe fn from_value(value: &'a glib::Value) -> Self {
603 skip_assert_initialized!();
604 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
605 }
606}
607
608impl ToValue for AccessibleProperty {
609 #[inline]
610 fn to_value(&self) -> glib::Value {
611 let mut value = glib::Value::for_value_type::<Self>();
612 unsafe {
613 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
614 }
615 value
616 }
617
618 #[inline]
619 fn value_type(&self) -> glib::Type {
620 Self::static_type()
621 }
622}
623
624impl From<AccessibleProperty> for glib::Value {
625 #[inline]
626 fn from(v: AccessibleProperty) -> Self {
627 skip_assert_initialized!();
628 ToValue::to_value(&v)
629 }
630}
631
632#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
633#[non_exhaustive]
634#[doc(alias = "GtkAccessibleRelation")]
635pub enum AccessibleRelation {
636 #[doc(alias = "GTK_ACCESSIBLE_RELATION_ACTIVE_DESCENDANT")]
637 ActiveDescendant,
638 #[doc(alias = "GTK_ACCESSIBLE_RELATION_COL_COUNT")]
639 ColCount,
640 #[doc(alias = "GTK_ACCESSIBLE_RELATION_COL_INDEX")]
641 ColIndex,
642 #[doc(alias = "GTK_ACCESSIBLE_RELATION_COL_INDEX_TEXT")]
643 ColIndexText,
644 #[doc(alias = "GTK_ACCESSIBLE_RELATION_COL_SPAN")]
645 ColSpan,
646 #[doc(alias = "GTK_ACCESSIBLE_RELATION_CONTROLS")]
647 Controls,
648 #[doc(alias = "GTK_ACCESSIBLE_RELATION_DESCRIBED_BY")]
649 DescribedBy,
650 #[doc(alias = "GTK_ACCESSIBLE_RELATION_DETAILS")]
651 Details,
652 #[doc(alias = "GTK_ACCESSIBLE_RELATION_ERROR_MESSAGE")]
653 ErrorMessage,
654 #[doc(alias = "GTK_ACCESSIBLE_RELATION_FLOW_TO")]
655 FlowTo,
656 #[doc(alias = "GTK_ACCESSIBLE_RELATION_LABELLED_BY")]
657 LabelledBy,
658 #[doc(alias = "GTK_ACCESSIBLE_RELATION_OWNS")]
659 Owns,
660 #[doc(alias = "GTK_ACCESSIBLE_RELATION_POS_IN_SET")]
661 PosInSet,
662 #[doc(alias = "GTK_ACCESSIBLE_RELATION_ROW_COUNT")]
663 RowCount,
664 #[doc(alias = "GTK_ACCESSIBLE_RELATION_ROW_INDEX")]
665 RowIndex,
666 #[doc(alias = "GTK_ACCESSIBLE_RELATION_ROW_INDEX_TEXT")]
667 RowIndexText,
668 #[doc(alias = "GTK_ACCESSIBLE_RELATION_ROW_SPAN")]
669 RowSpan,
670 #[doc(alias = "GTK_ACCESSIBLE_RELATION_SET_SIZE")]
671 SetSize,
672 #[cfg(feature = "v4_18")]
673 #[cfg_attr(docsrs, doc(cfg(feature = "v4_18")))]
674 #[doc(alias = "GTK_ACCESSIBLE_RELATION_LABEL_FOR")]
675 LabelFor,
676 #[cfg(feature = "v4_18")]
677 #[cfg_attr(docsrs, doc(cfg(feature = "v4_18")))]
678 #[doc(alias = "GTK_ACCESSIBLE_RELATION_DESCRIPTION_FOR")]
679 DescriptionFor,
680 #[cfg(feature = "v4_18")]
681 #[cfg_attr(docsrs, doc(cfg(feature = "v4_18")))]
682 #[doc(alias = "GTK_ACCESSIBLE_RELATION_CONTROLLED_BY")]
683 ControlledBy,
684 #[cfg(feature = "v4_18")]
685 #[cfg_attr(docsrs, doc(cfg(feature = "v4_18")))]
686 #[doc(alias = "GTK_ACCESSIBLE_RELATION_DETAILS_FOR")]
687 DetailsFor,
688 #[cfg(feature = "v4_18")]
689 #[cfg_attr(docsrs, doc(cfg(feature = "v4_18")))]
690 #[doc(alias = "GTK_ACCESSIBLE_RELATION_ERROR_MESSAGE_FOR")]
691 ErrorMessageFor,
692 #[cfg(feature = "v4_18")]
693 #[cfg_attr(docsrs, doc(cfg(feature = "v4_18")))]
694 #[doc(alias = "GTK_ACCESSIBLE_RELATION_FLOW_FROM")]
695 FlowFrom,
696 #[doc(hidden)]
697 __Unknown(i32),
698}
699
700impl AccessibleRelation {
701 #[doc(alias = "gtk_accessible_relation_init_value")]
702 pub fn init_value(self, value: &mut glib::Value) {
703 assert_initialized_main_thread!();
704 unsafe {
705 ffi::gtk_accessible_relation_init_value(self.into_glib(), value.to_glib_none_mut().0);
706 }
707 }
708}
709
710#[doc(hidden)]
711impl IntoGlib for AccessibleRelation {
712 type GlibType = ffi::GtkAccessibleRelation;
713
714 fn into_glib(self) -> ffi::GtkAccessibleRelation {
715 match self {
716 Self::ActiveDescendant => ffi::GTK_ACCESSIBLE_RELATION_ACTIVE_DESCENDANT,
717 Self::ColCount => ffi::GTK_ACCESSIBLE_RELATION_COL_COUNT,
718 Self::ColIndex => ffi::GTK_ACCESSIBLE_RELATION_COL_INDEX,
719 Self::ColIndexText => ffi::GTK_ACCESSIBLE_RELATION_COL_INDEX_TEXT,
720 Self::ColSpan => ffi::GTK_ACCESSIBLE_RELATION_COL_SPAN,
721 Self::Controls => ffi::GTK_ACCESSIBLE_RELATION_CONTROLS,
722 Self::DescribedBy => ffi::GTK_ACCESSIBLE_RELATION_DESCRIBED_BY,
723 Self::Details => ffi::GTK_ACCESSIBLE_RELATION_DETAILS,
724 Self::ErrorMessage => ffi::GTK_ACCESSIBLE_RELATION_ERROR_MESSAGE,
725 Self::FlowTo => ffi::GTK_ACCESSIBLE_RELATION_FLOW_TO,
726 Self::LabelledBy => ffi::GTK_ACCESSIBLE_RELATION_LABELLED_BY,
727 Self::Owns => ffi::GTK_ACCESSIBLE_RELATION_OWNS,
728 Self::PosInSet => ffi::GTK_ACCESSIBLE_RELATION_POS_IN_SET,
729 Self::RowCount => ffi::GTK_ACCESSIBLE_RELATION_ROW_COUNT,
730 Self::RowIndex => ffi::GTK_ACCESSIBLE_RELATION_ROW_INDEX,
731 Self::RowIndexText => ffi::GTK_ACCESSIBLE_RELATION_ROW_INDEX_TEXT,
732 Self::RowSpan => ffi::GTK_ACCESSIBLE_RELATION_ROW_SPAN,
733 Self::SetSize => ffi::GTK_ACCESSIBLE_RELATION_SET_SIZE,
734 #[cfg(feature = "v4_18")]
735 Self::LabelFor => ffi::GTK_ACCESSIBLE_RELATION_LABEL_FOR,
736 #[cfg(feature = "v4_18")]
737 Self::DescriptionFor => ffi::GTK_ACCESSIBLE_RELATION_DESCRIPTION_FOR,
738 #[cfg(feature = "v4_18")]
739 Self::ControlledBy => ffi::GTK_ACCESSIBLE_RELATION_CONTROLLED_BY,
740 #[cfg(feature = "v4_18")]
741 Self::DetailsFor => ffi::GTK_ACCESSIBLE_RELATION_DETAILS_FOR,
742 #[cfg(feature = "v4_18")]
743 Self::ErrorMessageFor => ffi::GTK_ACCESSIBLE_RELATION_ERROR_MESSAGE_FOR,
744 #[cfg(feature = "v4_18")]
745 Self::FlowFrom => ffi::GTK_ACCESSIBLE_RELATION_FLOW_FROM,
746 Self::__Unknown(value) => value,
747 }
748 }
749}
750
751#[doc(hidden)]
752impl FromGlib<ffi::GtkAccessibleRelation> for AccessibleRelation {
753 unsafe fn from_glib(value: ffi::GtkAccessibleRelation) -> Self {
754 skip_assert_initialized!();
755
756 match value {
757 ffi::GTK_ACCESSIBLE_RELATION_ACTIVE_DESCENDANT => Self::ActiveDescendant,
758 ffi::GTK_ACCESSIBLE_RELATION_COL_COUNT => Self::ColCount,
759 ffi::GTK_ACCESSIBLE_RELATION_COL_INDEX => Self::ColIndex,
760 ffi::GTK_ACCESSIBLE_RELATION_COL_INDEX_TEXT => Self::ColIndexText,
761 ffi::GTK_ACCESSIBLE_RELATION_COL_SPAN => Self::ColSpan,
762 ffi::GTK_ACCESSIBLE_RELATION_CONTROLS => Self::Controls,
763 ffi::GTK_ACCESSIBLE_RELATION_DESCRIBED_BY => Self::DescribedBy,
764 ffi::GTK_ACCESSIBLE_RELATION_DETAILS => Self::Details,
765 ffi::GTK_ACCESSIBLE_RELATION_ERROR_MESSAGE => Self::ErrorMessage,
766 ffi::GTK_ACCESSIBLE_RELATION_FLOW_TO => Self::FlowTo,
767 ffi::GTK_ACCESSIBLE_RELATION_LABELLED_BY => Self::LabelledBy,
768 ffi::GTK_ACCESSIBLE_RELATION_OWNS => Self::Owns,
769 ffi::GTK_ACCESSIBLE_RELATION_POS_IN_SET => Self::PosInSet,
770 ffi::GTK_ACCESSIBLE_RELATION_ROW_COUNT => Self::RowCount,
771 ffi::GTK_ACCESSIBLE_RELATION_ROW_INDEX => Self::RowIndex,
772 ffi::GTK_ACCESSIBLE_RELATION_ROW_INDEX_TEXT => Self::RowIndexText,
773 ffi::GTK_ACCESSIBLE_RELATION_ROW_SPAN => Self::RowSpan,
774 ffi::GTK_ACCESSIBLE_RELATION_SET_SIZE => Self::SetSize,
775 #[cfg(feature = "v4_18")]
776 ffi::GTK_ACCESSIBLE_RELATION_LABEL_FOR => Self::LabelFor,
777 #[cfg(feature = "v4_18")]
778 ffi::GTK_ACCESSIBLE_RELATION_DESCRIPTION_FOR => Self::DescriptionFor,
779 #[cfg(feature = "v4_18")]
780 ffi::GTK_ACCESSIBLE_RELATION_CONTROLLED_BY => Self::ControlledBy,
781 #[cfg(feature = "v4_18")]
782 ffi::GTK_ACCESSIBLE_RELATION_DETAILS_FOR => Self::DetailsFor,
783 #[cfg(feature = "v4_18")]
784 ffi::GTK_ACCESSIBLE_RELATION_ERROR_MESSAGE_FOR => Self::ErrorMessageFor,
785 #[cfg(feature = "v4_18")]
786 ffi::GTK_ACCESSIBLE_RELATION_FLOW_FROM => Self::FlowFrom,
787 value => Self::__Unknown(value),
788 }
789 }
790}
791
792impl StaticType for AccessibleRelation {
793 #[inline]
794 #[doc(alias = "gtk_accessible_relation_get_type")]
795 fn static_type() -> glib::Type {
796 unsafe { from_glib(ffi::gtk_accessible_relation_get_type()) }
797 }
798}
799
800impl glib::HasParamSpec for AccessibleRelation {
801 type ParamSpec = glib::ParamSpecEnum;
802 type SetValue = Self;
803 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
804
805 fn param_spec_builder() -> Self::BuilderFn {
806 Self::ParamSpec::builder_with_default
807 }
808}
809
810impl glib::value::ValueType for AccessibleRelation {
811 type Type = Self;
812}
813
814unsafe impl<'a> glib::value::FromValue<'a> for AccessibleRelation {
815 type Checker = glib::value::GenericValueTypeChecker<Self>;
816
817 #[inline]
818 unsafe fn from_value(value: &'a glib::Value) -> Self {
819 skip_assert_initialized!();
820 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
821 }
822}
823
824impl ToValue for AccessibleRelation {
825 #[inline]
826 fn to_value(&self) -> glib::Value {
827 let mut value = glib::Value::for_value_type::<Self>();
828 unsafe {
829 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
830 }
831 value
832 }
833
834 #[inline]
835 fn value_type(&self) -> glib::Type {
836 Self::static_type()
837 }
838}
839
840impl From<AccessibleRelation> for glib::Value {
841 #[inline]
842 fn from(v: AccessibleRelation) -> Self {
843 skip_assert_initialized!();
844 ToValue::to_value(&v)
845 }
846}
847
848#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
849#[non_exhaustive]
850#[doc(alias = "GtkAccessibleRole")]
851pub enum AccessibleRole {
852 #[doc(alias = "GTK_ACCESSIBLE_ROLE_ALERT")]
853 Alert,
854 #[doc(alias = "GTK_ACCESSIBLE_ROLE_ALERT_DIALOG")]
855 AlertDialog,
856 #[doc(alias = "GTK_ACCESSIBLE_ROLE_BANNER")]
857 Banner,
858 #[doc(alias = "GTK_ACCESSIBLE_ROLE_BUTTON")]
859 Button,
860 #[doc(alias = "GTK_ACCESSIBLE_ROLE_CAPTION")]
861 Caption,
862 #[doc(alias = "GTK_ACCESSIBLE_ROLE_CELL")]
863 Cell,
864 #[doc(alias = "GTK_ACCESSIBLE_ROLE_CHECKBOX")]
865 Checkbox,
866 #[doc(alias = "GTK_ACCESSIBLE_ROLE_COLUMN_HEADER")]
867 ColumnHeader,
868 #[doc(alias = "GTK_ACCESSIBLE_ROLE_COMBO_BOX")]
869 ComboBox,
870 #[doc(alias = "GTK_ACCESSIBLE_ROLE_COMMAND")]
871 Command,
872 #[doc(alias = "GTK_ACCESSIBLE_ROLE_COMPOSITE")]
873 Composite,
874 #[doc(alias = "GTK_ACCESSIBLE_ROLE_DIALOG")]
875 Dialog,
876 #[doc(alias = "GTK_ACCESSIBLE_ROLE_DOCUMENT")]
877 Document,
878 #[doc(alias = "GTK_ACCESSIBLE_ROLE_FEED")]
879 Feed,
880 #[doc(alias = "GTK_ACCESSIBLE_ROLE_FORM")]
881 Form,
882 #[doc(alias = "GTK_ACCESSIBLE_ROLE_GENERIC")]
883 Generic,
884 #[doc(alias = "GTK_ACCESSIBLE_ROLE_GRID")]
885 Grid,
886 #[doc(alias = "GTK_ACCESSIBLE_ROLE_GRID_CELL")]
887 GridCell,
888 #[doc(alias = "GTK_ACCESSIBLE_ROLE_GROUP")]
889 Group,
890 #[doc(alias = "GTK_ACCESSIBLE_ROLE_HEADING")]
891 Heading,
892 #[doc(alias = "GTK_ACCESSIBLE_ROLE_IMG")]
893 Img,
894 #[doc(alias = "GTK_ACCESSIBLE_ROLE_INPUT")]
895 Input,
896 #[doc(alias = "GTK_ACCESSIBLE_ROLE_LABEL")]
897 Label,
898 #[doc(alias = "GTK_ACCESSIBLE_ROLE_LANDMARK")]
899 Landmark,
900 #[doc(alias = "GTK_ACCESSIBLE_ROLE_LEGEND")]
901 Legend,
902 #[doc(alias = "GTK_ACCESSIBLE_ROLE_LINK")]
903 Link,
904 #[doc(alias = "GTK_ACCESSIBLE_ROLE_LIST")]
905 List,
906 #[doc(alias = "GTK_ACCESSIBLE_ROLE_LIST_BOX")]
907 ListBox,
908 #[doc(alias = "GTK_ACCESSIBLE_ROLE_LIST_ITEM")]
909 ListItem,
910 #[doc(alias = "GTK_ACCESSIBLE_ROLE_LOG")]
911 Log,
912 #[doc(alias = "GTK_ACCESSIBLE_ROLE_MAIN")]
913 Main,
914 #[doc(alias = "GTK_ACCESSIBLE_ROLE_MARQUEE")]
915 Marquee,
916 #[doc(alias = "GTK_ACCESSIBLE_ROLE_MATH")]
917 Math,
918 #[doc(alias = "GTK_ACCESSIBLE_ROLE_METER")]
919 Meter,
920 #[doc(alias = "GTK_ACCESSIBLE_ROLE_MENU")]
921 Menu,
922 #[doc(alias = "GTK_ACCESSIBLE_ROLE_MENU_BAR")]
923 MenuBar,
924 #[doc(alias = "GTK_ACCESSIBLE_ROLE_MENU_ITEM")]
925 MenuItem,
926 #[doc(alias = "GTK_ACCESSIBLE_ROLE_MENU_ITEM_CHECKBOX")]
927 MenuItemCheckbox,
928 #[doc(alias = "GTK_ACCESSIBLE_ROLE_MENU_ITEM_RADIO")]
929 MenuItemRadio,
930 #[doc(alias = "GTK_ACCESSIBLE_ROLE_NAVIGATION")]
931 Navigation,
932 #[doc(alias = "GTK_ACCESSIBLE_ROLE_NONE")]
933 None,
934 #[doc(alias = "GTK_ACCESSIBLE_ROLE_NOTE")]
935 Note,
936 #[doc(alias = "GTK_ACCESSIBLE_ROLE_OPTION")]
937 Option,
938 #[doc(alias = "GTK_ACCESSIBLE_ROLE_PRESENTATION")]
939 Presentation,
940 #[doc(alias = "GTK_ACCESSIBLE_ROLE_PROGRESS_BAR")]
941 ProgressBar,
942 #[doc(alias = "GTK_ACCESSIBLE_ROLE_RADIO")]
943 Radio,
944 #[doc(alias = "GTK_ACCESSIBLE_ROLE_RADIO_GROUP")]
945 RadioGroup,
946 #[doc(alias = "GTK_ACCESSIBLE_ROLE_RANGE")]
947 Range,
948 #[doc(alias = "GTK_ACCESSIBLE_ROLE_REGION")]
949 Region,
950 #[doc(alias = "GTK_ACCESSIBLE_ROLE_ROW")]
951 Row,
952 #[doc(alias = "GTK_ACCESSIBLE_ROLE_ROW_GROUP")]
953 RowGroup,
954 #[doc(alias = "GTK_ACCESSIBLE_ROLE_ROW_HEADER")]
955 RowHeader,
956 #[doc(alias = "GTK_ACCESSIBLE_ROLE_SCROLLBAR")]
957 Scrollbar,
958 #[doc(alias = "GTK_ACCESSIBLE_ROLE_SEARCH")]
959 Search,
960 #[doc(alias = "GTK_ACCESSIBLE_ROLE_SEARCH_BOX")]
961 SearchBox,
962 #[doc(alias = "GTK_ACCESSIBLE_ROLE_SECTION")]
963 Section,
964 #[doc(alias = "GTK_ACCESSIBLE_ROLE_SECTION_HEAD")]
965 SectionHead,
966 #[doc(alias = "GTK_ACCESSIBLE_ROLE_SELECT")]
967 Select,
968 #[doc(alias = "GTK_ACCESSIBLE_ROLE_SEPARATOR")]
969 Separator,
970 #[doc(alias = "GTK_ACCESSIBLE_ROLE_SLIDER")]
971 Slider,
972 #[doc(alias = "GTK_ACCESSIBLE_ROLE_SPIN_BUTTON")]
973 SpinButton,
974 #[doc(alias = "GTK_ACCESSIBLE_ROLE_STATUS")]
975 Status,
976 #[doc(alias = "GTK_ACCESSIBLE_ROLE_STRUCTURE")]
977 Structure,
978 #[doc(alias = "GTK_ACCESSIBLE_ROLE_SWITCH")]
979 Switch,
980 #[doc(alias = "GTK_ACCESSIBLE_ROLE_TAB")]
981 Tab,
982 #[doc(alias = "GTK_ACCESSIBLE_ROLE_TABLE")]
983 Table,
984 #[doc(alias = "GTK_ACCESSIBLE_ROLE_TAB_LIST")]
985 TabList,
986 #[doc(alias = "GTK_ACCESSIBLE_ROLE_TAB_PANEL")]
987 TabPanel,
988 #[doc(alias = "GTK_ACCESSIBLE_ROLE_TEXT_BOX")]
989 TextBox,
990 #[doc(alias = "GTK_ACCESSIBLE_ROLE_TIME")]
991 Time,
992 #[doc(alias = "GTK_ACCESSIBLE_ROLE_TIMER")]
993 Timer,
994 #[doc(alias = "GTK_ACCESSIBLE_ROLE_TOOLBAR")]
995 Toolbar,
996 #[doc(alias = "GTK_ACCESSIBLE_ROLE_TOOLTIP")]
997 Tooltip,
998 #[doc(alias = "GTK_ACCESSIBLE_ROLE_TREE")]
999 Tree,
1000 #[doc(alias = "GTK_ACCESSIBLE_ROLE_TREE_GRID")]
1001 TreeGrid,
1002 #[doc(alias = "GTK_ACCESSIBLE_ROLE_TREE_ITEM")]
1003 TreeItem,
1004 #[doc(alias = "GTK_ACCESSIBLE_ROLE_WIDGET")]
1005 Widget,
1006 #[doc(alias = "GTK_ACCESSIBLE_ROLE_WINDOW")]
1007 Window,
1008 #[cfg(feature = "v4_10")]
1009 #[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
1010 #[doc(alias = "GTK_ACCESSIBLE_ROLE_TOGGLE_BUTTON")]
1011 ToggleButton,
1012 #[cfg(feature = "v4_12")]
1013 #[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
1014 #[doc(alias = "GTK_ACCESSIBLE_ROLE_APPLICATION")]
1015 Application,
1016 #[cfg(feature = "v4_14")]
1017 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1018 #[doc(alias = "GTK_ACCESSIBLE_ROLE_PARAGRAPH")]
1019 Paragraph,
1020 #[cfg(feature = "v4_14")]
1021 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1022 #[doc(alias = "GTK_ACCESSIBLE_ROLE_BLOCK_QUOTE")]
1023 BlockQuote,
1024 #[cfg(feature = "v4_14")]
1025 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1026 #[doc(alias = "GTK_ACCESSIBLE_ROLE_ARTICLE")]
1027 Article,
1028 #[cfg(feature = "v4_14")]
1029 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1030 #[doc(alias = "GTK_ACCESSIBLE_ROLE_COMMENT")]
1031 Comment,
1032 #[cfg(feature = "v4_14")]
1033 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1034 #[doc(alias = "GTK_ACCESSIBLE_ROLE_TERMINAL")]
1035 Terminal,
1036 #[doc(hidden)]
1037 __Unknown(i32),
1038}
1039
1040#[doc(hidden)]
1041impl IntoGlib for AccessibleRole {
1042 type GlibType = ffi::GtkAccessibleRole;
1043
1044 fn into_glib(self) -> ffi::GtkAccessibleRole {
1045 match self {
1046 Self::Alert => ffi::GTK_ACCESSIBLE_ROLE_ALERT,
1047 Self::AlertDialog => ffi::GTK_ACCESSIBLE_ROLE_ALERT_DIALOG,
1048 Self::Banner => ffi::GTK_ACCESSIBLE_ROLE_BANNER,
1049 Self::Button => ffi::GTK_ACCESSIBLE_ROLE_BUTTON,
1050 Self::Caption => ffi::GTK_ACCESSIBLE_ROLE_CAPTION,
1051 Self::Cell => ffi::GTK_ACCESSIBLE_ROLE_CELL,
1052 Self::Checkbox => ffi::GTK_ACCESSIBLE_ROLE_CHECKBOX,
1053 Self::ColumnHeader => ffi::GTK_ACCESSIBLE_ROLE_COLUMN_HEADER,
1054 Self::ComboBox => ffi::GTK_ACCESSIBLE_ROLE_COMBO_BOX,
1055 Self::Command => ffi::GTK_ACCESSIBLE_ROLE_COMMAND,
1056 Self::Composite => ffi::GTK_ACCESSIBLE_ROLE_COMPOSITE,
1057 Self::Dialog => ffi::GTK_ACCESSIBLE_ROLE_DIALOG,
1058 Self::Document => ffi::GTK_ACCESSIBLE_ROLE_DOCUMENT,
1059 Self::Feed => ffi::GTK_ACCESSIBLE_ROLE_FEED,
1060 Self::Form => ffi::GTK_ACCESSIBLE_ROLE_FORM,
1061 Self::Generic => ffi::GTK_ACCESSIBLE_ROLE_GENERIC,
1062 Self::Grid => ffi::GTK_ACCESSIBLE_ROLE_GRID,
1063 Self::GridCell => ffi::GTK_ACCESSIBLE_ROLE_GRID_CELL,
1064 Self::Group => ffi::GTK_ACCESSIBLE_ROLE_GROUP,
1065 Self::Heading => ffi::GTK_ACCESSIBLE_ROLE_HEADING,
1066 Self::Img => ffi::GTK_ACCESSIBLE_ROLE_IMG,
1067 Self::Input => ffi::GTK_ACCESSIBLE_ROLE_INPUT,
1068 Self::Label => ffi::GTK_ACCESSIBLE_ROLE_LABEL,
1069 Self::Landmark => ffi::GTK_ACCESSIBLE_ROLE_LANDMARK,
1070 Self::Legend => ffi::GTK_ACCESSIBLE_ROLE_LEGEND,
1071 Self::Link => ffi::GTK_ACCESSIBLE_ROLE_LINK,
1072 Self::List => ffi::GTK_ACCESSIBLE_ROLE_LIST,
1073 Self::ListBox => ffi::GTK_ACCESSIBLE_ROLE_LIST_BOX,
1074 Self::ListItem => ffi::GTK_ACCESSIBLE_ROLE_LIST_ITEM,
1075 Self::Log => ffi::GTK_ACCESSIBLE_ROLE_LOG,
1076 Self::Main => ffi::GTK_ACCESSIBLE_ROLE_MAIN,
1077 Self::Marquee => ffi::GTK_ACCESSIBLE_ROLE_MARQUEE,
1078 Self::Math => ffi::GTK_ACCESSIBLE_ROLE_MATH,
1079 Self::Meter => ffi::GTK_ACCESSIBLE_ROLE_METER,
1080 Self::Menu => ffi::GTK_ACCESSIBLE_ROLE_MENU,
1081 Self::MenuBar => ffi::GTK_ACCESSIBLE_ROLE_MENU_BAR,
1082 Self::MenuItem => ffi::GTK_ACCESSIBLE_ROLE_MENU_ITEM,
1083 Self::MenuItemCheckbox => ffi::GTK_ACCESSIBLE_ROLE_MENU_ITEM_CHECKBOX,
1084 Self::MenuItemRadio => ffi::GTK_ACCESSIBLE_ROLE_MENU_ITEM_RADIO,
1085 Self::Navigation => ffi::GTK_ACCESSIBLE_ROLE_NAVIGATION,
1086 Self::None => ffi::GTK_ACCESSIBLE_ROLE_NONE,
1087 Self::Note => ffi::GTK_ACCESSIBLE_ROLE_NOTE,
1088 Self::Option => ffi::GTK_ACCESSIBLE_ROLE_OPTION,
1089 Self::Presentation => ffi::GTK_ACCESSIBLE_ROLE_PRESENTATION,
1090 Self::ProgressBar => ffi::GTK_ACCESSIBLE_ROLE_PROGRESS_BAR,
1091 Self::Radio => ffi::GTK_ACCESSIBLE_ROLE_RADIO,
1092 Self::RadioGroup => ffi::GTK_ACCESSIBLE_ROLE_RADIO_GROUP,
1093 Self::Range => ffi::GTK_ACCESSIBLE_ROLE_RANGE,
1094 Self::Region => ffi::GTK_ACCESSIBLE_ROLE_REGION,
1095 Self::Row => ffi::GTK_ACCESSIBLE_ROLE_ROW,
1096 Self::RowGroup => ffi::GTK_ACCESSIBLE_ROLE_ROW_GROUP,
1097 Self::RowHeader => ffi::GTK_ACCESSIBLE_ROLE_ROW_HEADER,
1098 Self::Scrollbar => ffi::GTK_ACCESSIBLE_ROLE_SCROLLBAR,
1099 Self::Search => ffi::GTK_ACCESSIBLE_ROLE_SEARCH,
1100 Self::SearchBox => ffi::GTK_ACCESSIBLE_ROLE_SEARCH_BOX,
1101 Self::Section => ffi::GTK_ACCESSIBLE_ROLE_SECTION,
1102 Self::SectionHead => ffi::GTK_ACCESSIBLE_ROLE_SECTION_HEAD,
1103 Self::Select => ffi::GTK_ACCESSIBLE_ROLE_SELECT,
1104 Self::Separator => ffi::GTK_ACCESSIBLE_ROLE_SEPARATOR,
1105 Self::Slider => ffi::GTK_ACCESSIBLE_ROLE_SLIDER,
1106 Self::SpinButton => ffi::GTK_ACCESSIBLE_ROLE_SPIN_BUTTON,
1107 Self::Status => ffi::GTK_ACCESSIBLE_ROLE_STATUS,
1108 Self::Structure => ffi::GTK_ACCESSIBLE_ROLE_STRUCTURE,
1109 Self::Switch => ffi::GTK_ACCESSIBLE_ROLE_SWITCH,
1110 Self::Tab => ffi::GTK_ACCESSIBLE_ROLE_TAB,
1111 Self::Table => ffi::GTK_ACCESSIBLE_ROLE_TABLE,
1112 Self::TabList => ffi::GTK_ACCESSIBLE_ROLE_TAB_LIST,
1113 Self::TabPanel => ffi::GTK_ACCESSIBLE_ROLE_TAB_PANEL,
1114 Self::TextBox => ffi::GTK_ACCESSIBLE_ROLE_TEXT_BOX,
1115 Self::Time => ffi::GTK_ACCESSIBLE_ROLE_TIME,
1116 Self::Timer => ffi::GTK_ACCESSIBLE_ROLE_TIMER,
1117 Self::Toolbar => ffi::GTK_ACCESSIBLE_ROLE_TOOLBAR,
1118 Self::Tooltip => ffi::GTK_ACCESSIBLE_ROLE_TOOLTIP,
1119 Self::Tree => ffi::GTK_ACCESSIBLE_ROLE_TREE,
1120 Self::TreeGrid => ffi::GTK_ACCESSIBLE_ROLE_TREE_GRID,
1121 Self::TreeItem => ffi::GTK_ACCESSIBLE_ROLE_TREE_ITEM,
1122 Self::Widget => ffi::GTK_ACCESSIBLE_ROLE_WIDGET,
1123 Self::Window => ffi::GTK_ACCESSIBLE_ROLE_WINDOW,
1124 #[cfg(feature = "v4_10")]
1125 Self::ToggleButton => ffi::GTK_ACCESSIBLE_ROLE_TOGGLE_BUTTON,
1126 #[cfg(feature = "v4_12")]
1127 Self::Application => ffi::GTK_ACCESSIBLE_ROLE_APPLICATION,
1128 #[cfg(feature = "v4_14")]
1129 Self::Paragraph => ffi::GTK_ACCESSIBLE_ROLE_PARAGRAPH,
1130 #[cfg(feature = "v4_14")]
1131 Self::BlockQuote => ffi::GTK_ACCESSIBLE_ROLE_BLOCK_QUOTE,
1132 #[cfg(feature = "v4_14")]
1133 Self::Article => ffi::GTK_ACCESSIBLE_ROLE_ARTICLE,
1134 #[cfg(feature = "v4_14")]
1135 Self::Comment => ffi::GTK_ACCESSIBLE_ROLE_COMMENT,
1136 #[cfg(feature = "v4_14")]
1137 Self::Terminal => ffi::GTK_ACCESSIBLE_ROLE_TERMINAL,
1138 Self::__Unknown(value) => value,
1139 }
1140 }
1141}
1142
1143#[doc(hidden)]
1144impl FromGlib<ffi::GtkAccessibleRole> for AccessibleRole {
1145 unsafe fn from_glib(value: ffi::GtkAccessibleRole) -> Self {
1146 skip_assert_initialized!();
1147
1148 match value {
1149 ffi::GTK_ACCESSIBLE_ROLE_ALERT => Self::Alert,
1150 ffi::GTK_ACCESSIBLE_ROLE_ALERT_DIALOG => Self::AlertDialog,
1151 ffi::GTK_ACCESSIBLE_ROLE_BANNER => Self::Banner,
1152 ffi::GTK_ACCESSIBLE_ROLE_BUTTON => Self::Button,
1153 ffi::GTK_ACCESSIBLE_ROLE_CAPTION => Self::Caption,
1154 ffi::GTK_ACCESSIBLE_ROLE_CELL => Self::Cell,
1155 ffi::GTK_ACCESSIBLE_ROLE_CHECKBOX => Self::Checkbox,
1156 ffi::GTK_ACCESSIBLE_ROLE_COLUMN_HEADER => Self::ColumnHeader,
1157 ffi::GTK_ACCESSIBLE_ROLE_COMBO_BOX => Self::ComboBox,
1158 ffi::GTK_ACCESSIBLE_ROLE_COMMAND => Self::Command,
1159 ffi::GTK_ACCESSIBLE_ROLE_COMPOSITE => Self::Composite,
1160 ffi::GTK_ACCESSIBLE_ROLE_DIALOG => Self::Dialog,
1161 ffi::GTK_ACCESSIBLE_ROLE_DOCUMENT => Self::Document,
1162 ffi::GTK_ACCESSIBLE_ROLE_FEED => Self::Feed,
1163 ffi::GTK_ACCESSIBLE_ROLE_FORM => Self::Form,
1164 ffi::GTK_ACCESSIBLE_ROLE_GENERIC => Self::Generic,
1165 ffi::GTK_ACCESSIBLE_ROLE_GRID => Self::Grid,
1166 ffi::GTK_ACCESSIBLE_ROLE_GRID_CELL => Self::GridCell,
1167 ffi::GTK_ACCESSIBLE_ROLE_GROUP => Self::Group,
1168 ffi::GTK_ACCESSIBLE_ROLE_HEADING => Self::Heading,
1169 ffi::GTK_ACCESSIBLE_ROLE_IMG => Self::Img,
1170 ffi::GTK_ACCESSIBLE_ROLE_INPUT => Self::Input,
1171 ffi::GTK_ACCESSIBLE_ROLE_LABEL => Self::Label,
1172 ffi::GTK_ACCESSIBLE_ROLE_LANDMARK => Self::Landmark,
1173 ffi::GTK_ACCESSIBLE_ROLE_LEGEND => Self::Legend,
1174 ffi::GTK_ACCESSIBLE_ROLE_LINK => Self::Link,
1175 ffi::GTK_ACCESSIBLE_ROLE_LIST => Self::List,
1176 ffi::GTK_ACCESSIBLE_ROLE_LIST_BOX => Self::ListBox,
1177 ffi::GTK_ACCESSIBLE_ROLE_LIST_ITEM => Self::ListItem,
1178 ffi::GTK_ACCESSIBLE_ROLE_LOG => Self::Log,
1179 ffi::GTK_ACCESSIBLE_ROLE_MAIN => Self::Main,
1180 ffi::GTK_ACCESSIBLE_ROLE_MARQUEE => Self::Marquee,
1181 ffi::GTK_ACCESSIBLE_ROLE_MATH => Self::Math,
1182 ffi::GTK_ACCESSIBLE_ROLE_METER => Self::Meter,
1183 ffi::GTK_ACCESSIBLE_ROLE_MENU => Self::Menu,
1184 ffi::GTK_ACCESSIBLE_ROLE_MENU_BAR => Self::MenuBar,
1185 ffi::GTK_ACCESSIBLE_ROLE_MENU_ITEM => Self::MenuItem,
1186 ffi::GTK_ACCESSIBLE_ROLE_MENU_ITEM_CHECKBOX => Self::MenuItemCheckbox,
1187 ffi::GTK_ACCESSIBLE_ROLE_MENU_ITEM_RADIO => Self::MenuItemRadio,
1188 ffi::GTK_ACCESSIBLE_ROLE_NAVIGATION => Self::Navigation,
1189 ffi::GTK_ACCESSIBLE_ROLE_NONE => Self::None,
1190 ffi::GTK_ACCESSIBLE_ROLE_NOTE => Self::Note,
1191 ffi::GTK_ACCESSIBLE_ROLE_OPTION => Self::Option,
1192 ffi::GTK_ACCESSIBLE_ROLE_PRESENTATION => Self::Presentation,
1193 ffi::GTK_ACCESSIBLE_ROLE_PROGRESS_BAR => Self::ProgressBar,
1194 ffi::GTK_ACCESSIBLE_ROLE_RADIO => Self::Radio,
1195 ffi::GTK_ACCESSIBLE_ROLE_RADIO_GROUP => Self::RadioGroup,
1196 ffi::GTK_ACCESSIBLE_ROLE_RANGE => Self::Range,
1197 ffi::GTK_ACCESSIBLE_ROLE_REGION => Self::Region,
1198 ffi::GTK_ACCESSIBLE_ROLE_ROW => Self::Row,
1199 ffi::GTK_ACCESSIBLE_ROLE_ROW_GROUP => Self::RowGroup,
1200 ffi::GTK_ACCESSIBLE_ROLE_ROW_HEADER => Self::RowHeader,
1201 ffi::GTK_ACCESSIBLE_ROLE_SCROLLBAR => Self::Scrollbar,
1202 ffi::GTK_ACCESSIBLE_ROLE_SEARCH => Self::Search,
1203 ffi::GTK_ACCESSIBLE_ROLE_SEARCH_BOX => Self::SearchBox,
1204 ffi::GTK_ACCESSIBLE_ROLE_SECTION => Self::Section,
1205 ffi::GTK_ACCESSIBLE_ROLE_SECTION_HEAD => Self::SectionHead,
1206 ffi::GTK_ACCESSIBLE_ROLE_SELECT => Self::Select,
1207 ffi::GTK_ACCESSIBLE_ROLE_SEPARATOR => Self::Separator,
1208 ffi::GTK_ACCESSIBLE_ROLE_SLIDER => Self::Slider,
1209 ffi::GTK_ACCESSIBLE_ROLE_SPIN_BUTTON => Self::SpinButton,
1210 ffi::GTK_ACCESSIBLE_ROLE_STATUS => Self::Status,
1211 ffi::GTK_ACCESSIBLE_ROLE_STRUCTURE => Self::Structure,
1212 ffi::GTK_ACCESSIBLE_ROLE_SWITCH => Self::Switch,
1213 ffi::GTK_ACCESSIBLE_ROLE_TAB => Self::Tab,
1214 ffi::GTK_ACCESSIBLE_ROLE_TABLE => Self::Table,
1215 ffi::GTK_ACCESSIBLE_ROLE_TAB_LIST => Self::TabList,
1216 ffi::GTK_ACCESSIBLE_ROLE_TAB_PANEL => Self::TabPanel,
1217 ffi::GTK_ACCESSIBLE_ROLE_TEXT_BOX => Self::TextBox,
1218 ffi::GTK_ACCESSIBLE_ROLE_TIME => Self::Time,
1219 ffi::GTK_ACCESSIBLE_ROLE_TIMER => Self::Timer,
1220 ffi::GTK_ACCESSIBLE_ROLE_TOOLBAR => Self::Toolbar,
1221 ffi::GTK_ACCESSIBLE_ROLE_TOOLTIP => Self::Tooltip,
1222 ffi::GTK_ACCESSIBLE_ROLE_TREE => Self::Tree,
1223 ffi::GTK_ACCESSIBLE_ROLE_TREE_GRID => Self::TreeGrid,
1224 ffi::GTK_ACCESSIBLE_ROLE_TREE_ITEM => Self::TreeItem,
1225 ffi::GTK_ACCESSIBLE_ROLE_WIDGET => Self::Widget,
1226 ffi::GTK_ACCESSIBLE_ROLE_WINDOW => Self::Window,
1227 #[cfg(feature = "v4_10")]
1228 ffi::GTK_ACCESSIBLE_ROLE_TOGGLE_BUTTON => Self::ToggleButton,
1229 #[cfg(feature = "v4_12")]
1230 ffi::GTK_ACCESSIBLE_ROLE_APPLICATION => Self::Application,
1231 #[cfg(feature = "v4_14")]
1232 ffi::GTK_ACCESSIBLE_ROLE_PARAGRAPH => Self::Paragraph,
1233 #[cfg(feature = "v4_14")]
1234 ffi::GTK_ACCESSIBLE_ROLE_BLOCK_QUOTE => Self::BlockQuote,
1235 #[cfg(feature = "v4_14")]
1236 ffi::GTK_ACCESSIBLE_ROLE_ARTICLE => Self::Article,
1237 #[cfg(feature = "v4_14")]
1238 ffi::GTK_ACCESSIBLE_ROLE_COMMENT => Self::Comment,
1239 #[cfg(feature = "v4_14")]
1240 ffi::GTK_ACCESSIBLE_ROLE_TERMINAL => Self::Terminal,
1241 value => Self::__Unknown(value),
1242 }
1243 }
1244}
1245
1246impl StaticType for AccessibleRole {
1247 #[inline]
1248 #[doc(alias = "gtk_accessible_role_get_type")]
1249 fn static_type() -> glib::Type {
1250 unsafe { from_glib(ffi::gtk_accessible_role_get_type()) }
1251 }
1252}
1253
1254impl glib::HasParamSpec for AccessibleRole {
1255 type ParamSpec = glib::ParamSpecEnum;
1256 type SetValue = Self;
1257 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1258
1259 fn param_spec_builder() -> Self::BuilderFn {
1260 Self::ParamSpec::builder_with_default
1261 }
1262}
1263
1264impl glib::value::ValueType for AccessibleRole {
1265 type Type = Self;
1266}
1267
1268unsafe impl<'a> glib::value::FromValue<'a> for AccessibleRole {
1269 type Checker = glib::value::GenericValueTypeChecker<Self>;
1270
1271 #[inline]
1272 unsafe fn from_value(value: &'a glib::Value) -> Self {
1273 skip_assert_initialized!();
1274 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
1275 }
1276}
1277
1278impl ToValue for AccessibleRole {
1279 #[inline]
1280 fn to_value(&self) -> glib::Value {
1281 let mut value = glib::Value::for_value_type::<Self>();
1282 unsafe {
1283 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1284 }
1285 value
1286 }
1287
1288 #[inline]
1289 fn value_type(&self) -> glib::Type {
1290 Self::static_type()
1291 }
1292}
1293
1294impl From<AccessibleRole> for glib::Value {
1295 #[inline]
1296 fn from(v: AccessibleRole) -> Self {
1297 skip_assert_initialized!();
1298 ToValue::to_value(&v)
1299 }
1300}
1301
1302#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1303#[non_exhaustive]
1304#[doc(alias = "GtkAccessibleSort")]
1305pub enum AccessibleSort {
1306 #[doc(alias = "GTK_ACCESSIBLE_SORT_NONE")]
1307 None,
1308 #[doc(alias = "GTK_ACCESSIBLE_SORT_ASCENDING")]
1309 Ascending,
1310 #[doc(alias = "GTK_ACCESSIBLE_SORT_DESCENDING")]
1311 Descending,
1312 #[doc(alias = "GTK_ACCESSIBLE_SORT_OTHER")]
1313 Other,
1314 #[doc(hidden)]
1315 __Unknown(i32),
1316}
1317
1318#[doc(hidden)]
1319impl IntoGlib for AccessibleSort {
1320 type GlibType = ffi::GtkAccessibleSort;
1321
1322 #[inline]
1323 fn into_glib(self) -> ffi::GtkAccessibleSort {
1324 match self {
1325 Self::None => ffi::GTK_ACCESSIBLE_SORT_NONE,
1326 Self::Ascending => ffi::GTK_ACCESSIBLE_SORT_ASCENDING,
1327 Self::Descending => ffi::GTK_ACCESSIBLE_SORT_DESCENDING,
1328 Self::Other => ffi::GTK_ACCESSIBLE_SORT_OTHER,
1329 Self::__Unknown(value) => value,
1330 }
1331 }
1332}
1333
1334#[doc(hidden)]
1335impl FromGlib<ffi::GtkAccessibleSort> for AccessibleSort {
1336 #[inline]
1337 unsafe fn from_glib(value: ffi::GtkAccessibleSort) -> Self {
1338 skip_assert_initialized!();
1339
1340 match value {
1341 ffi::GTK_ACCESSIBLE_SORT_NONE => Self::None,
1342 ffi::GTK_ACCESSIBLE_SORT_ASCENDING => Self::Ascending,
1343 ffi::GTK_ACCESSIBLE_SORT_DESCENDING => Self::Descending,
1344 ffi::GTK_ACCESSIBLE_SORT_OTHER => Self::Other,
1345 value => Self::__Unknown(value),
1346 }
1347 }
1348}
1349
1350impl StaticType for AccessibleSort {
1351 #[inline]
1352 #[doc(alias = "gtk_accessible_sort_get_type")]
1353 fn static_type() -> glib::Type {
1354 unsafe { from_glib(ffi::gtk_accessible_sort_get_type()) }
1355 }
1356}
1357
1358impl glib::HasParamSpec for AccessibleSort {
1359 type ParamSpec = glib::ParamSpecEnum;
1360 type SetValue = Self;
1361 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1362
1363 fn param_spec_builder() -> Self::BuilderFn {
1364 Self::ParamSpec::builder_with_default
1365 }
1366}
1367
1368impl glib::value::ValueType for AccessibleSort {
1369 type Type = Self;
1370}
1371
1372unsafe impl<'a> glib::value::FromValue<'a> for AccessibleSort {
1373 type Checker = glib::value::GenericValueTypeChecker<Self>;
1374
1375 #[inline]
1376 unsafe fn from_value(value: &'a glib::Value) -> Self {
1377 skip_assert_initialized!();
1378 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
1379 }
1380}
1381
1382impl ToValue for AccessibleSort {
1383 #[inline]
1384 fn to_value(&self) -> glib::Value {
1385 let mut value = glib::Value::for_value_type::<Self>();
1386 unsafe {
1387 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1388 }
1389 value
1390 }
1391
1392 #[inline]
1393 fn value_type(&self) -> glib::Type {
1394 Self::static_type()
1395 }
1396}
1397
1398impl From<AccessibleSort> for glib::Value {
1399 #[inline]
1400 fn from(v: AccessibleSort) -> Self {
1401 skip_assert_initialized!();
1402 ToValue::to_value(&v)
1403 }
1404}
1405
1406#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1407#[non_exhaustive]
1408#[doc(alias = "GtkAccessibleState")]
1409pub enum AccessibleState {
1410 #[doc(alias = "GTK_ACCESSIBLE_STATE_BUSY")]
1411 Busy,
1412 #[doc(alias = "GTK_ACCESSIBLE_STATE_CHECKED")]
1413 Checked,
1414 #[doc(alias = "GTK_ACCESSIBLE_STATE_DISABLED")]
1415 Disabled,
1416 #[doc(alias = "GTK_ACCESSIBLE_STATE_EXPANDED")]
1417 Expanded,
1418 #[doc(alias = "GTK_ACCESSIBLE_STATE_HIDDEN")]
1419 Hidden,
1420 #[doc(alias = "GTK_ACCESSIBLE_STATE_INVALID")]
1421 Invalid,
1422 #[doc(alias = "GTK_ACCESSIBLE_STATE_PRESSED")]
1423 Pressed,
1424 #[doc(alias = "GTK_ACCESSIBLE_STATE_SELECTED")]
1425 Selected,
1426 #[cfg(feature = "v4_12")]
1427 #[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
1428 #[doc(alias = "GTK_ACCESSIBLE_STATE_VISITED")]
1429 Visited,
1430 #[doc(hidden)]
1431 __Unknown(i32),
1432}
1433
1434impl AccessibleState {
1435 #[doc(alias = "gtk_accessible_state_init_value")]
1436 pub fn init_value(self, value: &mut glib::Value) {
1437 assert_initialized_main_thread!();
1438 unsafe {
1439 ffi::gtk_accessible_state_init_value(self.into_glib(), value.to_glib_none_mut().0);
1440 }
1441 }
1442}
1443
1444#[doc(hidden)]
1445impl IntoGlib for AccessibleState {
1446 type GlibType = ffi::GtkAccessibleState;
1447
1448 #[inline]
1449 fn into_glib(self) -> ffi::GtkAccessibleState {
1450 match self {
1451 Self::Busy => ffi::GTK_ACCESSIBLE_STATE_BUSY,
1452 Self::Checked => ffi::GTK_ACCESSIBLE_STATE_CHECKED,
1453 Self::Disabled => ffi::GTK_ACCESSIBLE_STATE_DISABLED,
1454 Self::Expanded => ffi::GTK_ACCESSIBLE_STATE_EXPANDED,
1455 Self::Hidden => ffi::GTK_ACCESSIBLE_STATE_HIDDEN,
1456 Self::Invalid => ffi::GTK_ACCESSIBLE_STATE_INVALID,
1457 Self::Pressed => ffi::GTK_ACCESSIBLE_STATE_PRESSED,
1458 Self::Selected => ffi::GTK_ACCESSIBLE_STATE_SELECTED,
1459 #[cfg(feature = "v4_12")]
1460 Self::Visited => ffi::GTK_ACCESSIBLE_STATE_VISITED,
1461 Self::__Unknown(value) => value,
1462 }
1463 }
1464}
1465
1466#[doc(hidden)]
1467impl FromGlib<ffi::GtkAccessibleState> for AccessibleState {
1468 #[inline]
1469 unsafe fn from_glib(value: ffi::GtkAccessibleState) -> Self {
1470 skip_assert_initialized!();
1471
1472 match value {
1473 ffi::GTK_ACCESSIBLE_STATE_BUSY => Self::Busy,
1474 ffi::GTK_ACCESSIBLE_STATE_CHECKED => Self::Checked,
1475 ffi::GTK_ACCESSIBLE_STATE_DISABLED => Self::Disabled,
1476 ffi::GTK_ACCESSIBLE_STATE_EXPANDED => Self::Expanded,
1477 ffi::GTK_ACCESSIBLE_STATE_HIDDEN => Self::Hidden,
1478 ffi::GTK_ACCESSIBLE_STATE_INVALID => Self::Invalid,
1479 ffi::GTK_ACCESSIBLE_STATE_PRESSED => Self::Pressed,
1480 ffi::GTK_ACCESSIBLE_STATE_SELECTED => Self::Selected,
1481 #[cfg(feature = "v4_12")]
1482 ffi::GTK_ACCESSIBLE_STATE_VISITED => Self::Visited,
1483 value => Self::__Unknown(value),
1484 }
1485 }
1486}
1487
1488impl StaticType for AccessibleState {
1489 #[inline]
1490 #[doc(alias = "gtk_accessible_state_get_type")]
1491 fn static_type() -> glib::Type {
1492 unsafe { from_glib(ffi::gtk_accessible_state_get_type()) }
1493 }
1494}
1495
1496impl glib::HasParamSpec for AccessibleState {
1497 type ParamSpec = glib::ParamSpecEnum;
1498 type SetValue = Self;
1499 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1500
1501 fn param_spec_builder() -> Self::BuilderFn {
1502 Self::ParamSpec::builder_with_default
1503 }
1504}
1505
1506impl glib::value::ValueType for AccessibleState {
1507 type Type = Self;
1508}
1509
1510unsafe impl<'a> glib::value::FromValue<'a> for AccessibleState {
1511 type Checker = glib::value::GenericValueTypeChecker<Self>;
1512
1513 #[inline]
1514 unsafe fn from_value(value: &'a glib::Value) -> Self {
1515 skip_assert_initialized!();
1516 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
1517 }
1518}
1519
1520impl ToValue for AccessibleState {
1521 #[inline]
1522 fn to_value(&self) -> glib::Value {
1523 let mut value = glib::Value::for_value_type::<Self>();
1524 unsafe {
1525 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1526 }
1527 value
1528 }
1529
1530 #[inline]
1531 fn value_type(&self) -> glib::Type {
1532 Self::static_type()
1533 }
1534}
1535
1536impl From<AccessibleState> for glib::Value {
1537 #[inline]
1538 fn from(v: AccessibleState) -> Self {
1539 skip_assert_initialized!();
1540 ToValue::to_value(&v)
1541 }
1542}
1543
1544#[cfg(feature = "v4_14")]
1545#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1546#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1547#[non_exhaustive]
1548#[doc(alias = "GtkAccessibleTextContentChange")]
1549pub enum AccessibleTextContentChange {
1550 #[doc(alias = "GTK_ACCESSIBLE_TEXT_CONTENT_CHANGE_INSERT")]
1551 Insert,
1552 #[doc(alias = "GTK_ACCESSIBLE_TEXT_CONTENT_CHANGE_REMOVE")]
1553 Remove,
1554 #[doc(hidden)]
1555 __Unknown(i32),
1556}
1557
1558#[cfg(feature = "v4_14")]
1559#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1560#[doc(hidden)]
1561impl IntoGlib for AccessibleTextContentChange {
1562 type GlibType = ffi::GtkAccessibleTextContentChange;
1563
1564 #[inline]
1565 fn into_glib(self) -> ffi::GtkAccessibleTextContentChange {
1566 match self {
1567 Self::Insert => ffi::GTK_ACCESSIBLE_TEXT_CONTENT_CHANGE_INSERT,
1568 Self::Remove => ffi::GTK_ACCESSIBLE_TEXT_CONTENT_CHANGE_REMOVE,
1569 Self::__Unknown(value) => value,
1570 }
1571 }
1572}
1573
1574#[cfg(feature = "v4_14")]
1575#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1576#[doc(hidden)]
1577impl FromGlib<ffi::GtkAccessibleTextContentChange> for AccessibleTextContentChange {
1578 #[inline]
1579 unsafe fn from_glib(value: ffi::GtkAccessibleTextContentChange) -> Self {
1580 skip_assert_initialized!();
1581
1582 match value {
1583 ffi::GTK_ACCESSIBLE_TEXT_CONTENT_CHANGE_INSERT => Self::Insert,
1584 ffi::GTK_ACCESSIBLE_TEXT_CONTENT_CHANGE_REMOVE => Self::Remove,
1585 value => Self::__Unknown(value),
1586 }
1587 }
1588}
1589
1590#[cfg(feature = "v4_14")]
1591#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1592impl StaticType for AccessibleTextContentChange {
1593 #[inline]
1594 #[doc(alias = "gtk_accessible_text_content_change_get_type")]
1595 fn static_type() -> glib::Type {
1596 unsafe { from_glib(ffi::gtk_accessible_text_content_change_get_type()) }
1597 }
1598}
1599
1600#[cfg(feature = "v4_14")]
1601#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1602impl glib::HasParamSpec for AccessibleTextContentChange {
1603 type ParamSpec = glib::ParamSpecEnum;
1604 type SetValue = Self;
1605 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1606
1607 fn param_spec_builder() -> Self::BuilderFn {
1608 Self::ParamSpec::builder_with_default
1609 }
1610}
1611
1612#[cfg(feature = "v4_14")]
1613#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1614impl glib::value::ValueType for AccessibleTextContentChange {
1615 type Type = Self;
1616}
1617
1618#[cfg(feature = "v4_14")]
1619#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1620unsafe impl<'a> glib::value::FromValue<'a> for AccessibleTextContentChange {
1621 type Checker = glib::value::GenericValueTypeChecker<Self>;
1622
1623 #[inline]
1624 unsafe fn from_value(value: &'a glib::Value) -> Self {
1625 skip_assert_initialized!();
1626 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
1627 }
1628}
1629
1630#[cfg(feature = "v4_14")]
1631#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1632impl ToValue for AccessibleTextContentChange {
1633 #[inline]
1634 fn to_value(&self) -> glib::Value {
1635 let mut value = glib::Value::for_value_type::<Self>();
1636 unsafe {
1637 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1638 }
1639 value
1640 }
1641
1642 #[inline]
1643 fn value_type(&self) -> glib::Type {
1644 Self::static_type()
1645 }
1646}
1647
1648#[cfg(feature = "v4_14")]
1649#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1650impl From<AccessibleTextContentChange> for glib::Value {
1651 #[inline]
1652 fn from(v: AccessibleTextContentChange) -> Self {
1653 skip_assert_initialized!();
1654 ToValue::to_value(&v)
1655 }
1656}
1657
1658#[cfg(feature = "v4_14")]
1659#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1660#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1661#[non_exhaustive]
1662#[doc(alias = "GtkAccessibleTextGranularity")]
1663pub enum AccessibleTextGranularity {
1664 #[doc(alias = "GTK_ACCESSIBLE_TEXT_GRANULARITY_CHARACTER")]
1665 Character,
1666 #[doc(alias = "GTK_ACCESSIBLE_TEXT_GRANULARITY_WORD")]
1667 Word,
1668 #[doc(alias = "GTK_ACCESSIBLE_TEXT_GRANULARITY_SENTENCE")]
1669 Sentence,
1670 #[doc(alias = "GTK_ACCESSIBLE_TEXT_GRANULARITY_LINE")]
1671 Line,
1672 #[doc(alias = "GTK_ACCESSIBLE_TEXT_GRANULARITY_PARAGRAPH")]
1673 Paragraph,
1674 #[doc(hidden)]
1675 __Unknown(i32),
1676}
1677
1678#[cfg(feature = "v4_14")]
1679#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1680#[doc(hidden)]
1681impl IntoGlib for AccessibleTextGranularity {
1682 type GlibType = ffi::GtkAccessibleTextGranularity;
1683
1684 #[inline]
1685 fn into_glib(self) -> ffi::GtkAccessibleTextGranularity {
1686 match self {
1687 Self::Character => ffi::GTK_ACCESSIBLE_TEXT_GRANULARITY_CHARACTER,
1688 Self::Word => ffi::GTK_ACCESSIBLE_TEXT_GRANULARITY_WORD,
1689 Self::Sentence => ffi::GTK_ACCESSIBLE_TEXT_GRANULARITY_SENTENCE,
1690 Self::Line => ffi::GTK_ACCESSIBLE_TEXT_GRANULARITY_LINE,
1691 Self::Paragraph => ffi::GTK_ACCESSIBLE_TEXT_GRANULARITY_PARAGRAPH,
1692 Self::__Unknown(value) => value,
1693 }
1694 }
1695}
1696
1697#[cfg(feature = "v4_14")]
1698#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1699#[doc(hidden)]
1700impl FromGlib<ffi::GtkAccessibleTextGranularity> for AccessibleTextGranularity {
1701 #[inline]
1702 unsafe fn from_glib(value: ffi::GtkAccessibleTextGranularity) -> Self {
1703 skip_assert_initialized!();
1704
1705 match value {
1706 ffi::GTK_ACCESSIBLE_TEXT_GRANULARITY_CHARACTER => Self::Character,
1707 ffi::GTK_ACCESSIBLE_TEXT_GRANULARITY_WORD => Self::Word,
1708 ffi::GTK_ACCESSIBLE_TEXT_GRANULARITY_SENTENCE => Self::Sentence,
1709 ffi::GTK_ACCESSIBLE_TEXT_GRANULARITY_LINE => Self::Line,
1710 ffi::GTK_ACCESSIBLE_TEXT_GRANULARITY_PARAGRAPH => Self::Paragraph,
1711 value => Self::__Unknown(value),
1712 }
1713 }
1714}
1715
1716#[cfg(feature = "v4_14")]
1717#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1718impl StaticType for AccessibleTextGranularity {
1719 #[inline]
1720 #[doc(alias = "gtk_accessible_text_granularity_get_type")]
1721 fn static_type() -> glib::Type {
1722 unsafe { from_glib(ffi::gtk_accessible_text_granularity_get_type()) }
1723 }
1724}
1725
1726#[cfg(feature = "v4_14")]
1727#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1728impl glib::HasParamSpec for AccessibleTextGranularity {
1729 type ParamSpec = glib::ParamSpecEnum;
1730 type SetValue = Self;
1731 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1732
1733 fn param_spec_builder() -> Self::BuilderFn {
1734 Self::ParamSpec::builder_with_default
1735 }
1736}
1737
1738#[cfg(feature = "v4_14")]
1739#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1740impl glib::value::ValueType for AccessibleTextGranularity {
1741 type Type = Self;
1742}
1743
1744#[cfg(feature = "v4_14")]
1745#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1746unsafe impl<'a> glib::value::FromValue<'a> for AccessibleTextGranularity {
1747 type Checker = glib::value::GenericValueTypeChecker<Self>;
1748
1749 #[inline]
1750 unsafe fn from_value(value: &'a glib::Value) -> Self {
1751 skip_assert_initialized!();
1752 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
1753 }
1754}
1755
1756#[cfg(feature = "v4_14")]
1757#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1758impl ToValue for AccessibleTextGranularity {
1759 #[inline]
1760 fn to_value(&self) -> glib::Value {
1761 let mut value = glib::Value::for_value_type::<Self>();
1762 unsafe {
1763 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1764 }
1765 value
1766 }
1767
1768 #[inline]
1769 fn value_type(&self) -> glib::Type {
1770 Self::static_type()
1771 }
1772}
1773
1774#[cfg(feature = "v4_14")]
1775#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
1776impl From<AccessibleTextGranularity> for glib::Value {
1777 #[inline]
1778 fn from(v: AccessibleTextGranularity) -> Self {
1779 skip_assert_initialized!();
1780 ToValue::to_value(&v)
1781 }
1782}
1783
1784#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1785#[non_exhaustive]
1786#[doc(alias = "GtkAccessibleTristate")]
1787pub enum AccessibleTristate {
1788 #[doc(alias = "GTK_ACCESSIBLE_TRISTATE_FALSE")]
1789 False,
1790 #[doc(alias = "GTK_ACCESSIBLE_TRISTATE_TRUE")]
1791 True,
1792 #[doc(alias = "GTK_ACCESSIBLE_TRISTATE_MIXED")]
1793 Mixed,
1794 #[doc(hidden)]
1795 __Unknown(i32),
1796}
1797
1798#[doc(hidden)]
1799impl IntoGlib for AccessibleTristate {
1800 type GlibType = ffi::GtkAccessibleTristate;
1801
1802 #[inline]
1803 fn into_glib(self) -> ffi::GtkAccessibleTristate {
1804 match self {
1805 Self::False => ffi::GTK_ACCESSIBLE_TRISTATE_FALSE,
1806 Self::True => ffi::GTK_ACCESSIBLE_TRISTATE_TRUE,
1807 Self::Mixed => ffi::GTK_ACCESSIBLE_TRISTATE_MIXED,
1808 Self::__Unknown(value) => value,
1809 }
1810 }
1811}
1812
1813#[doc(hidden)]
1814impl FromGlib<ffi::GtkAccessibleTristate> for AccessibleTristate {
1815 #[inline]
1816 unsafe fn from_glib(value: ffi::GtkAccessibleTristate) -> Self {
1817 skip_assert_initialized!();
1818
1819 match value {
1820 ffi::GTK_ACCESSIBLE_TRISTATE_FALSE => Self::False,
1821 ffi::GTK_ACCESSIBLE_TRISTATE_TRUE => Self::True,
1822 ffi::GTK_ACCESSIBLE_TRISTATE_MIXED => Self::Mixed,
1823 value => Self::__Unknown(value),
1824 }
1825 }
1826}
1827
1828impl StaticType for AccessibleTristate {
1829 #[inline]
1830 #[doc(alias = "gtk_accessible_tristate_get_type")]
1831 fn static_type() -> glib::Type {
1832 unsafe { from_glib(ffi::gtk_accessible_tristate_get_type()) }
1833 }
1834}
1835
1836impl glib::HasParamSpec for AccessibleTristate {
1837 type ParamSpec = glib::ParamSpecEnum;
1838 type SetValue = Self;
1839 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1840
1841 fn param_spec_builder() -> Self::BuilderFn {
1842 Self::ParamSpec::builder_with_default
1843 }
1844}
1845
1846impl glib::value::ValueType for AccessibleTristate {
1847 type Type = Self;
1848}
1849
1850unsafe impl<'a> glib::value::FromValue<'a> for AccessibleTristate {
1851 type Checker = glib::value::GenericValueTypeChecker<Self>;
1852
1853 #[inline]
1854 unsafe fn from_value(value: &'a glib::Value) -> Self {
1855 skip_assert_initialized!();
1856 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
1857 }
1858}
1859
1860impl ToValue for AccessibleTristate {
1861 #[inline]
1862 fn to_value(&self) -> glib::Value {
1863 let mut value = glib::Value::for_value_type::<Self>();
1864 unsafe {
1865 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1866 }
1867 value
1868 }
1869
1870 #[inline]
1871 fn value_type(&self) -> glib::Type {
1872 Self::static_type()
1873 }
1874}
1875
1876impl From<AccessibleTristate> for glib::Value {
1877 #[inline]
1878 fn from(v: AccessibleTristate) -> Self {
1879 skip_assert_initialized!();
1880 ToValue::to_value(&v)
1881 }
1882}
1883
1884#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1885#[non_exhaustive]
1886#[doc(alias = "GtkArrowType")]
1887pub enum ArrowType {
1888 #[doc(alias = "GTK_ARROW_UP")]
1889 Up,
1890 #[doc(alias = "GTK_ARROW_DOWN")]
1891 Down,
1892 #[doc(alias = "GTK_ARROW_LEFT")]
1893 Left,
1894 #[doc(alias = "GTK_ARROW_RIGHT")]
1895 Right,
1896 #[doc(alias = "GTK_ARROW_NONE")]
1897 None,
1898 #[doc(hidden)]
1899 __Unknown(i32),
1900}
1901
1902#[doc(hidden)]
1903impl IntoGlib for ArrowType {
1904 type GlibType = ffi::GtkArrowType;
1905
1906 #[inline]
1907 fn into_glib(self) -> ffi::GtkArrowType {
1908 match self {
1909 Self::Up => ffi::GTK_ARROW_UP,
1910 Self::Down => ffi::GTK_ARROW_DOWN,
1911 Self::Left => ffi::GTK_ARROW_LEFT,
1912 Self::Right => ffi::GTK_ARROW_RIGHT,
1913 Self::None => ffi::GTK_ARROW_NONE,
1914 Self::__Unknown(value) => value,
1915 }
1916 }
1917}
1918
1919#[doc(hidden)]
1920impl FromGlib<ffi::GtkArrowType> for ArrowType {
1921 #[inline]
1922 unsafe fn from_glib(value: ffi::GtkArrowType) -> Self {
1923 skip_assert_initialized!();
1924
1925 match value {
1926 ffi::GTK_ARROW_UP => Self::Up,
1927 ffi::GTK_ARROW_DOWN => Self::Down,
1928 ffi::GTK_ARROW_LEFT => Self::Left,
1929 ffi::GTK_ARROW_RIGHT => Self::Right,
1930 ffi::GTK_ARROW_NONE => Self::None,
1931 value => Self::__Unknown(value),
1932 }
1933 }
1934}
1935
1936impl StaticType for ArrowType {
1937 #[inline]
1938 #[doc(alias = "gtk_arrow_type_get_type")]
1939 fn static_type() -> glib::Type {
1940 unsafe { from_glib(ffi::gtk_arrow_type_get_type()) }
1941 }
1942}
1943
1944impl glib::HasParamSpec for ArrowType {
1945 type ParamSpec = glib::ParamSpecEnum;
1946 type SetValue = Self;
1947 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1948
1949 fn param_spec_builder() -> Self::BuilderFn {
1950 Self::ParamSpec::builder_with_default
1951 }
1952}
1953
1954impl glib::value::ValueType for ArrowType {
1955 type Type = Self;
1956}
1957
1958unsafe impl<'a> glib::value::FromValue<'a> for ArrowType {
1959 type Checker = glib::value::GenericValueTypeChecker<Self>;
1960
1961 #[inline]
1962 unsafe fn from_value(value: &'a glib::Value) -> Self {
1963 skip_assert_initialized!();
1964 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
1965 }
1966}
1967
1968impl ToValue for ArrowType {
1969 #[inline]
1970 fn to_value(&self) -> glib::Value {
1971 let mut value = glib::Value::for_value_type::<Self>();
1972 unsafe {
1973 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1974 }
1975 value
1976 }
1977
1978 #[inline]
1979 fn value_type(&self) -> glib::Type {
1980 Self::static_type()
1981 }
1982}
1983
1984impl From<ArrowType> for glib::Value {
1985 #[inline]
1986 fn from(v: ArrowType) -> Self {
1987 skip_assert_initialized!();
1988 ToValue::to_value(&v)
1989 }
1990}
1991
1992#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1993#[non_exhaustive]
1994#[doc(alias = "GtkAssistantPageType")]
1995pub enum AssistantPageType {
1996 #[doc(alias = "GTK_ASSISTANT_PAGE_CONTENT")]
1997 Content,
1998 #[doc(alias = "GTK_ASSISTANT_PAGE_INTRO")]
1999 Intro,
2000 #[doc(alias = "GTK_ASSISTANT_PAGE_CONFIRM")]
2001 Confirm,
2002 #[doc(alias = "GTK_ASSISTANT_PAGE_SUMMARY")]
2003 Summary,
2004 #[doc(alias = "GTK_ASSISTANT_PAGE_PROGRESS")]
2005 Progress,
2006 #[doc(alias = "GTK_ASSISTANT_PAGE_CUSTOM")]
2007 Custom,
2008 #[doc(hidden)]
2009 __Unknown(i32),
2010}
2011
2012#[doc(hidden)]
2013impl IntoGlib for AssistantPageType {
2014 type GlibType = ffi::GtkAssistantPageType;
2015
2016 #[inline]
2017 fn into_glib(self) -> ffi::GtkAssistantPageType {
2018 match self {
2019 Self::Content => ffi::GTK_ASSISTANT_PAGE_CONTENT,
2020 Self::Intro => ffi::GTK_ASSISTANT_PAGE_INTRO,
2021 Self::Confirm => ffi::GTK_ASSISTANT_PAGE_CONFIRM,
2022 Self::Summary => ffi::GTK_ASSISTANT_PAGE_SUMMARY,
2023 Self::Progress => ffi::GTK_ASSISTANT_PAGE_PROGRESS,
2024 Self::Custom => ffi::GTK_ASSISTANT_PAGE_CUSTOM,
2025 Self::__Unknown(value) => value,
2026 }
2027 }
2028}
2029
2030#[doc(hidden)]
2031impl FromGlib<ffi::GtkAssistantPageType> for AssistantPageType {
2032 #[inline]
2033 unsafe fn from_glib(value: ffi::GtkAssistantPageType) -> Self {
2034 skip_assert_initialized!();
2035
2036 match value {
2037 ffi::GTK_ASSISTANT_PAGE_CONTENT => Self::Content,
2038 ffi::GTK_ASSISTANT_PAGE_INTRO => Self::Intro,
2039 ffi::GTK_ASSISTANT_PAGE_CONFIRM => Self::Confirm,
2040 ffi::GTK_ASSISTANT_PAGE_SUMMARY => Self::Summary,
2041 ffi::GTK_ASSISTANT_PAGE_PROGRESS => Self::Progress,
2042 ffi::GTK_ASSISTANT_PAGE_CUSTOM => Self::Custom,
2043 value => Self::__Unknown(value),
2044 }
2045 }
2046}
2047
2048impl StaticType for AssistantPageType {
2049 #[inline]
2050 #[doc(alias = "gtk_assistant_page_type_get_type")]
2051 fn static_type() -> glib::Type {
2052 unsafe { from_glib(ffi::gtk_assistant_page_type_get_type()) }
2053 }
2054}
2055
2056impl glib::HasParamSpec for AssistantPageType {
2057 type ParamSpec = glib::ParamSpecEnum;
2058 type SetValue = Self;
2059 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2060
2061 fn param_spec_builder() -> Self::BuilderFn {
2062 Self::ParamSpec::builder_with_default
2063 }
2064}
2065
2066impl glib::value::ValueType for AssistantPageType {
2067 type Type = Self;
2068}
2069
2070unsafe impl<'a> glib::value::FromValue<'a> for AssistantPageType {
2071 type Checker = glib::value::GenericValueTypeChecker<Self>;
2072
2073 #[inline]
2074 unsafe fn from_value(value: &'a glib::Value) -> Self {
2075 skip_assert_initialized!();
2076 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
2077 }
2078}
2079
2080impl ToValue for AssistantPageType {
2081 #[inline]
2082 fn to_value(&self) -> glib::Value {
2083 let mut value = glib::Value::for_value_type::<Self>();
2084 unsafe {
2085 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2086 }
2087 value
2088 }
2089
2090 #[inline]
2091 fn value_type(&self) -> glib::Type {
2092 Self::static_type()
2093 }
2094}
2095
2096impl From<AssistantPageType> for glib::Value {
2097 #[inline]
2098 fn from(v: AssistantPageType) -> Self {
2099 skip_assert_initialized!();
2100 ToValue::to_value(&v)
2101 }
2102}
2103
2104#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2105#[non_exhaustive]
2106#[doc(alias = "GtkBaselinePosition")]
2107pub enum BaselinePosition {
2108 #[doc(alias = "GTK_BASELINE_POSITION_TOP")]
2109 Top,
2110 #[doc(alias = "GTK_BASELINE_POSITION_CENTER")]
2111 Center,
2112 #[doc(alias = "GTK_BASELINE_POSITION_BOTTOM")]
2113 Bottom,
2114 #[doc(hidden)]
2115 __Unknown(i32),
2116}
2117
2118#[doc(hidden)]
2119impl IntoGlib for BaselinePosition {
2120 type GlibType = ffi::GtkBaselinePosition;
2121
2122 #[inline]
2123 fn into_glib(self) -> ffi::GtkBaselinePosition {
2124 match self {
2125 Self::Top => ffi::GTK_BASELINE_POSITION_TOP,
2126 Self::Center => ffi::GTK_BASELINE_POSITION_CENTER,
2127 Self::Bottom => ffi::GTK_BASELINE_POSITION_BOTTOM,
2128 Self::__Unknown(value) => value,
2129 }
2130 }
2131}
2132
2133#[doc(hidden)]
2134impl FromGlib<ffi::GtkBaselinePosition> for BaselinePosition {
2135 #[inline]
2136 unsafe fn from_glib(value: ffi::GtkBaselinePosition) -> Self {
2137 skip_assert_initialized!();
2138
2139 match value {
2140 ffi::GTK_BASELINE_POSITION_TOP => Self::Top,
2141 ffi::GTK_BASELINE_POSITION_CENTER => Self::Center,
2142 ffi::GTK_BASELINE_POSITION_BOTTOM => Self::Bottom,
2143 value => Self::__Unknown(value),
2144 }
2145 }
2146}
2147
2148impl StaticType for BaselinePosition {
2149 #[inline]
2150 #[doc(alias = "gtk_baseline_position_get_type")]
2151 fn static_type() -> glib::Type {
2152 unsafe { from_glib(ffi::gtk_baseline_position_get_type()) }
2153 }
2154}
2155
2156impl glib::HasParamSpec for BaselinePosition {
2157 type ParamSpec = glib::ParamSpecEnum;
2158 type SetValue = Self;
2159 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2160
2161 fn param_spec_builder() -> Self::BuilderFn {
2162 Self::ParamSpec::builder_with_default
2163 }
2164}
2165
2166impl glib::value::ValueType for BaselinePosition {
2167 type Type = Self;
2168}
2169
2170unsafe impl<'a> glib::value::FromValue<'a> for BaselinePosition {
2171 type Checker = glib::value::GenericValueTypeChecker<Self>;
2172
2173 #[inline]
2174 unsafe fn from_value(value: &'a glib::Value) -> Self {
2175 skip_assert_initialized!();
2176 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
2177 }
2178}
2179
2180impl ToValue for BaselinePosition {
2181 #[inline]
2182 fn to_value(&self) -> glib::Value {
2183 let mut value = glib::Value::for_value_type::<Self>();
2184 unsafe {
2185 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2186 }
2187 value
2188 }
2189
2190 #[inline]
2191 fn value_type(&self) -> glib::Type {
2192 Self::static_type()
2193 }
2194}
2195
2196impl From<BaselinePosition> for glib::Value {
2197 #[inline]
2198 fn from(v: BaselinePosition) -> Self {
2199 skip_assert_initialized!();
2200 ToValue::to_value(&v)
2201 }
2202}
2203
2204#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2205#[non_exhaustive]
2206#[doc(alias = "GtkBorderStyle")]
2207pub enum BorderStyle {
2208 #[doc(alias = "GTK_BORDER_STYLE_NONE")]
2209 None,
2210 #[doc(alias = "GTK_BORDER_STYLE_HIDDEN")]
2211 Hidden,
2212 #[doc(alias = "GTK_BORDER_STYLE_SOLID")]
2213 Solid,
2214 #[doc(alias = "GTK_BORDER_STYLE_INSET")]
2215 Inset,
2216 #[doc(alias = "GTK_BORDER_STYLE_OUTSET")]
2217 Outset,
2218 #[doc(alias = "GTK_BORDER_STYLE_DOTTED")]
2219 Dotted,
2220 #[doc(alias = "GTK_BORDER_STYLE_DASHED")]
2221 Dashed,
2222 #[doc(alias = "GTK_BORDER_STYLE_DOUBLE")]
2223 Double,
2224 #[doc(alias = "GTK_BORDER_STYLE_GROOVE")]
2225 Groove,
2226 #[doc(alias = "GTK_BORDER_STYLE_RIDGE")]
2227 Ridge,
2228 #[doc(hidden)]
2229 __Unknown(i32),
2230}
2231
2232#[doc(hidden)]
2233impl IntoGlib for BorderStyle {
2234 type GlibType = ffi::GtkBorderStyle;
2235
2236 #[inline]
2237 fn into_glib(self) -> ffi::GtkBorderStyle {
2238 match self {
2239 Self::None => ffi::GTK_BORDER_STYLE_NONE,
2240 Self::Hidden => ffi::GTK_BORDER_STYLE_HIDDEN,
2241 Self::Solid => ffi::GTK_BORDER_STYLE_SOLID,
2242 Self::Inset => ffi::GTK_BORDER_STYLE_INSET,
2243 Self::Outset => ffi::GTK_BORDER_STYLE_OUTSET,
2244 Self::Dotted => ffi::GTK_BORDER_STYLE_DOTTED,
2245 Self::Dashed => ffi::GTK_BORDER_STYLE_DASHED,
2246 Self::Double => ffi::GTK_BORDER_STYLE_DOUBLE,
2247 Self::Groove => ffi::GTK_BORDER_STYLE_GROOVE,
2248 Self::Ridge => ffi::GTK_BORDER_STYLE_RIDGE,
2249 Self::__Unknown(value) => value,
2250 }
2251 }
2252}
2253
2254#[doc(hidden)]
2255impl FromGlib<ffi::GtkBorderStyle> for BorderStyle {
2256 #[inline]
2257 unsafe fn from_glib(value: ffi::GtkBorderStyle) -> Self {
2258 skip_assert_initialized!();
2259
2260 match value {
2261 ffi::GTK_BORDER_STYLE_NONE => Self::None,
2262 ffi::GTK_BORDER_STYLE_HIDDEN => Self::Hidden,
2263 ffi::GTK_BORDER_STYLE_SOLID => Self::Solid,
2264 ffi::GTK_BORDER_STYLE_INSET => Self::Inset,
2265 ffi::GTK_BORDER_STYLE_OUTSET => Self::Outset,
2266 ffi::GTK_BORDER_STYLE_DOTTED => Self::Dotted,
2267 ffi::GTK_BORDER_STYLE_DASHED => Self::Dashed,
2268 ffi::GTK_BORDER_STYLE_DOUBLE => Self::Double,
2269 ffi::GTK_BORDER_STYLE_GROOVE => Self::Groove,
2270 ffi::GTK_BORDER_STYLE_RIDGE => Self::Ridge,
2271 value => Self::__Unknown(value),
2272 }
2273 }
2274}
2275
2276impl StaticType for BorderStyle {
2277 #[inline]
2278 #[doc(alias = "gtk_border_style_get_type")]
2279 fn static_type() -> glib::Type {
2280 unsafe { from_glib(ffi::gtk_border_style_get_type()) }
2281 }
2282}
2283
2284impl glib::HasParamSpec for BorderStyle {
2285 type ParamSpec = glib::ParamSpecEnum;
2286 type SetValue = Self;
2287 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2288
2289 fn param_spec_builder() -> Self::BuilderFn {
2290 Self::ParamSpec::builder_with_default
2291 }
2292}
2293
2294impl glib::value::ValueType for BorderStyle {
2295 type Type = Self;
2296}
2297
2298unsafe impl<'a> glib::value::FromValue<'a> for BorderStyle {
2299 type Checker = glib::value::GenericValueTypeChecker<Self>;
2300
2301 #[inline]
2302 unsafe fn from_value(value: &'a glib::Value) -> Self {
2303 skip_assert_initialized!();
2304 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
2305 }
2306}
2307
2308impl ToValue for BorderStyle {
2309 #[inline]
2310 fn to_value(&self) -> glib::Value {
2311 let mut value = glib::Value::for_value_type::<Self>();
2312 unsafe {
2313 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2314 }
2315 value
2316 }
2317
2318 #[inline]
2319 fn value_type(&self) -> glib::Type {
2320 Self::static_type()
2321 }
2322}
2323
2324impl From<BorderStyle> for glib::Value {
2325 #[inline]
2326 fn from(v: BorderStyle) -> Self {
2327 skip_assert_initialized!();
2328 ToValue::to_value(&v)
2329 }
2330}
2331
2332#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2333#[non_exhaustive]
2334#[doc(alias = "GtkBuilderError")]
2335pub enum BuilderError {
2336 #[doc(alias = "GTK_BUILDER_ERROR_INVALID_TYPE_FUNCTION")]
2337 InvalidTypeFunction,
2338 #[doc(alias = "GTK_BUILDER_ERROR_UNHANDLED_TAG")]
2339 UnhandledTag,
2340 #[doc(alias = "GTK_BUILDER_ERROR_MISSING_ATTRIBUTE")]
2341 MissingAttribute,
2342 #[doc(alias = "GTK_BUILDER_ERROR_INVALID_ATTRIBUTE")]
2343 InvalidAttribute,
2344 #[doc(alias = "GTK_BUILDER_ERROR_INVALID_TAG")]
2345 InvalidTag,
2346 #[doc(alias = "GTK_BUILDER_ERROR_MISSING_PROPERTY_VALUE")]
2347 MissingPropertyValue,
2348 #[doc(alias = "GTK_BUILDER_ERROR_INVALID_VALUE")]
2349 InvalidValue,
2350 #[doc(alias = "GTK_BUILDER_ERROR_VERSION_MISMATCH")]
2351 VersionMismatch,
2352 #[doc(alias = "GTK_BUILDER_ERROR_DUPLICATE_ID")]
2353 DuplicateId,
2354 #[doc(alias = "GTK_BUILDER_ERROR_OBJECT_TYPE_REFUSED")]
2355 ObjectTypeRefused,
2356 #[doc(alias = "GTK_BUILDER_ERROR_TEMPLATE_MISMATCH")]
2357 TemplateMismatch,
2358 #[doc(alias = "GTK_BUILDER_ERROR_INVALID_PROPERTY")]
2359 InvalidProperty,
2360 #[doc(alias = "GTK_BUILDER_ERROR_INVALID_SIGNAL")]
2361 InvalidSignal,
2362 #[doc(alias = "GTK_BUILDER_ERROR_INVALID_ID")]
2363 InvalidId,
2364 #[doc(alias = "GTK_BUILDER_ERROR_INVALID_FUNCTION")]
2365 InvalidFunction,
2366 #[doc(hidden)]
2367 __Unknown(i32),
2368}
2369
2370#[doc(hidden)]
2371impl IntoGlib for BuilderError {
2372 type GlibType = ffi::GtkBuilderError;
2373
2374 fn into_glib(self) -> ffi::GtkBuilderError {
2375 match self {
2376 Self::InvalidTypeFunction => ffi::GTK_BUILDER_ERROR_INVALID_TYPE_FUNCTION,
2377 Self::UnhandledTag => ffi::GTK_BUILDER_ERROR_UNHANDLED_TAG,
2378 Self::MissingAttribute => ffi::GTK_BUILDER_ERROR_MISSING_ATTRIBUTE,
2379 Self::InvalidAttribute => ffi::GTK_BUILDER_ERROR_INVALID_ATTRIBUTE,
2380 Self::InvalidTag => ffi::GTK_BUILDER_ERROR_INVALID_TAG,
2381 Self::MissingPropertyValue => ffi::GTK_BUILDER_ERROR_MISSING_PROPERTY_VALUE,
2382 Self::InvalidValue => ffi::GTK_BUILDER_ERROR_INVALID_VALUE,
2383 Self::VersionMismatch => ffi::GTK_BUILDER_ERROR_VERSION_MISMATCH,
2384 Self::DuplicateId => ffi::GTK_BUILDER_ERROR_DUPLICATE_ID,
2385 Self::ObjectTypeRefused => ffi::GTK_BUILDER_ERROR_OBJECT_TYPE_REFUSED,
2386 Self::TemplateMismatch => ffi::GTK_BUILDER_ERROR_TEMPLATE_MISMATCH,
2387 Self::InvalidProperty => ffi::GTK_BUILDER_ERROR_INVALID_PROPERTY,
2388 Self::InvalidSignal => ffi::GTK_BUILDER_ERROR_INVALID_SIGNAL,
2389 Self::InvalidId => ffi::GTK_BUILDER_ERROR_INVALID_ID,
2390 Self::InvalidFunction => ffi::GTK_BUILDER_ERROR_INVALID_FUNCTION,
2391 Self::__Unknown(value) => value,
2392 }
2393 }
2394}
2395
2396#[doc(hidden)]
2397impl FromGlib<ffi::GtkBuilderError> for BuilderError {
2398 unsafe fn from_glib(value: ffi::GtkBuilderError) -> Self {
2399 skip_assert_initialized!();
2400
2401 match value {
2402 ffi::GTK_BUILDER_ERROR_INVALID_TYPE_FUNCTION => Self::InvalidTypeFunction,
2403 ffi::GTK_BUILDER_ERROR_UNHANDLED_TAG => Self::UnhandledTag,
2404 ffi::GTK_BUILDER_ERROR_MISSING_ATTRIBUTE => Self::MissingAttribute,
2405 ffi::GTK_BUILDER_ERROR_INVALID_ATTRIBUTE => Self::InvalidAttribute,
2406 ffi::GTK_BUILDER_ERROR_INVALID_TAG => Self::InvalidTag,
2407 ffi::GTK_BUILDER_ERROR_MISSING_PROPERTY_VALUE => Self::MissingPropertyValue,
2408 ffi::GTK_BUILDER_ERROR_INVALID_VALUE => Self::InvalidValue,
2409 ffi::GTK_BUILDER_ERROR_VERSION_MISMATCH => Self::VersionMismatch,
2410 ffi::GTK_BUILDER_ERROR_DUPLICATE_ID => Self::DuplicateId,
2411 ffi::GTK_BUILDER_ERROR_OBJECT_TYPE_REFUSED => Self::ObjectTypeRefused,
2412 ffi::GTK_BUILDER_ERROR_TEMPLATE_MISMATCH => Self::TemplateMismatch,
2413 ffi::GTK_BUILDER_ERROR_INVALID_PROPERTY => Self::InvalidProperty,
2414 ffi::GTK_BUILDER_ERROR_INVALID_SIGNAL => Self::InvalidSignal,
2415 ffi::GTK_BUILDER_ERROR_INVALID_ID => Self::InvalidId,
2416 ffi::GTK_BUILDER_ERROR_INVALID_FUNCTION => Self::InvalidFunction,
2417 value => Self::__Unknown(value),
2418 }
2419 }
2420}
2421
2422impl glib::error::ErrorDomain for BuilderError {
2423 #[inline]
2424 fn domain() -> glib::Quark {
2425 skip_assert_initialized!();
2426
2427 unsafe { from_glib(ffi::gtk_builder_error_quark()) }
2428 }
2429
2430 #[inline]
2431 fn code(self) -> i32 {
2432 self.into_glib()
2433 }
2434
2435 #[inline]
2436 #[allow(clippy::match_single_binding)]
2437 fn from(code: i32) -> Option<Self> {
2438 skip_assert_initialized!();
2439 match unsafe { from_glib(code) } {
2440 value => Some(value),
2441 }
2442 }
2443}
2444
2445impl StaticType for BuilderError {
2446 #[inline]
2447 #[doc(alias = "gtk_builder_error_get_type")]
2448 fn static_type() -> glib::Type {
2449 unsafe { from_glib(ffi::gtk_builder_error_get_type()) }
2450 }
2451}
2452
2453impl glib::HasParamSpec for BuilderError {
2454 type ParamSpec = glib::ParamSpecEnum;
2455 type SetValue = Self;
2456 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2457
2458 fn param_spec_builder() -> Self::BuilderFn {
2459 Self::ParamSpec::builder_with_default
2460 }
2461}
2462
2463impl glib::value::ValueType for BuilderError {
2464 type Type = Self;
2465}
2466
2467unsafe impl<'a> glib::value::FromValue<'a> for BuilderError {
2468 type Checker = glib::value::GenericValueTypeChecker<Self>;
2469
2470 #[inline]
2471 unsafe fn from_value(value: &'a glib::Value) -> Self {
2472 skip_assert_initialized!();
2473 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
2474 }
2475}
2476
2477impl ToValue for BuilderError {
2478 #[inline]
2479 fn to_value(&self) -> glib::Value {
2480 let mut value = glib::Value::for_value_type::<Self>();
2481 unsafe {
2482 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2483 }
2484 value
2485 }
2486
2487 #[inline]
2488 fn value_type(&self) -> glib::Type {
2489 Self::static_type()
2490 }
2491}
2492
2493impl From<BuilderError> for glib::Value {
2494 #[inline]
2495 fn from(v: BuilderError) -> Self {
2496 skip_assert_initialized!();
2497 ToValue::to_value(&v)
2498 }
2499}
2500
2501#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2502#[non_exhaustive]
2503#[doc(alias = "GtkButtonsType")]
2504pub enum ButtonsType {
2505 #[doc(alias = "GTK_BUTTONS_NONE")]
2506 None,
2507 #[doc(alias = "GTK_BUTTONS_OK")]
2508 Ok,
2509 #[doc(alias = "GTK_BUTTONS_CLOSE")]
2510 Close,
2511 #[doc(alias = "GTK_BUTTONS_CANCEL")]
2512 Cancel,
2513 #[doc(alias = "GTK_BUTTONS_YES_NO")]
2514 YesNo,
2515 #[doc(alias = "GTK_BUTTONS_OK_CANCEL")]
2516 OkCancel,
2517 #[doc(hidden)]
2518 __Unknown(i32),
2519}
2520
2521#[doc(hidden)]
2522impl IntoGlib for ButtonsType {
2523 type GlibType = ffi::GtkButtonsType;
2524
2525 #[inline]
2526 fn into_glib(self) -> ffi::GtkButtonsType {
2527 match self {
2528 Self::None => ffi::GTK_BUTTONS_NONE,
2529 Self::Ok => ffi::GTK_BUTTONS_OK,
2530 Self::Close => ffi::GTK_BUTTONS_CLOSE,
2531 Self::Cancel => ffi::GTK_BUTTONS_CANCEL,
2532 Self::YesNo => ffi::GTK_BUTTONS_YES_NO,
2533 Self::OkCancel => ffi::GTK_BUTTONS_OK_CANCEL,
2534 Self::__Unknown(value) => value,
2535 }
2536 }
2537}
2538
2539#[doc(hidden)]
2540impl FromGlib<ffi::GtkButtonsType> for ButtonsType {
2541 #[inline]
2542 unsafe fn from_glib(value: ffi::GtkButtonsType) -> Self {
2543 skip_assert_initialized!();
2544
2545 match value {
2546 ffi::GTK_BUTTONS_NONE => Self::None,
2547 ffi::GTK_BUTTONS_OK => Self::Ok,
2548 ffi::GTK_BUTTONS_CLOSE => Self::Close,
2549 ffi::GTK_BUTTONS_CANCEL => Self::Cancel,
2550 ffi::GTK_BUTTONS_YES_NO => Self::YesNo,
2551 ffi::GTK_BUTTONS_OK_CANCEL => Self::OkCancel,
2552 value => Self::__Unknown(value),
2553 }
2554 }
2555}
2556
2557impl StaticType for ButtonsType {
2558 #[inline]
2559 #[doc(alias = "gtk_buttons_type_get_type")]
2560 fn static_type() -> glib::Type {
2561 unsafe { from_glib(ffi::gtk_buttons_type_get_type()) }
2562 }
2563}
2564
2565impl glib::HasParamSpec for ButtonsType {
2566 type ParamSpec = glib::ParamSpecEnum;
2567 type SetValue = Self;
2568 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2569
2570 fn param_spec_builder() -> Self::BuilderFn {
2571 Self::ParamSpec::builder_with_default
2572 }
2573}
2574
2575impl glib::value::ValueType for ButtonsType {
2576 type Type = Self;
2577}
2578
2579unsafe impl<'a> glib::value::FromValue<'a> for ButtonsType {
2580 type Checker = glib::value::GenericValueTypeChecker<Self>;
2581
2582 #[inline]
2583 unsafe fn from_value(value: &'a glib::Value) -> Self {
2584 skip_assert_initialized!();
2585 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
2586 }
2587}
2588
2589impl ToValue for ButtonsType {
2590 #[inline]
2591 fn to_value(&self) -> glib::Value {
2592 let mut value = glib::Value::for_value_type::<Self>();
2593 unsafe {
2594 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2595 }
2596 value
2597 }
2598
2599 #[inline]
2600 fn value_type(&self) -> glib::Type {
2601 Self::static_type()
2602 }
2603}
2604
2605impl From<ButtonsType> for glib::Value {
2606 #[inline]
2607 fn from(v: ButtonsType) -> Self {
2608 skip_assert_initialized!();
2609 ToValue::to_value(&v)
2610 }
2611}
2612
2613#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2614#[non_exhaustive]
2615#[doc(alias = "GtkCellRendererAccelMode")]
2616pub enum CellRendererAccelMode {
2617 #[doc(alias = "GTK_CELL_RENDERER_ACCEL_MODE_GTK")]
2618 Gtk,
2619 #[doc(alias = "GTK_CELL_RENDERER_ACCEL_MODE_OTHER")]
2620 Other,
2621 #[doc(hidden)]
2622 __Unknown(i32),
2623}
2624
2625#[doc(hidden)]
2626impl IntoGlib for CellRendererAccelMode {
2627 type GlibType = ffi::GtkCellRendererAccelMode;
2628
2629 #[inline]
2630 fn into_glib(self) -> ffi::GtkCellRendererAccelMode {
2631 match self {
2632 Self::Gtk => ffi::GTK_CELL_RENDERER_ACCEL_MODE_GTK,
2633 Self::Other => ffi::GTK_CELL_RENDERER_ACCEL_MODE_OTHER,
2634 Self::__Unknown(value) => value,
2635 }
2636 }
2637}
2638
2639#[doc(hidden)]
2640impl FromGlib<ffi::GtkCellRendererAccelMode> for CellRendererAccelMode {
2641 #[inline]
2642 unsafe fn from_glib(value: ffi::GtkCellRendererAccelMode) -> Self {
2643 skip_assert_initialized!();
2644
2645 match value {
2646 ffi::GTK_CELL_RENDERER_ACCEL_MODE_GTK => Self::Gtk,
2647 ffi::GTK_CELL_RENDERER_ACCEL_MODE_OTHER => Self::Other,
2648 value => Self::__Unknown(value),
2649 }
2650 }
2651}
2652
2653impl StaticType for CellRendererAccelMode {
2654 #[inline]
2655 #[doc(alias = "gtk_cell_renderer_accel_mode_get_type")]
2656 fn static_type() -> glib::Type {
2657 unsafe { from_glib(ffi::gtk_cell_renderer_accel_mode_get_type()) }
2658 }
2659}
2660
2661impl glib::HasParamSpec for CellRendererAccelMode {
2662 type ParamSpec = glib::ParamSpecEnum;
2663 type SetValue = Self;
2664 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2665
2666 fn param_spec_builder() -> Self::BuilderFn {
2667 Self::ParamSpec::builder_with_default
2668 }
2669}
2670
2671impl glib::value::ValueType for CellRendererAccelMode {
2672 type Type = Self;
2673}
2674
2675unsafe impl<'a> glib::value::FromValue<'a> for CellRendererAccelMode {
2676 type Checker = glib::value::GenericValueTypeChecker<Self>;
2677
2678 #[inline]
2679 unsafe fn from_value(value: &'a glib::Value) -> Self {
2680 skip_assert_initialized!();
2681 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
2682 }
2683}
2684
2685impl ToValue for CellRendererAccelMode {
2686 #[inline]
2687 fn to_value(&self) -> glib::Value {
2688 let mut value = glib::Value::for_value_type::<Self>();
2689 unsafe {
2690 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2691 }
2692 value
2693 }
2694
2695 #[inline]
2696 fn value_type(&self) -> glib::Type {
2697 Self::static_type()
2698 }
2699}
2700
2701impl From<CellRendererAccelMode> for glib::Value {
2702 #[inline]
2703 fn from(v: CellRendererAccelMode) -> Self {
2704 skip_assert_initialized!();
2705 ToValue::to_value(&v)
2706 }
2707}
2708
2709#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2710#[non_exhaustive]
2711#[doc(alias = "GtkCellRendererMode")]
2712pub enum CellRendererMode {
2713 #[doc(alias = "GTK_CELL_RENDERER_MODE_INERT")]
2714 Inert,
2715 #[doc(alias = "GTK_CELL_RENDERER_MODE_ACTIVATABLE")]
2716 Activatable,
2717 #[doc(alias = "GTK_CELL_RENDERER_MODE_EDITABLE")]
2718 Editable,
2719 #[doc(hidden)]
2720 __Unknown(i32),
2721}
2722
2723#[doc(hidden)]
2724impl IntoGlib for CellRendererMode {
2725 type GlibType = ffi::GtkCellRendererMode;
2726
2727 #[inline]
2728 fn into_glib(self) -> ffi::GtkCellRendererMode {
2729 match self {
2730 Self::Inert => ffi::GTK_CELL_RENDERER_MODE_INERT,
2731 Self::Activatable => ffi::GTK_CELL_RENDERER_MODE_ACTIVATABLE,
2732 Self::Editable => ffi::GTK_CELL_RENDERER_MODE_EDITABLE,
2733 Self::__Unknown(value) => value,
2734 }
2735 }
2736}
2737
2738#[doc(hidden)]
2739impl FromGlib<ffi::GtkCellRendererMode> for CellRendererMode {
2740 #[inline]
2741 unsafe fn from_glib(value: ffi::GtkCellRendererMode) -> Self {
2742 skip_assert_initialized!();
2743
2744 match value {
2745 ffi::GTK_CELL_RENDERER_MODE_INERT => Self::Inert,
2746 ffi::GTK_CELL_RENDERER_MODE_ACTIVATABLE => Self::Activatable,
2747 ffi::GTK_CELL_RENDERER_MODE_EDITABLE => Self::Editable,
2748 value => Self::__Unknown(value),
2749 }
2750 }
2751}
2752
2753impl StaticType for CellRendererMode {
2754 #[inline]
2755 #[doc(alias = "gtk_cell_renderer_mode_get_type")]
2756 fn static_type() -> glib::Type {
2757 unsafe { from_glib(ffi::gtk_cell_renderer_mode_get_type()) }
2758 }
2759}
2760
2761impl glib::HasParamSpec for CellRendererMode {
2762 type ParamSpec = glib::ParamSpecEnum;
2763 type SetValue = Self;
2764 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2765
2766 fn param_spec_builder() -> Self::BuilderFn {
2767 Self::ParamSpec::builder_with_default
2768 }
2769}
2770
2771impl glib::value::ValueType for CellRendererMode {
2772 type Type = Self;
2773}
2774
2775unsafe impl<'a> glib::value::FromValue<'a> for CellRendererMode {
2776 type Checker = glib::value::GenericValueTypeChecker<Self>;
2777
2778 #[inline]
2779 unsafe fn from_value(value: &'a glib::Value) -> Self {
2780 skip_assert_initialized!();
2781 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
2782 }
2783}
2784
2785impl ToValue for CellRendererMode {
2786 #[inline]
2787 fn to_value(&self) -> glib::Value {
2788 let mut value = glib::Value::for_value_type::<Self>();
2789 unsafe {
2790 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2791 }
2792 value
2793 }
2794
2795 #[inline]
2796 fn value_type(&self) -> glib::Type {
2797 Self::static_type()
2798 }
2799}
2800
2801impl From<CellRendererMode> for glib::Value {
2802 #[inline]
2803 fn from(v: CellRendererMode) -> Self {
2804 skip_assert_initialized!();
2805 ToValue::to_value(&v)
2806 }
2807}
2808
2809#[cfg(feature = "v4_10")]
2810#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
2811#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2812#[non_exhaustive]
2813#[doc(alias = "GtkCollation")]
2814pub enum Collation {
2815 #[doc(alias = "GTK_COLLATION_NONE")]
2816 None,
2817 #[doc(alias = "GTK_COLLATION_UNICODE")]
2818 Unicode,
2819 #[doc(alias = "GTK_COLLATION_FILENAME")]
2820 Filename,
2821 #[doc(hidden)]
2822 __Unknown(i32),
2823}
2824
2825#[cfg(feature = "v4_10")]
2826#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
2827#[doc(hidden)]
2828impl IntoGlib for Collation {
2829 type GlibType = ffi::GtkCollation;
2830
2831 #[inline]
2832 fn into_glib(self) -> ffi::GtkCollation {
2833 match self {
2834 Self::None => ffi::GTK_COLLATION_NONE,
2835 Self::Unicode => ffi::GTK_COLLATION_UNICODE,
2836 Self::Filename => ffi::GTK_COLLATION_FILENAME,
2837 Self::__Unknown(value) => value,
2838 }
2839 }
2840}
2841
2842#[cfg(feature = "v4_10")]
2843#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
2844#[doc(hidden)]
2845impl FromGlib<ffi::GtkCollation> for Collation {
2846 #[inline]
2847 unsafe fn from_glib(value: ffi::GtkCollation) -> Self {
2848 skip_assert_initialized!();
2849
2850 match value {
2851 ffi::GTK_COLLATION_NONE => Self::None,
2852 ffi::GTK_COLLATION_UNICODE => Self::Unicode,
2853 ffi::GTK_COLLATION_FILENAME => Self::Filename,
2854 value => Self::__Unknown(value),
2855 }
2856 }
2857}
2858
2859#[cfg(feature = "v4_10")]
2860#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
2861impl StaticType for Collation {
2862 #[inline]
2863 #[doc(alias = "gtk_collation_get_type")]
2864 fn static_type() -> glib::Type {
2865 unsafe { from_glib(ffi::gtk_collation_get_type()) }
2866 }
2867}
2868
2869#[cfg(feature = "v4_10")]
2870#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
2871impl glib::HasParamSpec for Collation {
2872 type ParamSpec = glib::ParamSpecEnum;
2873 type SetValue = Self;
2874 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2875
2876 fn param_spec_builder() -> Self::BuilderFn {
2877 Self::ParamSpec::builder_with_default
2878 }
2879}
2880
2881#[cfg(feature = "v4_10")]
2882#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
2883impl glib::value::ValueType for Collation {
2884 type Type = Self;
2885}
2886
2887#[cfg(feature = "v4_10")]
2888#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
2889unsafe impl<'a> glib::value::FromValue<'a> for Collation {
2890 type Checker = glib::value::GenericValueTypeChecker<Self>;
2891
2892 #[inline]
2893 unsafe fn from_value(value: &'a glib::Value) -> Self {
2894 skip_assert_initialized!();
2895 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
2896 }
2897}
2898
2899#[cfg(feature = "v4_10")]
2900#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
2901impl ToValue for Collation {
2902 #[inline]
2903 fn to_value(&self) -> glib::Value {
2904 let mut value = glib::Value::for_value_type::<Self>();
2905 unsafe {
2906 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2907 }
2908 value
2909 }
2910
2911 #[inline]
2912 fn value_type(&self) -> glib::Type {
2913 Self::static_type()
2914 }
2915}
2916
2917#[cfg(feature = "v4_10")]
2918#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
2919impl From<Collation> for glib::Value {
2920 #[inline]
2921 fn from(v: Collation) -> Self {
2922 skip_assert_initialized!();
2923 ToValue::to_value(&v)
2924 }
2925}
2926
2927#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2928#[non_exhaustive]
2929#[doc(alias = "GtkConstraintAttribute")]
2930pub enum ConstraintAttribute {
2931 #[doc(alias = "GTK_CONSTRAINT_ATTRIBUTE_NONE")]
2932 None,
2933 #[doc(alias = "GTK_CONSTRAINT_ATTRIBUTE_LEFT")]
2934 Left,
2935 #[doc(alias = "GTK_CONSTRAINT_ATTRIBUTE_RIGHT")]
2936 Right,
2937 #[doc(alias = "GTK_CONSTRAINT_ATTRIBUTE_TOP")]
2938 Top,
2939 #[doc(alias = "GTK_CONSTRAINT_ATTRIBUTE_BOTTOM")]
2940 Bottom,
2941 #[doc(alias = "GTK_CONSTRAINT_ATTRIBUTE_START")]
2942 Start,
2943 #[doc(alias = "GTK_CONSTRAINT_ATTRIBUTE_END")]
2944 End,
2945 #[doc(alias = "GTK_CONSTRAINT_ATTRIBUTE_WIDTH")]
2946 Width,
2947 #[doc(alias = "GTK_CONSTRAINT_ATTRIBUTE_HEIGHT")]
2948 Height,
2949 #[doc(alias = "GTK_CONSTRAINT_ATTRIBUTE_CENTER_X")]
2950 CenterX,
2951 #[doc(alias = "GTK_CONSTRAINT_ATTRIBUTE_CENTER_Y")]
2952 CenterY,
2953 #[doc(alias = "GTK_CONSTRAINT_ATTRIBUTE_BASELINE")]
2954 Baseline,
2955 #[doc(hidden)]
2956 __Unknown(i32),
2957}
2958
2959#[doc(hidden)]
2960impl IntoGlib for ConstraintAttribute {
2961 type GlibType = ffi::GtkConstraintAttribute;
2962
2963 #[inline]
2964 fn into_glib(self) -> ffi::GtkConstraintAttribute {
2965 match self {
2966 Self::None => ffi::GTK_CONSTRAINT_ATTRIBUTE_NONE,
2967 Self::Left => ffi::GTK_CONSTRAINT_ATTRIBUTE_LEFT,
2968 Self::Right => ffi::GTK_CONSTRAINT_ATTRIBUTE_RIGHT,
2969 Self::Top => ffi::GTK_CONSTRAINT_ATTRIBUTE_TOP,
2970 Self::Bottom => ffi::GTK_CONSTRAINT_ATTRIBUTE_BOTTOM,
2971 Self::Start => ffi::GTK_CONSTRAINT_ATTRIBUTE_START,
2972 Self::End => ffi::GTK_CONSTRAINT_ATTRIBUTE_END,
2973 Self::Width => ffi::GTK_CONSTRAINT_ATTRIBUTE_WIDTH,
2974 Self::Height => ffi::GTK_CONSTRAINT_ATTRIBUTE_HEIGHT,
2975 Self::CenterX => ffi::GTK_CONSTRAINT_ATTRIBUTE_CENTER_X,
2976 Self::CenterY => ffi::GTK_CONSTRAINT_ATTRIBUTE_CENTER_Y,
2977 Self::Baseline => ffi::GTK_CONSTRAINT_ATTRIBUTE_BASELINE,
2978 Self::__Unknown(value) => value,
2979 }
2980 }
2981}
2982
2983#[doc(hidden)]
2984impl FromGlib<ffi::GtkConstraintAttribute> for ConstraintAttribute {
2985 #[inline]
2986 unsafe fn from_glib(value: ffi::GtkConstraintAttribute) -> Self {
2987 skip_assert_initialized!();
2988
2989 match value {
2990 ffi::GTK_CONSTRAINT_ATTRIBUTE_NONE => Self::None,
2991 ffi::GTK_CONSTRAINT_ATTRIBUTE_LEFT => Self::Left,
2992 ffi::GTK_CONSTRAINT_ATTRIBUTE_RIGHT => Self::Right,
2993 ffi::GTK_CONSTRAINT_ATTRIBUTE_TOP => Self::Top,
2994 ffi::GTK_CONSTRAINT_ATTRIBUTE_BOTTOM => Self::Bottom,
2995 ffi::GTK_CONSTRAINT_ATTRIBUTE_START => Self::Start,
2996 ffi::GTK_CONSTRAINT_ATTRIBUTE_END => Self::End,
2997 ffi::GTK_CONSTRAINT_ATTRIBUTE_WIDTH => Self::Width,
2998 ffi::GTK_CONSTRAINT_ATTRIBUTE_HEIGHT => Self::Height,
2999 ffi::GTK_CONSTRAINT_ATTRIBUTE_CENTER_X => Self::CenterX,
3000 ffi::GTK_CONSTRAINT_ATTRIBUTE_CENTER_Y => Self::CenterY,
3001 ffi::GTK_CONSTRAINT_ATTRIBUTE_BASELINE => Self::Baseline,
3002 value => Self::__Unknown(value),
3003 }
3004 }
3005}
3006
3007impl StaticType for ConstraintAttribute {
3008 #[inline]
3009 #[doc(alias = "gtk_constraint_attribute_get_type")]
3010 fn static_type() -> glib::Type {
3011 unsafe { from_glib(ffi::gtk_constraint_attribute_get_type()) }
3012 }
3013}
3014
3015impl glib::HasParamSpec for ConstraintAttribute {
3016 type ParamSpec = glib::ParamSpecEnum;
3017 type SetValue = Self;
3018 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
3019
3020 fn param_spec_builder() -> Self::BuilderFn {
3021 Self::ParamSpec::builder_with_default
3022 }
3023}
3024
3025impl glib::value::ValueType for ConstraintAttribute {
3026 type Type = Self;
3027}
3028
3029unsafe impl<'a> glib::value::FromValue<'a> for ConstraintAttribute {
3030 type Checker = glib::value::GenericValueTypeChecker<Self>;
3031
3032 #[inline]
3033 unsafe fn from_value(value: &'a glib::Value) -> Self {
3034 skip_assert_initialized!();
3035 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
3036 }
3037}
3038
3039impl ToValue for ConstraintAttribute {
3040 #[inline]
3041 fn to_value(&self) -> glib::Value {
3042 let mut value = glib::Value::for_value_type::<Self>();
3043 unsafe {
3044 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
3045 }
3046 value
3047 }
3048
3049 #[inline]
3050 fn value_type(&self) -> glib::Type {
3051 Self::static_type()
3052 }
3053}
3054
3055impl From<ConstraintAttribute> for glib::Value {
3056 #[inline]
3057 fn from(v: ConstraintAttribute) -> Self {
3058 skip_assert_initialized!();
3059 ToValue::to_value(&v)
3060 }
3061}
3062
3063#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3064#[non_exhaustive]
3065#[doc(alias = "GtkConstraintRelation")]
3066pub enum ConstraintRelation {
3067 #[doc(alias = "GTK_CONSTRAINT_RELATION_LE")]
3068 Le,
3069 #[doc(alias = "GTK_CONSTRAINT_RELATION_EQ")]
3070 Eq,
3071 #[doc(alias = "GTK_CONSTRAINT_RELATION_GE")]
3072 Ge,
3073 #[doc(hidden)]
3074 __Unknown(i32),
3075}
3076
3077#[doc(hidden)]
3078impl IntoGlib for ConstraintRelation {
3079 type GlibType = ffi::GtkConstraintRelation;
3080
3081 #[inline]
3082 fn into_glib(self) -> ffi::GtkConstraintRelation {
3083 match self {
3084 Self::Le => ffi::GTK_CONSTRAINT_RELATION_LE,
3085 Self::Eq => ffi::GTK_CONSTRAINT_RELATION_EQ,
3086 Self::Ge => ffi::GTK_CONSTRAINT_RELATION_GE,
3087 Self::__Unknown(value) => value,
3088 }
3089 }
3090}
3091
3092#[doc(hidden)]
3093impl FromGlib<ffi::GtkConstraintRelation> for ConstraintRelation {
3094 #[inline]
3095 unsafe fn from_glib(value: ffi::GtkConstraintRelation) -> Self {
3096 skip_assert_initialized!();
3097
3098 match value {
3099 ffi::GTK_CONSTRAINT_RELATION_LE => Self::Le,
3100 ffi::GTK_CONSTRAINT_RELATION_EQ => Self::Eq,
3101 ffi::GTK_CONSTRAINT_RELATION_GE => Self::Ge,
3102 value => Self::__Unknown(value),
3103 }
3104 }
3105}
3106
3107impl StaticType for ConstraintRelation {
3108 #[inline]
3109 #[doc(alias = "gtk_constraint_relation_get_type")]
3110 fn static_type() -> glib::Type {
3111 unsafe { from_glib(ffi::gtk_constraint_relation_get_type()) }
3112 }
3113}
3114
3115impl glib::HasParamSpec for ConstraintRelation {
3116 type ParamSpec = glib::ParamSpecEnum;
3117 type SetValue = Self;
3118 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
3119
3120 fn param_spec_builder() -> Self::BuilderFn {
3121 Self::ParamSpec::builder_with_default
3122 }
3123}
3124
3125impl glib::value::ValueType for ConstraintRelation {
3126 type Type = Self;
3127}
3128
3129unsafe impl<'a> glib::value::FromValue<'a> for ConstraintRelation {
3130 type Checker = glib::value::GenericValueTypeChecker<Self>;
3131
3132 #[inline]
3133 unsafe fn from_value(value: &'a glib::Value) -> Self {
3134 skip_assert_initialized!();
3135 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
3136 }
3137}
3138
3139impl ToValue for ConstraintRelation {
3140 #[inline]
3141 fn to_value(&self) -> glib::Value {
3142 let mut value = glib::Value::for_value_type::<Self>();
3143 unsafe {
3144 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
3145 }
3146 value
3147 }
3148
3149 #[inline]
3150 fn value_type(&self) -> glib::Type {
3151 Self::static_type()
3152 }
3153}
3154
3155impl From<ConstraintRelation> for glib::Value {
3156 #[inline]
3157 fn from(v: ConstraintRelation) -> Self {
3158 skip_assert_initialized!();
3159 ToValue::to_value(&v)
3160 }
3161}
3162
3163#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3164#[non_exhaustive]
3165#[doc(alias = "GtkConstraintStrength")]
3166pub enum ConstraintStrength {
3167 #[doc(alias = "GTK_CONSTRAINT_STRENGTH_REQUIRED")]
3168 Required,
3169 #[doc(alias = "GTK_CONSTRAINT_STRENGTH_STRONG")]
3170 Strong,
3171 #[doc(alias = "GTK_CONSTRAINT_STRENGTH_MEDIUM")]
3172 Medium,
3173 #[doc(alias = "GTK_CONSTRAINT_STRENGTH_WEAK")]
3174 Weak,
3175 #[doc(hidden)]
3176 __Unknown(i32),
3177}
3178
3179#[doc(hidden)]
3180impl IntoGlib for ConstraintStrength {
3181 type GlibType = ffi::GtkConstraintStrength;
3182
3183 #[inline]
3184 fn into_glib(self) -> ffi::GtkConstraintStrength {
3185 match self {
3186 Self::Required => ffi::GTK_CONSTRAINT_STRENGTH_REQUIRED,
3187 Self::Strong => ffi::GTK_CONSTRAINT_STRENGTH_STRONG,
3188 Self::Medium => ffi::GTK_CONSTRAINT_STRENGTH_MEDIUM,
3189 Self::Weak => ffi::GTK_CONSTRAINT_STRENGTH_WEAK,
3190 Self::__Unknown(value) => value,
3191 }
3192 }
3193}
3194
3195#[doc(hidden)]
3196impl FromGlib<ffi::GtkConstraintStrength> for ConstraintStrength {
3197 #[inline]
3198 unsafe fn from_glib(value: ffi::GtkConstraintStrength) -> Self {
3199 skip_assert_initialized!();
3200
3201 match value {
3202 ffi::GTK_CONSTRAINT_STRENGTH_REQUIRED => Self::Required,
3203 ffi::GTK_CONSTRAINT_STRENGTH_STRONG => Self::Strong,
3204 ffi::GTK_CONSTRAINT_STRENGTH_MEDIUM => Self::Medium,
3205 ffi::GTK_CONSTRAINT_STRENGTH_WEAK => Self::Weak,
3206 value => Self::__Unknown(value),
3207 }
3208 }
3209}
3210
3211impl StaticType for ConstraintStrength {
3212 #[inline]
3213 #[doc(alias = "gtk_constraint_strength_get_type")]
3214 fn static_type() -> glib::Type {
3215 unsafe { from_glib(ffi::gtk_constraint_strength_get_type()) }
3216 }
3217}
3218
3219impl glib::HasParamSpec for ConstraintStrength {
3220 type ParamSpec = glib::ParamSpecEnum;
3221 type SetValue = Self;
3222 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
3223
3224 fn param_spec_builder() -> Self::BuilderFn {
3225 Self::ParamSpec::builder_with_default
3226 }
3227}
3228
3229impl glib::value::ValueType for ConstraintStrength {
3230 type Type = Self;
3231}
3232
3233unsafe impl<'a> glib::value::FromValue<'a> for ConstraintStrength {
3234 type Checker = glib::value::GenericValueTypeChecker<Self>;
3235
3236 #[inline]
3237 unsafe fn from_value(value: &'a glib::Value) -> Self {
3238 skip_assert_initialized!();
3239 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
3240 }
3241}
3242
3243impl ToValue for ConstraintStrength {
3244 #[inline]
3245 fn to_value(&self) -> glib::Value {
3246 let mut value = glib::Value::for_value_type::<Self>();
3247 unsafe {
3248 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
3249 }
3250 value
3251 }
3252
3253 #[inline]
3254 fn value_type(&self) -> glib::Type {
3255 Self::static_type()
3256 }
3257}
3258
3259impl From<ConstraintStrength> for glib::Value {
3260 #[inline]
3261 fn from(v: ConstraintStrength) -> Self {
3262 skip_assert_initialized!();
3263 ToValue::to_value(&v)
3264 }
3265}
3266
3267#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3268#[non_exhaustive]
3269#[doc(alias = "GtkConstraintVflParserError")]
3270pub enum ConstraintVflParserError {
3271 #[doc(alias = "GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_SYMBOL")]
3272 Symbol,
3273 #[doc(alias = "GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_ATTRIBUTE")]
3274 Attribute,
3275 #[doc(alias = "GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_VIEW")]
3276 View,
3277 #[doc(alias = "GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_METRIC")]
3278 Metric,
3279 #[doc(alias = "GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_PRIORITY")]
3280 Priority,
3281 #[doc(alias = "GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_RELATION")]
3282 Relation,
3283 #[doc(hidden)]
3284 __Unknown(i32),
3285}
3286
3287#[doc(hidden)]
3288impl IntoGlib for ConstraintVflParserError {
3289 type GlibType = ffi::GtkConstraintVflParserError;
3290
3291 #[inline]
3292 fn into_glib(self) -> ffi::GtkConstraintVflParserError {
3293 match self {
3294 Self::Symbol => ffi::GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_SYMBOL,
3295 Self::Attribute => ffi::GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_ATTRIBUTE,
3296 Self::View => ffi::GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_VIEW,
3297 Self::Metric => ffi::GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_METRIC,
3298 Self::Priority => ffi::GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_PRIORITY,
3299 Self::Relation => ffi::GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_RELATION,
3300 Self::__Unknown(value) => value,
3301 }
3302 }
3303}
3304
3305#[doc(hidden)]
3306impl FromGlib<ffi::GtkConstraintVflParserError> for ConstraintVflParserError {
3307 #[inline]
3308 unsafe fn from_glib(value: ffi::GtkConstraintVflParserError) -> Self {
3309 skip_assert_initialized!();
3310
3311 match value {
3312 ffi::GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_SYMBOL => Self::Symbol,
3313 ffi::GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_ATTRIBUTE => Self::Attribute,
3314 ffi::GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_VIEW => Self::View,
3315 ffi::GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_METRIC => Self::Metric,
3316 ffi::GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_PRIORITY => Self::Priority,
3317 ffi::GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_RELATION => Self::Relation,
3318 value => Self::__Unknown(value),
3319 }
3320 }
3321}
3322
3323impl glib::error::ErrorDomain for ConstraintVflParserError {
3324 #[inline]
3325 fn domain() -> glib::Quark {
3326 skip_assert_initialized!();
3327
3328 unsafe { from_glib(ffi::gtk_constraint_vfl_parser_error_quark()) }
3329 }
3330
3331 #[inline]
3332 fn code(self) -> i32 {
3333 self.into_glib()
3334 }
3335
3336 #[inline]
3337 #[allow(clippy::match_single_binding)]
3338 fn from(code: i32) -> Option<Self> {
3339 skip_assert_initialized!();
3340 match unsafe { from_glib(code) } {
3341 value => Some(value),
3342 }
3343 }
3344}
3345
3346impl StaticType for ConstraintVflParserError {
3347 #[inline]
3348 #[doc(alias = "gtk_constraint_vfl_parser_error_get_type")]
3349 fn static_type() -> glib::Type {
3350 unsafe { from_glib(ffi::gtk_constraint_vfl_parser_error_get_type()) }
3351 }
3352}
3353
3354impl glib::HasParamSpec for ConstraintVflParserError {
3355 type ParamSpec = glib::ParamSpecEnum;
3356 type SetValue = Self;
3357 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
3358
3359 fn param_spec_builder() -> Self::BuilderFn {
3360 Self::ParamSpec::builder_with_default
3361 }
3362}
3363
3364impl glib::value::ValueType for ConstraintVflParserError {
3365 type Type = Self;
3366}
3367
3368unsafe impl<'a> glib::value::FromValue<'a> for ConstraintVflParserError {
3369 type Checker = glib::value::GenericValueTypeChecker<Self>;
3370
3371 #[inline]
3372 unsafe fn from_value(value: &'a glib::Value) -> Self {
3373 skip_assert_initialized!();
3374 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
3375 }
3376}
3377
3378impl ToValue for ConstraintVflParserError {
3379 #[inline]
3380 fn to_value(&self) -> glib::Value {
3381 let mut value = glib::Value::for_value_type::<Self>();
3382 unsafe {
3383 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
3384 }
3385 value
3386 }
3387
3388 #[inline]
3389 fn value_type(&self) -> glib::Type {
3390 Self::static_type()
3391 }
3392}
3393
3394impl From<ConstraintVflParserError> for glib::Value {
3395 #[inline]
3396 fn from(v: ConstraintVflParserError) -> Self {
3397 skip_assert_initialized!();
3398 ToValue::to_value(&v)
3399 }
3400}
3401
3402#[cfg(feature = "v4_8")]
3403#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
3404#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3405#[non_exhaustive]
3406#[doc(alias = "GtkContentFit")]
3407pub enum ContentFit {
3408 #[doc(alias = "GTK_CONTENT_FIT_FILL")]
3409 Fill,
3410 #[doc(alias = "GTK_CONTENT_FIT_CONTAIN")]
3411 Contain,
3412 #[doc(alias = "GTK_CONTENT_FIT_COVER")]
3413 Cover,
3414 #[doc(alias = "GTK_CONTENT_FIT_SCALE_DOWN")]
3415 ScaleDown,
3416 #[doc(hidden)]
3417 __Unknown(i32),
3418}
3419
3420#[cfg(feature = "v4_8")]
3421#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
3422#[doc(hidden)]
3423impl IntoGlib for ContentFit {
3424 type GlibType = ffi::GtkContentFit;
3425
3426 #[inline]
3427 fn into_glib(self) -> ffi::GtkContentFit {
3428 match self {
3429 Self::Fill => ffi::GTK_CONTENT_FIT_FILL,
3430 Self::Contain => ffi::GTK_CONTENT_FIT_CONTAIN,
3431 Self::Cover => ffi::GTK_CONTENT_FIT_COVER,
3432 Self::ScaleDown => ffi::GTK_CONTENT_FIT_SCALE_DOWN,
3433 Self::__Unknown(value) => value,
3434 }
3435 }
3436}
3437
3438#[cfg(feature = "v4_8")]
3439#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
3440#[doc(hidden)]
3441impl FromGlib<ffi::GtkContentFit> for ContentFit {
3442 #[inline]
3443 unsafe fn from_glib(value: ffi::GtkContentFit) -> Self {
3444 skip_assert_initialized!();
3445
3446 match value {
3447 ffi::GTK_CONTENT_FIT_FILL => Self::Fill,
3448 ffi::GTK_CONTENT_FIT_CONTAIN => Self::Contain,
3449 ffi::GTK_CONTENT_FIT_COVER => Self::Cover,
3450 ffi::GTK_CONTENT_FIT_SCALE_DOWN => Self::ScaleDown,
3451 value => Self::__Unknown(value),
3452 }
3453 }
3454}
3455
3456#[cfg(feature = "v4_8")]
3457#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
3458impl StaticType for ContentFit {
3459 #[inline]
3460 #[doc(alias = "gtk_content_fit_get_type")]
3461 fn static_type() -> glib::Type {
3462 unsafe { from_glib(ffi::gtk_content_fit_get_type()) }
3463 }
3464}
3465
3466#[cfg(feature = "v4_8")]
3467#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
3468impl glib::HasParamSpec for ContentFit {
3469 type ParamSpec = glib::ParamSpecEnum;
3470 type SetValue = Self;
3471 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
3472
3473 fn param_spec_builder() -> Self::BuilderFn {
3474 Self::ParamSpec::builder_with_default
3475 }
3476}
3477
3478#[cfg(feature = "v4_8")]
3479#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
3480impl glib::value::ValueType for ContentFit {
3481 type Type = Self;
3482}
3483
3484#[cfg(feature = "v4_8")]
3485#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
3486unsafe impl<'a> glib::value::FromValue<'a> for ContentFit {
3487 type Checker = glib::value::GenericValueTypeChecker<Self>;
3488
3489 #[inline]
3490 unsafe fn from_value(value: &'a glib::Value) -> Self {
3491 skip_assert_initialized!();
3492 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
3493 }
3494}
3495
3496#[cfg(feature = "v4_8")]
3497#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
3498impl ToValue for ContentFit {
3499 #[inline]
3500 fn to_value(&self) -> glib::Value {
3501 let mut value = glib::Value::for_value_type::<Self>();
3502 unsafe {
3503 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
3504 }
3505 value
3506 }
3507
3508 #[inline]
3509 fn value_type(&self) -> glib::Type {
3510 Self::static_type()
3511 }
3512}
3513
3514#[cfg(feature = "v4_8")]
3515#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
3516impl From<ContentFit> for glib::Value {
3517 #[inline]
3518 fn from(v: ContentFit) -> Self {
3519 skip_assert_initialized!();
3520 ToValue::to_value(&v)
3521 }
3522}
3523
3524#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3525#[non_exhaustive]
3526#[doc(alias = "GtkCornerType")]
3527pub enum CornerType {
3528 #[doc(alias = "GTK_CORNER_TOP_LEFT")]
3529 TopLeft,
3530 #[doc(alias = "GTK_CORNER_BOTTOM_LEFT")]
3531 BottomLeft,
3532 #[doc(alias = "GTK_CORNER_TOP_RIGHT")]
3533 TopRight,
3534 #[doc(alias = "GTK_CORNER_BOTTOM_RIGHT")]
3535 BottomRight,
3536 #[doc(hidden)]
3537 __Unknown(i32),
3538}
3539
3540#[doc(hidden)]
3541impl IntoGlib for CornerType {
3542 type GlibType = ffi::GtkCornerType;
3543
3544 #[inline]
3545 fn into_glib(self) -> ffi::GtkCornerType {
3546 match self {
3547 Self::TopLeft => ffi::GTK_CORNER_TOP_LEFT,
3548 Self::BottomLeft => ffi::GTK_CORNER_BOTTOM_LEFT,
3549 Self::TopRight => ffi::GTK_CORNER_TOP_RIGHT,
3550 Self::BottomRight => ffi::GTK_CORNER_BOTTOM_RIGHT,
3551 Self::__Unknown(value) => value,
3552 }
3553 }
3554}
3555
3556#[doc(hidden)]
3557impl FromGlib<ffi::GtkCornerType> for CornerType {
3558 #[inline]
3559 unsafe fn from_glib(value: ffi::GtkCornerType) -> Self {
3560 skip_assert_initialized!();
3561
3562 match value {
3563 ffi::GTK_CORNER_TOP_LEFT => Self::TopLeft,
3564 ffi::GTK_CORNER_BOTTOM_LEFT => Self::BottomLeft,
3565 ffi::GTK_CORNER_TOP_RIGHT => Self::TopRight,
3566 ffi::GTK_CORNER_BOTTOM_RIGHT => Self::BottomRight,
3567 value => Self::__Unknown(value),
3568 }
3569 }
3570}
3571
3572impl StaticType for CornerType {
3573 #[inline]
3574 #[doc(alias = "gtk_corner_type_get_type")]
3575 fn static_type() -> glib::Type {
3576 unsafe { from_glib(ffi::gtk_corner_type_get_type()) }
3577 }
3578}
3579
3580impl glib::HasParamSpec for CornerType {
3581 type ParamSpec = glib::ParamSpecEnum;
3582 type SetValue = Self;
3583 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
3584
3585 fn param_spec_builder() -> Self::BuilderFn {
3586 Self::ParamSpec::builder_with_default
3587 }
3588}
3589
3590impl glib::value::ValueType for CornerType {
3591 type Type = Self;
3592}
3593
3594unsafe impl<'a> glib::value::FromValue<'a> for CornerType {
3595 type Checker = glib::value::GenericValueTypeChecker<Self>;
3596
3597 #[inline]
3598 unsafe fn from_value(value: &'a glib::Value) -> Self {
3599 skip_assert_initialized!();
3600 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
3601 }
3602}
3603
3604impl ToValue for CornerType {
3605 #[inline]
3606 fn to_value(&self) -> glib::Value {
3607 let mut value = glib::Value::for_value_type::<Self>();
3608 unsafe {
3609 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
3610 }
3611 value
3612 }
3613
3614 #[inline]
3615 fn value_type(&self) -> glib::Type {
3616 Self::static_type()
3617 }
3618}
3619
3620impl From<CornerType> for glib::Value {
3621 #[inline]
3622 fn from(v: CornerType) -> Self {
3623 skip_assert_initialized!();
3624 ToValue::to_value(&v)
3625 }
3626}
3627
3628#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3629#[non_exhaustive]
3630#[doc(alias = "GtkCssParserError")]
3631pub enum CssParserError {
3632 #[doc(alias = "GTK_CSS_PARSER_ERROR_FAILED")]
3633 Failed,
3634 #[doc(alias = "GTK_CSS_PARSER_ERROR_SYNTAX")]
3635 Syntax,
3636 #[doc(alias = "GTK_CSS_PARSER_ERROR_IMPORT")]
3637 Import,
3638 #[doc(alias = "GTK_CSS_PARSER_ERROR_NAME")]
3639 Name,
3640 #[doc(alias = "GTK_CSS_PARSER_ERROR_UNKNOWN_VALUE")]
3641 UnknownValue,
3642 #[doc(hidden)]
3643 __Unknown(i32),
3644}
3645
3646#[doc(hidden)]
3647impl IntoGlib for CssParserError {
3648 type GlibType = ffi::GtkCssParserError;
3649
3650 #[inline]
3651 fn into_glib(self) -> ffi::GtkCssParserError {
3652 match self {
3653 Self::Failed => ffi::GTK_CSS_PARSER_ERROR_FAILED,
3654 Self::Syntax => ffi::GTK_CSS_PARSER_ERROR_SYNTAX,
3655 Self::Import => ffi::GTK_CSS_PARSER_ERROR_IMPORT,
3656 Self::Name => ffi::GTK_CSS_PARSER_ERROR_NAME,
3657 Self::UnknownValue => ffi::GTK_CSS_PARSER_ERROR_UNKNOWN_VALUE,
3658 Self::__Unknown(value) => value,
3659 }
3660 }
3661}
3662
3663#[doc(hidden)]
3664impl FromGlib<ffi::GtkCssParserError> for CssParserError {
3665 #[inline]
3666 unsafe fn from_glib(value: ffi::GtkCssParserError) -> Self {
3667 skip_assert_initialized!();
3668
3669 match value {
3670 ffi::GTK_CSS_PARSER_ERROR_FAILED => Self::Failed,
3671 ffi::GTK_CSS_PARSER_ERROR_SYNTAX => Self::Syntax,
3672 ffi::GTK_CSS_PARSER_ERROR_IMPORT => Self::Import,
3673 ffi::GTK_CSS_PARSER_ERROR_NAME => Self::Name,
3674 ffi::GTK_CSS_PARSER_ERROR_UNKNOWN_VALUE => Self::UnknownValue,
3675 value => Self::__Unknown(value),
3676 }
3677 }
3678}
3679
3680impl glib::error::ErrorDomain for CssParserError {
3681 #[inline]
3682 fn domain() -> glib::Quark {
3683 skip_assert_initialized!();
3684
3685 unsafe { from_glib(ffi::gtk_css_parser_error_quark()) }
3686 }
3687
3688 #[inline]
3689 fn code(self) -> i32 {
3690 self.into_glib()
3691 }
3692
3693 #[inline]
3694 #[allow(clippy::match_single_binding)]
3695 fn from(code: i32) -> Option<Self> {
3696 skip_assert_initialized!();
3697 match unsafe { from_glib(code) } {
3698 Self::__Unknown(_) => Some(Self::Failed),
3699 value => Some(value),
3700 }
3701 }
3702}
3703
3704#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3705#[non_exhaustive]
3706#[doc(alias = "GtkCssParserWarning")]
3707pub enum CssParserWarning {
3708 #[doc(alias = "GTK_CSS_PARSER_WARNING_DEPRECATED")]
3709 Deprecated,
3710 #[doc(alias = "GTK_CSS_PARSER_WARNING_SYNTAX")]
3711 Syntax,
3712 #[doc(alias = "GTK_CSS_PARSER_WARNING_UNIMPLEMENTED")]
3713 Unimplemented,
3714 #[doc(hidden)]
3715 __Unknown(i32),
3716}
3717
3718#[doc(hidden)]
3719impl IntoGlib for CssParserWarning {
3720 type GlibType = ffi::GtkCssParserWarning;
3721
3722 #[inline]
3723 fn into_glib(self) -> ffi::GtkCssParserWarning {
3724 match self {
3725 Self::Deprecated => ffi::GTK_CSS_PARSER_WARNING_DEPRECATED,
3726 Self::Syntax => ffi::GTK_CSS_PARSER_WARNING_SYNTAX,
3727 Self::Unimplemented => ffi::GTK_CSS_PARSER_WARNING_UNIMPLEMENTED,
3728 Self::__Unknown(value) => value,
3729 }
3730 }
3731}
3732
3733#[doc(hidden)]
3734impl FromGlib<ffi::GtkCssParserWarning> for CssParserWarning {
3735 #[inline]
3736 unsafe fn from_glib(value: ffi::GtkCssParserWarning) -> Self {
3737 skip_assert_initialized!();
3738
3739 match value {
3740 ffi::GTK_CSS_PARSER_WARNING_DEPRECATED => Self::Deprecated,
3741 ffi::GTK_CSS_PARSER_WARNING_SYNTAX => Self::Syntax,
3742 ffi::GTK_CSS_PARSER_WARNING_UNIMPLEMENTED => Self::Unimplemented,
3743 value => Self::__Unknown(value),
3744 }
3745 }
3746}
3747
3748#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3749#[non_exhaustive]
3750#[doc(alias = "GtkDeleteType")]
3751pub enum DeleteType {
3752 #[doc(alias = "GTK_DELETE_CHARS")]
3753 Chars,
3754 #[doc(alias = "GTK_DELETE_WORD_ENDS")]
3755 WordEnds,
3756 #[doc(alias = "GTK_DELETE_WORDS")]
3757 Words,
3758 #[doc(alias = "GTK_DELETE_DISPLAY_LINES")]
3759 DisplayLines,
3760 #[doc(alias = "GTK_DELETE_DISPLAY_LINE_ENDS")]
3761 DisplayLineEnds,
3762 #[doc(alias = "GTK_DELETE_PARAGRAPH_ENDS")]
3763 ParagraphEnds,
3764 #[doc(alias = "GTK_DELETE_PARAGRAPHS")]
3765 Paragraphs,
3766 #[doc(alias = "GTK_DELETE_WHITESPACE")]
3767 Whitespace,
3768 #[doc(hidden)]
3769 __Unknown(i32),
3770}
3771
3772#[doc(hidden)]
3773impl IntoGlib for DeleteType {
3774 type GlibType = ffi::GtkDeleteType;
3775
3776 #[inline]
3777 fn into_glib(self) -> ffi::GtkDeleteType {
3778 match self {
3779 Self::Chars => ffi::GTK_DELETE_CHARS,
3780 Self::WordEnds => ffi::GTK_DELETE_WORD_ENDS,
3781 Self::Words => ffi::GTK_DELETE_WORDS,
3782 Self::DisplayLines => ffi::GTK_DELETE_DISPLAY_LINES,
3783 Self::DisplayLineEnds => ffi::GTK_DELETE_DISPLAY_LINE_ENDS,
3784 Self::ParagraphEnds => ffi::GTK_DELETE_PARAGRAPH_ENDS,
3785 Self::Paragraphs => ffi::GTK_DELETE_PARAGRAPHS,
3786 Self::Whitespace => ffi::GTK_DELETE_WHITESPACE,
3787 Self::__Unknown(value) => value,
3788 }
3789 }
3790}
3791
3792#[doc(hidden)]
3793impl FromGlib<ffi::GtkDeleteType> for DeleteType {
3794 #[inline]
3795 unsafe fn from_glib(value: ffi::GtkDeleteType) -> Self {
3796 skip_assert_initialized!();
3797
3798 match value {
3799 ffi::GTK_DELETE_CHARS => Self::Chars,
3800 ffi::GTK_DELETE_WORD_ENDS => Self::WordEnds,
3801 ffi::GTK_DELETE_WORDS => Self::Words,
3802 ffi::GTK_DELETE_DISPLAY_LINES => Self::DisplayLines,
3803 ffi::GTK_DELETE_DISPLAY_LINE_ENDS => Self::DisplayLineEnds,
3804 ffi::GTK_DELETE_PARAGRAPH_ENDS => Self::ParagraphEnds,
3805 ffi::GTK_DELETE_PARAGRAPHS => Self::Paragraphs,
3806 ffi::GTK_DELETE_WHITESPACE => Self::Whitespace,
3807 value => Self::__Unknown(value),
3808 }
3809 }
3810}
3811
3812impl StaticType for DeleteType {
3813 #[inline]
3814 #[doc(alias = "gtk_delete_type_get_type")]
3815 fn static_type() -> glib::Type {
3816 unsafe { from_glib(ffi::gtk_delete_type_get_type()) }
3817 }
3818}
3819
3820impl glib::HasParamSpec for DeleteType {
3821 type ParamSpec = glib::ParamSpecEnum;
3822 type SetValue = Self;
3823 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
3824
3825 fn param_spec_builder() -> Self::BuilderFn {
3826 Self::ParamSpec::builder_with_default
3827 }
3828}
3829
3830impl glib::value::ValueType for DeleteType {
3831 type Type = Self;
3832}
3833
3834unsafe impl<'a> glib::value::FromValue<'a> for DeleteType {
3835 type Checker = glib::value::GenericValueTypeChecker<Self>;
3836
3837 #[inline]
3838 unsafe fn from_value(value: &'a glib::Value) -> Self {
3839 skip_assert_initialized!();
3840 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
3841 }
3842}
3843
3844impl ToValue for DeleteType {
3845 #[inline]
3846 fn to_value(&self) -> glib::Value {
3847 let mut value = glib::Value::for_value_type::<Self>();
3848 unsafe {
3849 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
3850 }
3851 value
3852 }
3853
3854 #[inline]
3855 fn value_type(&self) -> glib::Type {
3856 Self::static_type()
3857 }
3858}
3859
3860impl From<DeleteType> for glib::Value {
3861 #[inline]
3862 fn from(v: DeleteType) -> Self {
3863 skip_assert_initialized!();
3864 ToValue::to_value(&v)
3865 }
3866}
3867
3868#[cfg(feature = "v4_10")]
3869#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
3870#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3871#[non_exhaustive]
3872#[doc(alias = "GtkDialogError")]
3873pub enum DialogError {
3874 #[doc(alias = "GTK_DIALOG_ERROR_FAILED")]
3875 Failed,
3876 #[doc(alias = "GTK_DIALOG_ERROR_CANCELLED")]
3877 Cancelled,
3878 #[doc(alias = "GTK_DIALOG_ERROR_DISMISSED")]
3879 Dismissed,
3880 #[doc(hidden)]
3881 __Unknown(i32),
3882}
3883
3884#[cfg(feature = "v4_10")]
3885#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
3886#[doc(hidden)]
3887impl IntoGlib for DialogError {
3888 type GlibType = ffi::GtkDialogError;
3889
3890 #[inline]
3891 fn into_glib(self) -> ffi::GtkDialogError {
3892 match self {
3893 Self::Failed => ffi::GTK_DIALOG_ERROR_FAILED,
3894 Self::Cancelled => ffi::GTK_DIALOG_ERROR_CANCELLED,
3895 Self::Dismissed => ffi::GTK_DIALOG_ERROR_DISMISSED,
3896 Self::__Unknown(value) => value,
3897 }
3898 }
3899}
3900
3901#[cfg(feature = "v4_10")]
3902#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
3903#[doc(hidden)]
3904impl FromGlib<ffi::GtkDialogError> for DialogError {
3905 #[inline]
3906 unsafe fn from_glib(value: ffi::GtkDialogError) -> Self {
3907 skip_assert_initialized!();
3908
3909 match value {
3910 ffi::GTK_DIALOG_ERROR_FAILED => Self::Failed,
3911 ffi::GTK_DIALOG_ERROR_CANCELLED => Self::Cancelled,
3912 ffi::GTK_DIALOG_ERROR_DISMISSED => Self::Dismissed,
3913 value => Self::__Unknown(value),
3914 }
3915 }
3916}
3917
3918#[cfg(feature = "v4_10")]
3919#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
3920impl glib::error::ErrorDomain for DialogError {
3921 #[inline]
3922 fn domain() -> glib::Quark {
3923 skip_assert_initialized!();
3924
3925 unsafe { from_glib(ffi::gtk_dialog_error_quark()) }
3926 }
3927
3928 #[inline]
3929 fn code(self) -> i32 {
3930 self.into_glib()
3931 }
3932
3933 #[inline]
3934 #[allow(clippy::match_single_binding)]
3935 fn from(code: i32) -> Option<Self> {
3936 skip_assert_initialized!();
3937 match unsafe { from_glib(code) } {
3938 Self::__Unknown(_) => Some(Self::Failed),
3939 value => Some(value),
3940 }
3941 }
3942}
3943
3944#[cfg(feature = "v4_10")]
3945#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
3946impl StaticType for DialogError {
3947 #[inline]
3948 #[doc(alias = "gtk_dialog_error_get_type")]
3949 fn static_type() -> glib::Type {
3950 unsafe { from_glib(ffi::gtk_dialog_error_get_type()) }
3951 }
3952}
3953
3954#[cfg(feature = "v4_10")]
3955#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
3956impl glib::HasParamSpec for DialogError {
3957 type ParamSpec = glib::ParamSpecEnum;
3958 type SetValue = Self;
3959 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
3960
3961 fn param_spec_builder() -> Self::BuilderFn {
3962 Self::ParamSpec::builder_with_default
3963 }
3964}
3965
3966#[cfg(feature = "v4_10")]
3967#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
3968impl glib::value::ValueType for DialogError {
3969 type Type = Self;
3970}
3971
3972#[cfg(feature = "v4_10")]
3973#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
3974unsafe impl<'a> glib::value::FromValue<'a> for DialogError {
3975 type Checker = glib::value::GenericValueTypeChecker<Self>;
3976
3977 #[inline]
3978 unsafe fn from_value(value: &'a glib::Value) -> Self {
3979 skip_assert_initialized!();
3980 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
3981 }
3982}
3983
3984#[cfg(feature = "v4_10")]
3985#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
3986impl ToValue for DialogError {
3987 #[inline]
3988 fn to_value(&self) -> glib::Value {
3989 let mut value = glib::Value::for_value_type::<Self>();
3990 unsafe {
3991 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
3992 }
3993 value
3994 }
3995
3996 #[inline]
3997 fn value_type(&self) -> glib::Type {
3998 Self::static_type()
3999 }
4000}
4001
4002#[cfg(feature = "v4_10")]
4003#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
4004impl From<DialogError> for glib::Value {
4005 #[inline]
4006 fn from(v: DialogError) -> Self {
4007 skip_assert_initialized!();
4008 ToValue::to_value(&v)
4009 }
4010}
4011
4012#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
4013#[non_exhaustive]
4014#[doc(alias = "GtkDirectionType")]
4015pub enum DirectionType {
4016 #[doc(alias = "GTK_DIR_TAB_FORWARD")]
4017 TabForward,
4018 #[doc(alias = "GTK_DIR_TAB_BACKWARD")]
4019 TabBackward,
4020 #[doc(alias = "GTK_DIR_UP")]
4021 Up,
4022 #[doc(alias = "GTK_DIR_DOWN")]
4023 Down,
4024 #[doc(alias = "GTK_DIR_LEFT")]
4025 Left,
4026 #[doc(alias = "GTK_DIR_RIGHT")]
4027 Right,
4028 #[doc(hidden)]
4029 __Unknown(i32),
4030}
4031
4032#[doc(hidden)]
4033impl IntoGlib for DirectionType {
4034 type GlibType = ffi::GtkDirectionType;
4035
4036 #[inline]
4037 fn into_glib(self) -> ffi::GtkDirectionType {
4038 match self {
4039 Self::TabForward => ffi::GTK_DIR_TAB_FORWARD,
4040 Self::TabBackward => ffi::GTK_DIR_TAB_BACKWARD,
4041 Self::Up => ffi::GTK_DIR_UP,
4042 Self::Down => ffi::GTK_DIR_DOWN,
4043 Self::Left => ffi::GTK_DIR_LEFT,
4044 Self::Right => ffi::GTK_DIR_RIGHT,
4045 Self::__Unknown(value) => value,
4046 }
4047 }
4048}
4049
4050#[doc(hidden)]
4051impl FromGlib<ffi::GtkDirectionType> for DirectionType {
4052 #[inline]
4053 unsafe fn from_glib(value: ffi::GtkDirectionType) -> Self {
4054 skip_assert_initialized!();
4055
4056 match value {
4057 ffi::GTK_DIR_TAB_FORWARD => Self::TabForward,
4058 ffi::GTK_DIR_TAB_BACKWARD => Self::TabBackward,
4059 ffi::GTK_DIR_UP => Self::Up,
4060 ffi::GTK_DIR_DOWN => Self::Down,
4061 ffi::GTK_DIR_LEFT => Self::Left,
4062 ffi::GTK_DIR_RIGHT => Self::Right,
4063 value => Self::__Unknown(value),
4064 }
4065 }
4066}
4067
4068impl StaticType for DirectionType {
4069 #[inline]
4070 #[doc(alias = "gtk_direction_type_get_type")]
4071 fn static_type() -> glib::Type {
4072 unsafe { from_glib(ffi::gtk_direction_type_get_type()) }
4073 }
4074}
4075
4076impl glib::HasParamSpec for DirectionType {
4077 type ParamSpec = glib::ParamSpecEnum;
4078 type SetValue = Self;
4079 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
4080
4081 fn param_spec_builder() -> Self::BuilderFn {
4082 Self::ParamSpec::builder_with_default
4083 }
4084}
4085
4086impl glib::value::ValueType for DirectionType {
4087 type Type = Self;
4088}
4089
4090unsafe impl<'a> glib::value::FromValue<'a> for DirectionType {
4091 type Checker = glib::value::GenericValueTypeChecker<Self>;
4092
4093 #[inline]
4094 unsafe fn from_value(value: &'a glib::Value) -> Self {
4095 skip_assert_initialized!();
4096 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
4097 }
4098}
4099
4100impl ToValue for DirectionType {
4101 #[inline]
4102 fn to_value(&self) -> glib::Value {
4103 let mut value = glib::Value::for_value_type::<Self>();
4104 unsafe {
4105 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
4106 }
4107 value
4108 }
4109
4110 #[inline]
4111 fn value_type(&self) -> glib::Type {
4112 Self::static_type()
4113 }
4114}
4115
4116impl From<DirectionType> for glib::Value {
4117 #[inline]
4118 fn from(v: DirectionType) -> Self {
4119 skip_assert_initialized!();
4120 ToValue::to_value(&v)
4121 }
4122}
4123
4124#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
4125#[non_exhaustive]
4126#[doc(alias = "GtkEditableProperties")]
4127pub enum EditableProperties {
4128 #[doc(alias = "GTK_EDITABLE_PROP_TEXT")]
4129 PropText,
4130 #[doc(alias = "GTK_EDITABLE_PROP_CURSOR_POSITION")]
4131 PropCursorPosition,
4132 #[doc(alias = "GTK_EDITABLE_PROP_SELECTION_BOUND")]
4133 PropSelectionBound,
4134 #[doc(alias = "GTK_EDITABLE_PROP_EDITABLE")]
4135 PropEditable,
4136 #[doc(alias = "GTK_EDITABLE_PROP_WIDTH_CHARS")]
4137 PropWidthChars,
4138 #[doc(alias = "GTK_EDITABLE_PROP_MAX_WIDTH_CHARS")]
4139 PropMaxWidthChars,
4140 #[doc(alias = "GTK_EDITABLE_PROP_XALIGN")]
4141 PropXalign,
4142 #[doc(alias = "GTK_EDITABLE_PROP_ENABLE_UNDO")]
4143 PropEnableUndo,
4144 #[doc(alias = "GTK_EDITABLE_NUM_PROPERTIES")]
4145 NumProperties,
4146 #[doc(hidden)]
4147 __Unknown(i32),
4148}
4149
4150#[doc(hidden)]
4151impl IntoGlib for EditableProperties {
4152 type GlibType = ffi::GtkEditableProperties;
4153
4154 #[inline]
4155 fn into_glib(self) -> ffi::GtkEditableProperties {
4156 match self {
4157 Self::PropText => ffi::GTK_EDITABLE_PROP_TEXT,
4158 Self::PropCursorPosition => ffi::GTK_EDITABLE_PROP_CURSOR_POSITION,
4159 Self::PropSelectionBound => ffi::GTK_EDITABLE_PROP_SELECTION_BOUND,
4160 Self::PropEditable => ffi::GTK_EDITABLE_PROP_EDITABLE,
4161 Self::PropWidthChars => ffi::GTK_EDITABLE_PROP_WIDTH_CHARS,
4162 Self::PropMaxWidthChars => ffi::GTK_EDITABLE_PROP_MAX_WIDTH_CHARS,
4163 Self::PropXalign => ffi::GTK_EDITABLE_PROP_XALIGN,
4164 Self::PropEnableUndo => ffi::GTK_EDITABLE_PROP_ENABLE_UNDO,
4165 Self::NumProperties => ffi::GTK_EDITABLE_NUM_PROPERTIES,
4166 Self::__Unknown(value) => value,
4167 }
4168 }
4169}
4170
4171#[doc(hidden)]
4172impl FromGlib<ffi::GtkEditableProperties> for EditableProperties {
4173 #[inline]
4174 unsafe fn from_glib(value: ffi::GtkEditableProperties) -> Self {
4175 skip_assert_initialized!();
4176
4177 match value {
4178 ffi::GTK_EDITABLE_PROP_TEXT => Self::PropText,
4179 ffi::GTK_EDITABLE_PROP_CURSOR_POSITION => Self::PropCursorPosition,
4180 ffi::GTK_EDITABLE_PROP_SELECTION_BOUND => Self::PropSelectionBound,
4181 ffi::GTK_EDITABLE_PROP_EDITABLE => Self::PropEditable,
4182 ffi::GTK_EDITABLE_PROP_WIDTH_CHARS => Self::PropWidthChars,
4183 ffi::GTK_EDITABLE_PROP_MAX_WIDTH_CHARS => Self::PropMaxWidthChars,
4184 ffi::GTK_EDITABLE_PROP_XALIGN => Self::PropXalign,
4185 ffi::GTK_EDITABLE_PROP_ENABLE_UNDO => Self::PropEnableUndo,
4186 ffi::GTK_EDITABLE_NUM_PROPERTIES => Self::NumProperties,
4187 value => Self::__Unknown(value),
4188 }
4189 }
4190}
4191
4192impl StaticType for EditableProperties {
4193 #[inline]
4194 #[doc(alias = "gtk_editable_properties_get_type")]
4195 fn static_type() -> glib::Type {
4196 unsafe { from_glib(ffi::gtk_editable_properties_get_type()) }
4197 }
4198}
4199
4200impl glib::HasParamSpec for EditableProperties {
4201 type ParamSpec = glib::ParamSpecEnum;
4202 type SetValue = Self;
4203 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
4204
4205 fn param_spec_builder() -> Self::BuilderFn {
4206 Self::ParamSpec::builder_with_default
4207 }
4208}
4209
4210impl glib::value::ValueType for EditableProperties {
4211 type Type = Self;
4212}
4213
4214unsafe impl<'a> glib::value::FromValue<'a> for EditableProperties {
4215 type Checker = glib::value::GenericValueTypeChecker<Self>;
4216
4217 #[inline]
4218 unsafe fn from_value(value: &'a glib::Value) -> Self {
4219 skip_assert_initialized!();
4220 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
4221 }
4222}
4223
4224impl ToValue for EditableProperties {
4225 #[inline]
4226 fn to_value(&self) -> glib::Value {
4227 let mut value = glib::Value::for_value_type::<Self>();
4228 unsafe {
4229 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
4230 }
4231 value
4232 }
4233
4234 #[inline]
4235 fn value_type(&self) -> glib::Type {
4236 Self::static_type()
4237 }
4238}
4239
4240impl From<EditableProperties> for glib::Value {
4241 #[inline]
4242 fn from(v: EditableProperties) -> Self {
4243 skip_assert_initialized!();
4244 ToValue::to_value(&v)
4245 }
4246}
4247
4248#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
4249#[non_exhaustive]
4250#[doc(alias = "GtkEntryIconPosition")]
4251pub enum EntryIconPosition {
4252 #[doc(alias = "GTK_ENTRY_ICON_PRIMARY")]
4253 Primary,
4254 #[doc(alias = "GTK_ENTRY_ICON_SECONDARY")]
4255 Secondary,
4256 #[doc(hidden)]
4257 __Unknown(i32),
4258}
4259
4260#[doc(hidden)]
4261impl IntoGlib for EntryIconPosition {
4262 type GlibType = ffi::GtkEntryIconPosition;
4263
4264 #[inline]
4265 fn into_glib(self) -> ffi::GtkEntryIconPosition {
4266 match self {
4267 Self::Primary => ffi::GTK_ENTRY_ICON_PRIMARY,
4268 Self::Secondary => ffi::GTK_ENTRY_ICON_SECONDARY,
4269 Self::__Unknown(value) => value,
4270 }
4271 }
4272}
4273
4274#[doc(hidden)]
4275impl FromGlib<ffi::GtkEntryIconPosition> for EntryIconPosition {
4276 #[inline]
4277 unsafe fn from_glib(value: ffi::GtkEntryIconPosition) -> Self {
4278 skip_assert_initialized!();
4279
4280 match value {
4281 ffi::GTK_ENTRY_ICON_PRIMARY => Self::Primary,
4282 ffi::GTK_ENTRY_ICON_SECONDARY => Self::Secondary,
4283 value => Self::__Unknown(value),
4284 }
4285 }
4286}
4287
4288impl StaticType for EntryIconPosition {
4289 #[inline]
4290 #[doc(alias = "gtk_entry_icon_position_get_type")]
4291 fn static_type() -> glib::Type {
4292 unsafe { from_glib(ffi::gtk_entry_icon_position_get_type()) }
4293 }
4294}
4295
4296impl glib::HasParamSpec for EntryIconPosition {
4297 type ParamSpec = glib::ParamSpecEnum;
4298 type SetValue = Self;
4299 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
4300
4301 fn param_spec_builder() -> Self::BuilderFn {
4302 Self::ParamSpec::builder_with_default
4303 }
4304}
4305
4306impl glib::value::ValueType for EntryIconPosition {
4307 type Type = Self;
4308}
4309
4310unsafe impl<'a> glib::value::FromValue<'a> for EntryIconPosition {
4311 type Checker = glib::value::GenericValueTypeChecker<Self>;
4312
4313 #[inline]
4314 unsafe fn from_value(value: &'a glib::Value) -> Self {
4315 skip_assert_initialized!();
4316 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
4317 }
4318}
4319
4320impl ToValue for EntryIconPosition {
4321 #[inline]
4322 fn to_value(&self) -> glib::Value {
4323 let mut value = glib::Value::for_value_type::<Self>();
4324 unsafe {
4325 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
4326 }
4327 value
4328 }
4329
4330 #[inline]
4331 fn value_type(&self) -> glib::Type {
4332 Self::static_type()
4333 }
4334}
4335
4336impl From<EntryIconPosition> for glib::Value {
4337 #[inline]
4338 fn from(v: EntryIconPosition) -> Self {
4339 skip_assert_initialized!();
4340 ToValue::to_value(&v)
4341 }
4342}
4343
4344#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
4345#[non_exhaustive]
4346#[doc(alias = "GtkEventSequenceState")]
4347pub enum EventSequenceState {
4348 #[doc(alias = "GTK_EVENT_SEQUENCE_NONE")]
4349 None,
4350 #[doc(alias = "GTK_EVENT_SEQUENCE_CLAIMED")]
4351 Claimed,
4352 #[doc(alias = "GTK_EVENT_SEQUENCE_DENIED")]
4353 Denied,
4354 #[doc(hidden)]
4355 __Unknown(i32),
4356}
4357
4358#[doc(hidden)]
4359impl IntoGlib for EventSequenceState {
4360 type GlibType = ffi::GtkEventSequenceState;
4361
4362 #[inline]
4363 fn into_glib(self) -> ffi::GtkEventSequenceState {
4364 match self {
4365 Self::None => ffi::GTK_EVENT_SEQUENCE_NONE,
4366 Self::Claimed => ffi::GTK_EVENT_SEQUENCE_CLAIMED,
4367 Self::Denied => ffi::GTK_EVENT_SEQUENCE_DENIED,
4368 Self::__Unknown(value) => value,
4369 }
4370 }
4371}
4372
4373#[doc(hidden)]
4374impl FromGlib<ffi::GtkEventSequenceState> for EventSequenceState {
4375 #[inline]
4376 unsafe fn from_glib(value: ffi::GtkEventSequenceState) -> Self {
4377 skip_assert_initialized!();
4378
4379 match value {
4380 ffi::GTK_EVENT_SEQUENCE_NONE => Self::None,
4381 ffi::GTK_EVENT_SEQUENCE_CLAIMED => Self::Claimed,
4382 ffi::GTK_EVENT_SEQUENCE_DENIED => Self::Denied,
4383 value => Self::__Unknown(value),
4384 }
4385 }
4386}
4387
4388impl StaticType for EventSequenceState {
4389 #[inline]
4390 #[doc(alias = "gtk_event_sequence_state_get_type")]
4391 fn static_type() -> glib::Type {
4392 unsafe { from_glib(ffi::gtk_event_sequence_state_get_type()) }
4393 }
4394}
4395
4396impl glib::HasParamSpec for EventSequenceState {
4397 type ParamSpec = glib::ParamSpecEnum;
4398 type SetValue = Self;
4399 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
4400
4401 fn param_spec_builder() -> Self::BuilderFn {
4402 Self::ParamSpec::builder_with_default
4403 }
4404}
4405
4406impl glib::value::ValueType for EventSequenceState {
4407 type Type = Self;
4408}
4409
4410unsafe impl<'a> glib::value::FromValue<'a> for EventSequenceState {
4411 type Checker = glib::value::GenericValueTypeChecker<Self>;
4412
4413 #[inline]
4414 unsafe fn from_value(value: &'a glib::Value) -> Self {
4415 skip_assert_initialized!();
4416 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
4417 }
4418}
4419
4420impl ToValue for EventSequenceState {
4421 #[inline]
4422 fn to_value(&self) -> glib::Value {
4423 let mut value = glib::Value::for_value_type::<Self>();
4424 unsafe {
4425 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
4426 }
4427 value
4428 }
4429
4430 #[inline]
4431 fn value_type(&self) -> glib::Type {
4432 Self::static_type()
4433 }
4434}
4435
4436impl From<EventSequenceState> for glib::Value {
4437 #[inline]
4438 fn from(v: EventSequenceState) -> Self {
4439 skip_assert_initialized!();
4440 ToValue::to_value(&v)
4441 }
4442}
4443
4444#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
4445#[non_exhaustive]
4446#[doc(alias = "GtkFileChooserAction")]
4447pub enum FileChooserAction {
4448 #[doc(alias = "GTK_FILE_CHOOSER_ACTION_OPEN")]
4449 Open,
4450 #[doc(alias = "GTK_FILE_CHOOSER_ACTION_SAVE")]
4451 Save,
4452 #[doc(alias = "GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER")]
4453 SelectFolder,
4454 #[doc(hidden)]
4455 __Unknown(i32),
4456}
4457
4458#[doc(hidden)]
4459impl IntoGlib for FileChooserAction {
4460 type GlibType = ffi::GtkFileChooserAction;
4461
4462 #[inline]
4463 fn into_glib(self) -> ffi::GtkFileChooserAction {
4464 match self {
4465 Self::Open => ffi::GTK_FILE_CHOOSER_ACTION_OPEN,
4466 Self::Save => ffi::GTK_FILE_CHOOSER_ACTION_SAVE,
4467 Self::SelectFolder => ffi::GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER,
4468 Self::__Unknown(value) => value,
4469 }
4470 }
4471}
4472
4473#[doc(hidden)]
4474impl FromGlib<ffi::GtkFileChooserAction> for FileChooserAction {
4475 #[inline]
4476 unsafe fn from_glib(value: ffi::GtkFileChooserAction) -> Self {
4477 skip_assert_initialized!();
4478
4479 match value {
4480 ffi::GTK_FILE_CHOOSER_ACTION_OPEN => Self::Open,
4481 ffi::GTK_FILE_CHOOSER_ACTION_SAVE => Self::Save,
4482 ffi::GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER => Self::SelectFolder,
4483 value => Self::__Unknown(value),
4484 }
4485 }
4486}
4487
4488impl StaticType for FileChooserAction {
4489 #[inline]
4490 #[doc(alias = "gtk_file_chooser_action_get_type")]
4491 fn static_type() -> glib::Type {
4492 unsafe { from_glib(ffi::gtk_file_chooser_action_get_type()) }
4493 }
4494}
4495
4496impl glib::HasParamSpec for FileChooserAction {
4497 type ParamSpec = glib::ParamSpecEnum;
4498 type SetValue = Self;
4499 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
4500
4501 fn param_spec_builder() -> Self::BuilderFn {
4502 Self::ParamSpec::builder_with_default
4503 }
4504}
4505
4506impl glib::value::ValueType for FileChooserAction {
4507 type Type = Self;
4508}
4509
4510unsafe impl<'a> glib::value::FromValue<'a> for FileChooserAction {
4511 type Checker = glib::value::GenericValueTypeChecker<Self>;
4512
4513 #[inline]
4514 unsafe fn from_value(value: &'a glib::Value) -> Self {
4515 skip_assert_initialized!();
4516 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
4517 }
4518}
4519
4520impl ToValue for FileChooserAction {
4521 #[inline]
4522 fn to_value(&self) -> glib::Value {
4523 let mut value = glib::Value::for_value_type::<Self>();
4524 unsafe {
4525 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
4526 }
4527 value
4528 }
4529
4530 #[inline]
4531 fn value_type(&self) -> glib::Type {
4532 Self::static_type()
4533 }
4534}
4535
4536impl From<FileChooserAction> for glib::Value {
4537 #[inline]
4538 fn from(v: FileChooserAction) -> Self {
4539 skip_assert_initialized!();
4540 ToValue::to_value(&v)
4541 }
4542}
4543
4544#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
4545#[non_exhaustive]
4546#[doc(alias = "GtkFileChooserError")]
4547pub enum FileChooserError {
4548 #[doc(alias = "GTK_FILE_CHOOSER_ERROR_NONEXISTENT")]
4549 Nonexistent,
4550 #[doc(alias = "GTK_FILE_CHOOSER_ERROR_BAD_FILENAME")]
4551 BadFilename,
4552 #[doc(alias = "GTK_FILE_CHOOSER_ERROR_ALREADY_EXISTS")]
4553 AlreadyExists,
4554 #[doc(alias = "GTK_FILE_CHOOSER_ERROR_INCOMPLETE_HOSTNAME")]
4555 IncompleteHostname,
4556 #[doc(hidden)]
4557 __Unknown(i32),
4558}
4559
4560#[doc(hidden)]
4561impl IntoGlib for FileChooserError {
4562 type GlibType = ffi::GtkFileChooserError;
4563
4564 #[inline]
4565 fn into_glib(self) -> ffi::GtkFileChooserError {
4566 match self {
4567 Self::Nonexistent => ffi::GTK_FILE_CHOOSER_ERROR_NONEXISTENT,
4568 Self::BadFilename => ffi::GTK_FILE_CHOOSER_ERROR_BAD_FILENAME,
4569 Self::AlreadyExists => ffi::GTK_FILE_CHOOSER_ERROR_ALREADY_EXISTS,
4570 Self::IncompleteHostname => ffi::GTK_FILE_CHOOSER_ERROR_INCOMPLETE_HOSTNAME,
4571 Self::__Unknown(value) => value,
4572 }
4573 }
4574}
4575
4576#[doc(hidden)]
4577impl FromGlib<ffi::GtkFileChooserError> for FileChooserError {
4578 #[inline]
4579 unsafe fn from_glib(value: ffi::GtkFileChooserError) -> Self {
4580 skip_assert_initialized!();
4581
4582 match value {
4583 ffi::GTK_FILE_CHOOSER_ERROR_NONEXISTENT => Self::Nonexistent,
4584 ffi::GTK_FILE_CHOOSER_ERROR_BAD_FILENAME => Self::BadFilename,
4585 ffi::GTK_FILE_CHOOSER_ERROR_ALREADY_EXISTS => Self::AlreadyExists,
4586 ffi::GTK_FILE_CHOOSER_ERROR_INCOMPLETE_HOSTNAME => Self::IncompleteHostname,
4587 value => Self::__Unknown(value),
4588 }
4589 }
4590}
4591
4592impl glib::error::ErrorDomain for FileChooserError {
4593 #[inline]
4594 fn domain() -> glib::Quark {
4595 skip_assert_initialized!();
4596
4597 unsafe { from_glib(ffi::gtk_file_chooser_error_quark()) }
4598 }
4599
4600 #[inline]
4601 fn code(self) -> i32 {
4602 self.into_glib()
4603 }
4604
4605 #[inline]
4606 #[allow(clippy::match_single_binding)]
4607 fn from(code: i32) -> Option<Self> {
4608 skip_assert_initialized!();
4609 match unsafe { from_glib(code) } {
4610 value => Some(value),
4611 }
4612 }
4613}
4614
4615impl StaticType for FileChooserError {
4616 #[inline]
4617 #[doc(alias = "gtk_file_chooser_error_get_type")]
4618 fn static_type() -> glib::Type {
4619 unsafe { from_glib(ffi::gtk_file_chooser_error_get_type()) }
4620 }
4621}
4622
4623impl glib::HasParamSpec for FileChooserError {
4624 type ParamSpec = glib::ParamSpecEnum;
4625 type SetValue = Self;
4626 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
4627
4628 fn param_spec_builder() -> Self::BuilderFn {
4629 Self::ParamSpec::builder_with_default
4630 }
4631}
4632
4633impl glib::value::ValueType for FileChooserError {
4634 type Type = Self;
4635}
4636
4637unsafe impl<'a> glib::value::FromValue<'a> for FileChooserError {
4638 type Checker = glib::value::GenericValueTypeChecker<Self>;
4639
4640 #[inline]
4641 unsafe fn from_value(value: &'a glib::Value) -> Self {
4642 skip_assert_initialized!();
4643 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
4644 }
4645}
4646
4647impl ToValue for FileChooserError {
4648 #[inline]
4649 fn to_value(&self) -> glib::Value {
4650 let mut value = glib::Value::for_value_type::<Self>();
4651 unsafe {
4652 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
4653 }
4654 value
4655 }
4656
4657 #[inline]
4658 fn value_type(&self) -> glib::Type {
4659 Self::static_type()
4660 }
4661}
4662
4663impl From<FileChooserError> for glib::Value {
4664 #[inline]
4665 fn from(v: FileChooserError) -> Self {
4666 skip_assert_initialized!();
4667 ToValue::to_value(&v)
4668 }
4669}
4670
4671#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
4672#[non_exhaustive]
4673#[doc(alias = "GtkFilterChange")]
4674pub enum FilterChange {
4675 #[doc(alias = "GTK_FILTER_CHANGE_DIFFERENT")]
4676 Different,
4677 #[doc(alias = "GTK_FILTER_CHANGE_LESS_STRICT")]
4678 LessStrict,
4679 #[doc(alias = "GTK_FILTER_CHANGE_MORE_STRICT")]
4680 MoreStrict,
4681 #[doc(hidden)]
4682 __Unknown(i32),
4683}
4684
4685#[doc(hidden)]
4686impl IntoGlib for FilterChange {
4687 type GlibType = ffi::GtkFilterChange;
4688
4689 #[inline]
4690 fn into_glib(self) -> ffi::GtkFilterChange {
4691 match self {
4692 Self::Different => ffi::GTK_FILTER_CHANGE_DIFFERENT,
4693 Self::LessStrict => ffi::GTK_FILTER_CHANGE_LESS_STRICT,
4694 Self::MoreStrict => ffi::GTK_FILTER_CHANGE_MORE_STRICT,
4695 Self::__Unknown(value) => value,
4696 }
4697 }
4698}
4699
4700#[doc(hidden)]
4701impl FromGlib<ffi::GtkFilterChange> for FilterChange {
4702 #[inline]
4703 unsafe fn from_glib(value: ffi::GtkFilterChange) -> Self {
4704 skip_assert_initialized!();
4705
4706 match value {
4707 ffi::GTK_FILTER_CHANGE_DIFFERENT => Self::Different,
4708 ffi::GTK_FILTER_CHANGE_LESS_STRICT => Self::LessStrict,
4709 ffi::GTK_FILTER_CHANGE_MORE_STRICT => Self::MoreStrict,
4710 value => Self::__Unknown(value),
4711 }
4712 }
4713}
4714
4715impl StaticType for FilterChange {
4716 #[inline]
4717 #[doc(alias = "gtk_filter_change_get_type")]
4718 fn static_type() -> glib::Type {
4719 unsafe { from_glib(ffi::gtk_filter_change_get_type()) }
4720 }
4721}
4722
4723impl glib::HasParamSpec for FilterChange {
4724 type ParamSpec = glib::ParamSpecEnum;
4725 type SetValue = Self;
4726 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
4727
4728 fn param_spec_builder() -> Self::BuilderFn {
4729 Self::ParamSpec::builder_with_default
4730 }
4731}
4732
4733impl glib::value::ValueType for FilterChange {
4734 type Type = Self;
4735}
4736
4737unsafe impl<'a> glib::value::FromValue<'a> for FilterChange {
4738 type Checker = glib::value::GenericValueTypeChecker<Self>;
4739
4740 #[inline]
4741 unsafe fn from_value(value: &'a glib::Value) -> Self {
4742 skip_assert_initialized!();
4743 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
4744 }
4745}
4746
4747impl ToValue for FilterChange {
4748 #[inline]
4749 fn to_value(&self) -> glib::Value {
4750 let mut value = glib::Value::for_value_type::<Self>();
4751 unsafe {
4752 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
4753 }
4754 value
4755 }
4756
4757 #[inline]
4758 fn value_type(&self) -> glib::Type {
4759 Self::static_type()
4760 }
4761}
4762
4763impl From<FilterChange> for glib::Value {
4764 #[inline]
4765 fn from(v: FilterChange) -> Self {
4766 skip_assert_initialized!();
4767 ToValue::to_value(&v)
4768 }
4769}
4770
4771#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
4772#[non_exhaustive]
4773#[doc(alias = "GtkFilterMatch")]
4774pub enum FilterMatch {
4775 #[doc(alias = "GTK_FILTER_MATCH_SOME")]
4776 Some,
4777 #[doc(alias = "GTK_FILTER_MATCH_NONE")]
4778 None,
4779 #[doc(alias = "GTK_FILTER_MATCH_ALL")]
4780 All,
4781 #[doc(hidden)]
4782 __Unknown(i32),
4783}
4784
4785#[doc(hidden)]
4786impl IntoGlib for FilterMatch {
4787 type GlibType = ffi::GtkFilterMatch;
4788
4789 #[inline]
4790 fn into_glib(self) -> ffi::GtkFilterMatch {
4791 match self {
4792 Self::Some => ffi::GTK_FILTER_MATCH_SOME,
4793 Self::None => ffi::GTK_FILTER_MATCH_NONE,
4794 Self::All => ffi::GTK_FILTER_MATCH_ALL,
4795 Self::__Unknown(value) => value,
4796 }
4797 }
4798}
4799
4800#[doc(hidden)]
4801impl FromGlib<ffi::GtkFilterMatch> for FilterMatch {
4802 #[inline]
4803 unsafe fn from_glib(value: ffi::GtkFilterMatch) -> Self {
4804 skip_assert_initialized!();
4805
4806 match value {
4807 ffi::GTK_FILTER_MATCH_SOME => Self::Some,
4808 ffi::GTK_FILTER_MATCH_NONE => Self::None,
4809 ffi::GTK_FILTER_MATCH_ALL => Self::All,
4810 value => Self::__Unknown(value),
4811 }
4812 }
4813}
4814
4815impl StaticType for FilterMatch {
4816 #[inline]
4817 #[doc(alias = "gtk_filter_match_get_type")]
4818 fn static_type() -> glib::Type {
4819 unsafe { from_glib(ffi::gtk_filter_match_get_type()) }
4820 }
4821}
4822
4823impl glib::HasParamSpec for FilterMatch {
4824 type ParamSpec = glib::ParamSpecEnum;
4825 type SetValue = Self;
4826 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
4827
4828 fn param_spec_builder() -> Self::BuilderFn {
4829 Self::ParamSpec::builder_with_default
4830 }
4831}
4832
4833impl glib::value::ValueType for FilterMatch {
4834 type Type = Self;
4835}
4836
4837unsafe impl<'a> glib::value::FromValue<'a> for FilterMatch {
4838 type Checker = glib::value::GenericValueTypeChecker<Self>;
4839
4840 #[inline]
4841 unsafe fn from_value(value: &'a glib::Value) -> Self {
4842 skip_assert_initialized!();
4843 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
4844 }
4845}
4846
4847impl ToValue for FilterMatch {
4848 #[inline]
4849 fn to_value(&self) -> glib::Value {
4850 let mut value = glib::Value::for_value_type::<Self>();
4851 unsafe {
4852 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
4853 }
4854 value
4855 }
4856
4857 #[inline]
4858 fn value_type(&self) -> glib::Type {
4859 Self::static_type()
4860 }
4861}
4862
4863impl From<FilterMatch> for glib::Value {
4864 #[inline]
4865 fn from(v: FilterMatch) -> Self {
4866 skip_assert_initialized!();
4867 ToValue::to_value(&v)
4868 }
4869}
4870
4871#[cfg(feature = "v4_10")]
4872#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
4873#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
4874#[non_exhaustive]
4875#[doc(alias = "GtkFontLevel")]
4876pub enum FontLevel {
4877 #[doc(alias = "GTK_FONT_LEVEL_FAMILY")]
4878 Family,
4879 #[doc(alias = "GTK_FONT_LEVEL_FACE")]
4880 Face,
4881 #[doc(alias = "GTK_FONT_LEVEL_FONT")]
4882 Font,
4883 #[doc(alias = "GTK_FONT_LEVEL_FEATURES")]
4884 Features,
4885 #[doc(hidden)]
4886 __Unknown(i32),
4887}
4888
4889#[cfg(feature = "v4_10")]
4890#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
4891#[doc(hidden)]
4892impl IntoGlib for FontLevel {
4893 type GlibType = ffi::GtkFontLevel;
4894
4895 #[inline]
4896 fn into_glib(self) -> ffi::GtkFontLevel {
4897 match self {
4898 Self::Family => ffi::GTK_FONT_LEVEL_FAMILY,
4899 Self::Face => ffi::GTK_FONT_LEVEL_FACE,
4900 Self::Font => ffi::GTK_FONT_LEVEL_FONT,
4901 Self::Features => ffi::GTK_FONT_LEVEL_FEATURES,
4902 Self::__Unknown(value) => value,
4903 }
4904 }
4905}
4906
4907#[cfg(feature = "v4_10")]
4908#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
4909#[doc(hidden)]
4910impl FromGlib<ffi::GtkFontLevel> for FontLevel {
4911 #[inline]
4912 unsafe fn from_glib(value: ffi::GtkFontLevel) -> Self {
4913 skip_assert_initialized!();
4914
4915 match value {
4916 ffi::GTK_FONT_LEVEL_FAMILY => Self::Family,
4917 ffi::GTK_FONT_LEVEL_FACE => Self::Face,
4918 ffi::GTK_FONT_LEVEL_FONT => Self::Font,
4919 ffi::GTK_FONT_LEVEL_FEATURES => Self::Features,
4920 value => Self::__Unknown(value),
4921 }
4922 }
4923}
4924
4925#[cfg(feature = "v4_10")]
4926#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
4927impl StaticType for FontLevel {
4928 #[inline]
4929 #[doc(alias = "gtk_font_level_get_type")]
4930 fn static_type() -> glib::Type {
4931 unsafe { from_glib(ffi::gtk_font_level_get_type()) }
4932 }
4933}
4934
4935#[cfg(feature = "v4_10")]
4936#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
4937impl glib::HasParamSpec for FontLevel {
4938 type ParamSpec = glib::ParamSpecEnum;
4939 type SetValue = Self;
4940 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
4941
4942 fn param_spec_builder() -> Self::BuilderFn {
4943 Self::ParamSpec::builder_with_default
4944 }
4945}
4946
4947#[cfg(feature = "v4_10")]
4948#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
4949impl glib::value::ValueType for FontLevel {
4950 type Type = Self;
4951}
4952
4953#[cfg(feature = "v4_10")]
4954#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
4955unsafe impl<'a> glib::value::FromValue<'a> for FontLevel {
4956 type Checker = glib::value::GenericValueTypeChecker<Self>;
4957
4958 #[inline]
4959 unsafe fn from_value(value: &'a glib::Value) -> Self {
4960 skip_assert_initialized!();
4961 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
4962 }
4963}
4964
4965#[cfg(feature = "v4_10")]
4966#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
4967impl ToValue for FontLevel {
4968 #[inline]
4969 fn to_value(&self) -> glib::Value {
4970 let mut value = glib::Value::for_value_type::<Self>();
4971 unsafe {
4972 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
4973 }
4974 value
4975 }
4976
4977 #[inline]
4978 fn value_type(&self) -> glib::Type {
4979 Self::static_type()
4980 }
4981}
4982
4983#[cfg(feature = "v4_10")]
4984#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
4985impl From<FontLevel> for glib::Value {
4986 #[inline]
4987 fn from(v: FontLevel) -> Self {
4988 skip_assert_initialized!();
4989 ToValue::to_value(&v)
4990 }
4991}
4992
4993#[cfg(feature = "v4_16")]
4994#[cfg_attr(docsrs, doc(cfg(feature = "v4_16")))]
4995#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
4996#[non_exhaustive]
4997#[doc(alias = "GtkFontRendering")]
4998pub enum FontRendering {
4999 #[doc(alias = "GTK_FONT_RENDERING_AUTOMATIC")]
5000 Automatic,
5001 #[doc(alias = "GTK_FONT_RENDERING_MANUAL")]
5002 Manual,
5003 #[doc(hidden)]
5004 __Unknown(i32),
5005}
5006
5007#[cfg(feature = "v4_16")]
5008#[cfg_attr(docsrs, doc(cfg(feature = "v4_16")))]
5009#[doc(hidden)]
5010impl IntoGlib for FontRendering {
5011 type GlibType = ffi::GtkFontRendering;
5012
5013 #[inline]
5014 fn into_glib(self) -> ffi::GtkFontRendering {
5015 match self {
5016 Self::Automatic => ffi::GTK_FONT_RENDERING_AUTOMATIC,
5017 Self::Manual => ffi::GTK_FONT_RENDERING_MANUAL,
5018 Self::__Unknown(value) => value,
5019 }
5020 }
5021}
5022
5023#[cfg(feature = "v4_16")]
5024#[cfg_attr(docsrs, doc(cfg(feature = "v4_16")))]
5025#[doc(hidden)]
5026impl FromGlib<ffi::GtkFontRendering> for FontRendering {
5027 #[inline]
5028 unsafe fn from_glib(value: ffi::GtkFontRendering) -> Self {
5029 skip_assert_initialized!();
5030
5031 match value {
5032 ffi::GTK_FONT_RENDERING_AUTOMATIC => Self::Automatic,
5033 ffi::GTK_FONT_RENDERING_MANUAL => Self::Manual,
5034 value => Self::__Unknown(value),
5035 }
5036 }
5037}
5038
5039#[cfg(feature = "v4_16")]
5040#[cfg_attr(docsrs, doc(cfg(feature = "v4_16")))]
5041impl StaticType for FontRendering {
5042 #[inline]
5043 #[doc(alias = "gtk_font_rendering_get_type")]
5044 fn static_type() -> glib::Type {
5045 unsafe { from_glib(ffi::gtk_font_rendering_get_type()) }
5046 }
5047}
5048
5049#[cfg(feature = "v4_16")]
5050#[cfg_attr(docsrs, doc(cfg(feature = "v4_16")))]
5051impl glib::HasParamSpec for FontRendering {
5052 type ParamSpec = glib::ParamSpecEnum;
5053 type SetValue = Self;
5054 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
5055
5056 fn param_spec_builder() -> Self::BuilderFn {
5057 Self::ParamSpec::builder_with_default
5058 }
5059}
5060
5061#[cfg(feature = "v4_16")]
5062#[cfg_attr(docsrs, doc(cfg(feature = "v4_16")))]
5063impl glib::value::ValueType for FontRendering {
5064 type Type = Self;
5065}
5066
5067#[cfg(feature = "v4_16")]
5068#[cfg_attr(docsrs, doc(cfg(feature = "v4_16")))]
5069unsafe impl<'a> glib::value::FromValue<'a> for FontRendering {
5070 type Checker = glib::value::GenericValueTypeChecker<Self>;
5071
5072 #[inline]
5073 unsafe fn from_value(value: &'a glib::Value) -> Self {
5074 skip_assert_initialized!();
5075 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
5076 }
5077}
5078
5079#[cfg(feature = "v4_16")]
5080#[cfg_attr(docsrs, doc(cfg(feature = "v4_16")))]
5081impl ToValue for FontRendering {
5082 #[inline]
5083 fn to_value(&self) -> glib::Value {
5084 let mut value = glib::Value::for_value_type::<Self>();
5085 unsafe {
5086 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
5087 }
5088 value
5089 }
5090
5091 #[inline]
5092 fn value_type(&self) -> glib::Type {
5093 Self::static_type()
5094 }
5095}
5096
5097#[cfg(feature = "v4_16")]
5098#[cfg_attr(docsrs, doc(cfg(feature = "v4_16")))]
5099impl From<FontRendering> for glib::Value {
5100 #[inline]
5101 fn from(v: FontRendering) -> Self {
5102 skip_assert_initialized!();
5103 ToValue::to_value(&v)
5104 }
5105}
5106
5107#[cfg(feature = "v4_14")]
5108#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
5109#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
5110#[non_exhaustive]
5111#[doc(alias = "GtkGraphicsOffloadEnabled")]
5112pub enum GraphicsOffloadEnabled {
5113 #[doc(alias = "GTK_GRAPHICS_OFFLOAD_ENABLED")]
5114 Enabled,
5115 #[doc(alias = "GTK_GRAPHICS_OFFLOAD_DISABLED")]
5116 Disabled,
5117 #[doc(hidden)]
5118 __Unknown(i32),
5119}
5120
5121#[cfg(feature = "v4_14")]
5122#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
5123#[doc(hidden)]
5124impl IntoGlib for GraphicsOffloadEnabled {
5125 type GlibType = ffi::GtkGraphicsOffloadEnabled;
5126
5127 #[inline]
5128 fn into_glib(self) -> ffi::GtkGraphicsOffloadEnabled {
5129 match self {
5130 Self::Enabled => ffi::GTK_GRAPHICS_OFFLOAD_ENABLED,
5131 Self::Disabled => ffi::GTK_GRAPHICS_OFFLOAD_DISABLED,
5132 Self::__Unknown(value) => value,
5133 }
5134 }
5135}
5136
5137#[cfg(feature = "v4_14")]
5138#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
5139#[doc(hidden)]
5140impl FromGlib<ffi::GtkGraphicsOffloadEnabled> for GraphicsOffloadEnabled {
5141 #[inline]
5142 unsafe fn from_glib(value: ffi::GtkGraphicsOffloadEnabled) -> Self {
5143 skip_assert_initialized!();
5144
5145 match value {
5146 ffi::GTK_GRAPHICS_OFFLOAD_ENABLED => Self::Enabled,
5147 ffi::GTK_GRAPHICS_OFFLOAD_DISABLED => Self::Disabled,
5148 value => Self::__Unknown(value),
5149 }
5150 }
5151}
5152
5153#[cfg(feature = "v4_14")]
5154#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
5155impl StaticType for GraphicsOffloadEnabled {
5156 #[inline]
5157 #[doc(alias = "gtk_graphics_offload_enabled_get_type")]
5158 fn static_type() -> glib::Type {
5159 unsafe { from_glib(ffi::gtk_graphics_offload_enabled_get_type()) }
5160 }
5161}
5162
5163#[cfg(feature = "v4_14")]
5164#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
5165impl glib::HasParamSpec for GraphicsOffloadEnabled {
5166 type ParamSpec = glib::ParamSpecEnum;
5167 type SetValue = Self;
5168 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
5169
5170 fn param_spec_builder() -> Self::BuilderFn {
5171 Self::ParamSpec::builder_with_default
5172 }
5173}
5174
5175#[cfg(feature = "v4_14")]
5176#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
5177impl glib::value::ValueType for GraphicsOffloadEnabled {
5178 type Type = Self;
5179}
5180
5181#[cfg(feature = "v4_14")]
5182#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
5183unsafe impl<'a> glib::value::FromValue<'a> for GraphicsOffloadEnabled {
5184 type Checker = glib::value::GenericValueTypeChecker<Self>;
5185
5186 #[inline]
5187 unsafe fn from_value(value: &'a glib::Value) -> Self {
5188 skip_assert_initialized!();
5189 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
5190 }
5191}
5192
5193#[cfg(feature = "v4_14")]
5194#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
5195impl ToValue for GraphicsOffloadEnabled {
5196 #[inline]
5197 fn to_value(&self) -> glib::Value {
5198 let mut value = glib::Value::for_value_type::<Self>();
5199 unsafe {
5200 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
5201 }
5202 value
5203 }
5204
5205 #[inline]
5206 fn value_type(&self) -> glib::Type {
5207 Self::static_type()
5208 }
5209}
5210
5211#[cfg(feature = "v4_14")]
5212#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
5213impl From<GraphicsOffloadEnabled> for glib::Value {
5214 #[inline]
5215 fn from(v: GraphicsOffloadEnabled) -> Self {
5216 skip_assert_initialized!();
5217 ToValue::to_value(&v)
5218 }
5219}
5220
5221#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
5222#[non_exhaustive]
5223#[doc(alias = "GtkIconSize")]
5224pub enum IconSize {
5225 #[doc(alias = "GTK_ICON_SIZE_INHERIT")]
5226 Inherit,
5227 #[doc(alias = "GTK_ICON_SIZE_NORMAL")]
5228 Normal,
5229 #[doc(alias = "GTK_ICON_SIZE_LARGE")]
5230 Large,
5231 #[doc(hidden)]
5232 __Unknown(i32),
5233}
5234
5235#[doc(hidden)]
5236impl IntoGlib for IconSize {
5237 type GlibType = ffi::GtkIconSize;
5238
5239 #[inline]
5240 fn into_glib(self) -> ffi::GtkIconSize {
5241 match self {
5242 Self::Inherit => ffi::GTK_ICON_SIZE_INHERIT,
5243 Self::Normal => ffi::GTK_ICON_SIZE_NORMAL,
5244 Self::Large => ffi::GTK_ICON_SIZE_LARGE,
5245 Self::__Unknown(value) => value,
5246 }
5247 }
5248}
5249
5250#[doc(hidden)]
5251impl FromGlib<ffi::GtkIconSize> for IconSize {
5252 #[inline]
5253 unsafe fn from_glib(value: ffi::GtkIconSize) -> Self {
5254 skip_assert_initialized!();
5255
5256 match value {
5257 ffi::GTK_ICON_SIZE_INHERIT => Self::Inherit,
5258 ffi::GTK_ICON_SIZE_NORMAL => Self::Normal,
5259 ffi::GTK_ICON_SIZE_LARGE => Self::Large,
5260 value => Self::__Unknown(value),
5261 }
5262 }
5263}
5264
5265impl StaticType for IconSize {
5266 #[inline]
5267 #[doc(alias = "gtk_icon_size_get_type")]
5268 fn static_type() -> glib::Type {
5269 unsafe { from_glib(ffi::gtk_icon_size_get_type()) }
5270 }
5271}
5272
5273impl glib::HasParamSpec for IconSize {
5274 type ParamSpec = glib::ParamSpecEnum;
5275 type SetValue = Self;
5276 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
5277
5278 fn param_spec_builder() -> Self::BuilderFn {
5279 Self::ParamSpec::builder_with_default
5280 }
5281}
5282
5283impl glib::value::ValueType for IconSize {
5284 type Type = Self;
5285}
5286
5287unsafe impl<'a> glib::value::FromValue<'a> for IconSize {
5288 type Checker = glib::value::GenericValueTypeChecker<Self>;
5289
5290 #[inline]
5291 unsafe fn from_value(value: &'a glib::Value) -> Self {
5292 skip_assert_initialized!();
5293 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
5294 }
5295}
5296
5297impl ToValue for IconSize {
5298 #[inline]
5299 fn to_value(&self) -> glib::Value {
5300 let mut value = glib::Value::for_value_type::<Self>();
5301 unsafe {
5302 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
5303 }
5304 value
5305 }
5306
5307 #[inline]
5308 fn value_type(&self) -> glib::Type {
5309 Self::static_type()
5310 }
5311}
5312
5313impl From<IconSize> for glib::Value {
5314 #[inline]
5315 fn from(v: IconSize) -> Self {
5316 skip_assert_initialized!();
5317 ToValue::to_value(&v)
5318 }
5319}
5320
5321#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
5322#[non_exhaustive]
5323#[doc(alias = "GtkIconThemeError")]
5324pub enum IconThemeError {
5325 #[doc(alias = "GTK_ICON_THEME_NOT_FOUND")]
5326 NotFound,
5327 #[doc(alias = "GTK_ICON_THEME_FAILED")]
5328 Failed,
5329 #[doc(hidden)]
5330 __Unknown(i32),
5331}
5332
5333#[doc(hidden)]
5334impl IntoGlib for IconThemeError {
5335 type GlibType = ffi::GtkIconThemeError;
5336
5337 #[inline]
5338 fn into_glib(self) -> ffi::GtkIconThemeError {
5339 match self {
5340 Self::NotFound => ffi::GTK_ICON_THEME_NOT_FOUND,
5341 Self::Failed => ffi::GTK_ICON_THEME_FAILED,
5342 Self::__Unknown(value) => value,
5343 }
5344 }
5345}
5346
5347#[doc(hidden)]
5348impl FromGlib<ffi::GtkIconThemeError> for IconThemeError {
5349 #[inline]
5350 unsafe fn from_glib(value: ffi::GtkIconThemeError) -> Self {
5351 skip_assert_initialized!();
5352
5353 match value {
5354 ffi::GTK_ICON_THEME_NOT_FOUND => Self::NotFound,
5355 ffi::GTK_ICON_THEME_FAILED => Self::Failed,
5356 value => Self::__Unknown(value),
5357 }
5358 }
5359}
5360
5361impl glib::error::ErrorDomain for IconThemeError {
5362 #[inline]
5363 fn domain() -> glib::Quark {
5364 skip_assert_initialized!();
5365
5366 unsafe { from_glib(ffi::gtk_icon_theme_error_quark()) }
5367 }
5368
5369 #[inline]
5370 fn code(self) -> i32 {
5371 self.into_glib()
5372 }
5373
5374 #[inline]
5375 #[allow(clippy::match_single_binding)]
5376 fn from(code: i32) -> Option<Self> {
5377 skip_assert_initialized!();
5378 match unsafe { from_glib(code) } {
5379 Self::__Unknown(_) => Some(Self::Failed),
5380 value => Some(value),
5381 }
5382 }
5383}
5384
5385impl StaticType for IconThemeError {
5386 #[inline]
5387 #[doc(alias = "gtk_icon_theme_error_get_type")]
5388 fn static_type() -> glib::Type {
5389 unsafe { from_glib(ffi::gtk_icon_theme_error_get_type()) }
5390 }
5391}
5392
5393impl glib::HasParamSpec for IconThemeError {
5394 type ParamSpec = glib::ParamSpecEnum;
5395 type SetValue = Self;
5396 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
5397
5398 fn param_spec_builder() -> Self::BuilderFn {
5399 Self::ParamSpec::builder_with_default
5400 }
5401}
5402
5403impl glib::value::ValueType for IconThemeError {
5404 type Type = Self;
5405}
5406
5407unsafe impl<'a> glib::value::FromValue<'a> for IconThemeError {
5408 type Checker = glib::value::GenericValueTypeChecker<Self>;
5409
5410 #[inline]
5411 unsafe fn from_value(value: &'a glib::Value) -> Self {
5412 skip_assert_initialized!();
5413 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
5414 }
5415}
5416
5417impl ToValue for IconThemeError {
5418 #[inline]
5419 fn to_value(&self) -> glib::Value {
5420 let mut value = glib::Value::for_value_type::<Self>();
5421 unsafe {
5422 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
5423 }
5424 value
5425 }
5426
5427 #[inline]
5428 fn value_type(&self) -> glib::Type {
5429 Self::static_type()
5430 }
5431}
5432
5433impl From<IconThemeError> for glib::Value {
5434 #[inline]
5435 fn from(v: IconThemeError) -> Self {
5436 skip_assert_initialized!();
5437 ToValue::to_value(&v)
5438 }
5439}
5440
5441#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
5442#[non_exhaustive]
5443#[doc(alias = "GtkIconViewDropPosition")]
5444pub enum IconViewDropPosition {
5445 #[doc(alias = "GTK_ICON_VIEW_NO_DROP")]
5446 NoDrop,
5447 #[doc(alias = "GTK_ICON_VIEW_DROP_INTO")]
5448 DropInto,
5449 #[doc(alias = "GTK_ICON_VIEW_DROP_LEFT")]
5450 DropLeft,
5451 #[doc(alias = "GTK_ICON_VIEW_DROP_RIGHT")]
5452 DropRight,
5453 #[doc(alias = "GTK_ICON_VIEW_DROP_ABOVE")]
5454 DropAbove,
5455 #[doc(alias = "GTK_ICON_VIEW_DROP_BELOW")]
5456 DropBelow,
5457 #[doc(hidden)]
5458 __Unknown(i32),
5459}
5460
5461#[doc(hidden)]
5462impl IntoGlib for IconViewDropPosition {
5463 type GlibType = ffi::GtkIconViewDropPosition;
5464
5465 #[inline]
5466 fn into_glib(self) -> ffi::GtkIconViewDropPosition {
5467 match self {
5468 Self::NoDrop => ffi::GTK_ICON_VIEW_NO_DROP,
5469 Self::DropInto => ffi::GTK_ICON_VIEW_DROP_INTO,
5470 Self::DropLeft => ffi::GTK_ICON_VIEW_DROP_LEFT,
5471 Self::DropRight => ffi::GTK_ICON_VIEW_DROP_RIGHT,
5472 Self::DropAbove => ffi::GTK_ICON_VIEW_DROP_ABOVE,
5473 Self::DropBelow => ffi::GTK_ICON_VIEW_DROP_BELOW,
5474 Self::__Unknown(value) => value,
5475 }
5476 }
5477}
5478
5479#[doc(hidden)]
5480impl FromGlib<ffi::GtkIconViewDropPosition> for IconViewDropPosition {
5481 #[inline]
5482 unsafe fn from_glib(value: ffi::GtkIconViewDropPosition) -> Self {
5483 skip_assert_initialized!();
5484
5485 match value {
5486 ffi::GTK_ICON_VIEW_NO_DROP => Self::NoDrop,
5487 ffi::GTK_ICON_VIEW_DROP_INTO => Self::DropInto,
5488 ffi::GTK_ICON_VIEW_DROP_LEFT => Self::DropLeft,
5489 ffi::GTK_ICON_VIEW_DROP_RIGHT => Self::DropRight,
5490 ffi::GTK_ICON_VIEW_DROP_ABOVE => Self::DropAbove,
5491 ffi::GTK_ICON_VIEW_DROP_BELOW => Self::DropBelow,
5492 value => Self::__Unknown(value),
5493 }
5494 }
5495}
5496
5497impl StaticType for IconViewDropPosition {
5498 #[inline]
5499 #[doc(alias = "gtk_icon_view_drop_position_get_type")]
5500 fn static_type() -> glib::Type {
5501 unsafe { from_glib(ffi::gtk_icon_view_drop_position_get_type()) }
5502 }
5503}
5504
5505impl glib::HasParamSpec for IconViewDropPosition {
5506 type ParamSpec = glib::ParamSpecEnum;
5507 type SetValue = Self;
5508 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
5509
5510 fn param_spec_builder() -> Self::BuilderFn {
5511 Self::ParamSpec::builder_with_default
5512 }
5513}
5514
5515impl glib::value::ValueType for IconViewDropPosition {
5516 type Type = Self;
5517}
5518
5519unsafe impl<'a> glib::value::FromValue<'a> for IconViewDropPosition {
5520 type Checker = glib::value::GenericValueTypeChecker<Self>;
5521
5522 #[inline]
5523 unsafe fn from_value(value: &'a glib::Value) -> Self {
5524 skip_assert_initialized!();
5525 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
5526 }
5527}
5528
5529impl ToValue for IconViewDropPosition {
5530 #[inline]
5531 fn to_value(&self) -> glib::Value {
5532 let mut value = glib::Value::for_value_type::<Self>();
5533 unsafe {
5534 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
5535 }
5536 value
5537 }
5538
5539 #[inline]
5540 fn value_type(&self) -> glib::Type {
5541 Self::static_type()
5542 }
5543}
5544
5545impl From<IconViewDropPosition> for glib::Value {
5546 #[inline]
5547 fn from(v: IconViewDropPosition) -> Self {
5548 skip_assert_initialized!();
5549 ToValue::to_value(&v)
5550 }
5551}
5552
5553#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
5554#[non_exhaustive]
5555#[doc(alias = "GtkImageType")]
5556pub enum ImageType {
5557 #[doc(alias = "GTK_IMAGE_EMPTY")]
5558 Empty,
5559 #[doc(alias = "GTK_IMAGE_ICON_NAME")]
5560 IconName,
5561 #[doc(alias = "GTK_IMAGE_GICON")]
5562 Gicon,
5563 #[doc(alias = "GTK_IMAGE_PAINTABLE")]
5564 Paintable,
5565 #[doc(hidden)]
5566 __Unknown(i32),
5567}
5568
5569#[doc(hidden)]
5570impl IntoGlib for ImageType {
5571 type GlibType = ffi::GtkImageType;
5572
5573 #[inline]
5574 fn into_glib(self) -> ffi::GtkImageType {
5575 match self {
5576 Self::Empty => ffi::GTK_IMAGE_EMPTY,
5577 Self::IconName => ffi::GTK_IMAGE_ICON_NAME,
5578 Self::Gicon => ffi::GTK_IMAGE_GICON,
5579 Self::Paintable => ffi::GTK_IMAGE_PAINTABLE,
5580 Self::__Unknown(value) => value,
5581 }
5582 }
5583}
5584
5585#[doc(hidden)]
5586impl FromGlib<ffi::GtkImageType> for ImageType {
5587 #[inline]
5588 unsafe fn from_glib(value: ffi::GtkImageType) -> Self {
5589 skip_assert_initialized!();
5590
5591 match value {
5592 ffi::GTK_IMAGE_EMPTY => Self::Empty,
5593 ffi::GTK_IMAGE_ICON_NAME => Self::IconName,
5594 ffi::GTK_IMAGE_GICON => Self::Gicon,
5595 ffi::GTK_IMAGE_PAINTABLE => Self::Paintable,
5596 value => Self::__Unknown(value),
5597 }
5598 }
5599}
5600
5601impl StaticType for ImageType {
5602 #[inline]
5603 #[doc(alias = "gtk_image_type_get_type")]
5604 fn static_type() -> glib::Type {
5605 unsafe { from_glib(ffi::gtk_image_type_get_type()) }
5606 }
5607}
5608
5609impl glib::HasParamSpec for ImageType {
5610 type ParamSpec = glib::ParamSpecEnum;
5611 type SetValue = Self;
5612 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
5613
5614 fn param_spec_builder() -> Self::BuilderFn {
5615 Self::ParamSpec::builder_with_default
5616 }
5617}
5618
5619impl glib::value::ValueType for ImageType {
5620 type Type = Self;
5621}
5622
5623unsafe impl<'a> glib::value::FromValue<'a> for ImageType {
5624 type Checker = glib::value::GenericValueTypeChecker<Self>;
5625
5626 #[inline]
5627 unsafe fn from_value(value: &'a glib::Value) -> Self {
5628 skip_assert_initialized!();
5629 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
5630 }
5631}
5632
5633impl ToValue for ImageType {
5634 #[inline]
5635 fn to_value(&self) -> glib::Value {
5636 let mut value = glib::Value::for_value_type::<Self>();
5637 unsafe {
5638 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
5639 }
5640 value
5641 }
5642
5643 #[inline]
5644 fn value_type(&self) -> glib::Type {
5645 Self::static_type()
5646 }
5647}
5648
5649impl From<ImageType> for glib::Value {
5650 #[inline]
5651 fn from(v: ImageType) -> Self {
5652 skip_assert_initialized!();
5653 ToValue::to_value(&v)
5654 }
5655}
5656
5657#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
5658#[non_exhaustive]
5659#[doc(alias = "GtkInputPurpose")]
5660pub enum InputPurpose {
5661 #[doc(alias = "GTK_INPUT_PURPOSE_FREE_FORM")]
5662 FreeForm,
5663 #[doc(alias = "GTK_INPUT_PURPOSE_ALPHA")]
5664 Alpha,
5665 #[doc(alias = "GTK_INPUT_PURPOSE_DIGITS")]
5666 Digits,
5667 #[doc(alias = "GTK_INPUT_PURPOSE_NUMBER")]
5668 Number,
5669 #[doc(alias = "GTK_INPUT_PURPOSE_PHONE")]
5670 Phone,
5671 #[doc(alias = "GTK_INPUT_PURPOSE_URL")]
5672 Url,
5673 #[doc(alias = "GTK_INPUT_PURPOSE_EMAIL")]
5674 Email,
5675 #[doc(alias = "GTK_INPUT_PURPOSE_NAME")]
5676 Name,
5677 #[doc(alias = "GTK_INPUT_PURPOSE_PASSWORD")]
5678 Password,
5679 #[doc(alias = "GTK_INPUT_PURPOSE_PIN")]
5680 Pin,
5681 #[doc(alias = "GTK_INPUT_PURPOSE_TERMINAL")]
5682 Terminal,
5683 #[doc(hidden)]
5684 __Unknown(i32),
5685}
5686
5687#[doc(hidden)]
5688impl IntoGlib for InputPurpose {
5689 type GlibType = ffi::GtkInputPurpose;
5690
5691 #[inline]
5692 fn into_glib(self) -> ffi::GtkInputPurpose {
5693 match self {
5694 Self::FreeForm => ffi::GTK_INPUT_PURPOSE_FREE_FORM,
5695 Self::Alpha => ffi::GTK_INPUT_PURPOSE_ALPHA,
5696 Self::Digits => ffi::GTK_INPUT_PURPOSE_DIGITS,
5697 Self::Number => ffi::GTK_INPUT_PURPOSE_NUMBER,
5698 Self::Phone => ffi::GTK_INPUT_PURPOSE_PHONE,
5699 Self::Url => ffi::GTK_INPUT_PURPOSE_URL,
5700 Self::Email => ffi::GTK_INPUT_PURPOSE_EMAIL,
5701 Self::Name => ffi::GTK_INPUT_PURPOSE_NAME,
5702 Self::Password => ffi::GTK_INPUT_PURPOSE_PASSWORD,
5703 Self::Pin => ffi::GTK_INPUT_PURPOSE_PIN,
5704 Self::Terminal => ffi::GTK_INPUT_PURPOSE_TERMINAL,
5705 Self::__Unknown(value) => value,
5706 }
5707 }
5708}
5709
5710#[doc(hidden)]
5711impl FromGlib<ffi::GtkInputPurpose> for InputPurpose {
5712 #[inline]
5713 unsafe fn from_glib(value: ffi::GtkInputPurpose) -> Self {
5714 skip_assert_initialized!();
5715
5716 match value {
5717 ffi::GTK_INPUT_PURPOSE_FREE_FORM => Self::FreeForm,
5718 ffi::GTK_INPUT_PURPOSE_ALPHA => Self::Alpha,
5719 ffi::GTK_INPUT_PURPOSE_DIGITS => Self::Digits,
5720 ffi::GTK_INPUT_PURPOSE_NUMBER => Self::Number,
5721 ffi::GTK_INPUT_PURPOSE_PHONE => Self::Phone,
5722 ffi::GTK_INPUT_PURPOSE_URL => Self::Url,
5723 ffi::GTK_INPUT_PURPOSE_EMAIL => Self::Email,
5724 ffi::GTK_INPUT_PURPOSE_NAME => Self::Name,
5725 ffi::GTK_INPUT_PURPOSE_PASSWORD => Self::Password,
5726 ffi::GTK_INPUT_PURPOSE_PIN => Self::Pin,
5727 ffi::GTK_INPUT_PURPOSE_TERMINAL => Self::Terminal,
5728 value => Self::__Unknown(value),
5729 }
5730 }
5731}
5732
5733impl StaticType for InputPurpose {
5734 #[inline]
5735 #[doc(alias = "gtk_input_purpose_get_type")]
5736 fn static_type() -> glib::Type {
5737 unsafe { from_glib(ffi::gtk_input_purpose_get_type()) }
5738 }
5739}
5740
5741impl glib::HasParamSpec for InputPurpose {
5742 type ParamSpec = glib::ParamSpecEnum;
5743 type SetValue = Self;
5744 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
5745
5746 fn param_spec_builder() -> Self::BuilderFn {
5747 Self::ParamSpec::builder_with_default
5748 }
5749}
5750
5751impl glib::value::ValueType for InputPurpose {
5752 type Type = Self;
5753}
5754
5755unsafe impl<'a> glib::value::FromValue<'a> for InputPurpose {
5756 type Checker = glib::value::GenericValueTypeChecker<Self>;
5757
5758 #[inline]
5759 unsafe fn from_value(value: &'a glib::Value) -> Self {
5760 skip_assert_initialized!();
5761 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
5762 }
5763}
5764
5765impl ToValue for InputPurpose {
5766 #[inline]
5767 fn to_value(&self) -> glib::Value {
5768 let mut value = glib::Value::for_value_type::<Self>();
5769 unsafe {
5770 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
5771 }
5772 value
5773 }
5774
5775 #[inline]
5776 fn value_type(&self) -> glib::Type {
5777 Self::static_type()
5778 }
5779}
5780
5781impl From<InputPurpose> for glib::Value {
5782 #[inline]
5783 fn from(v: InputPurpose) -> Self {
5784 skip_assert_initialized!();
5785 ToValue::to_value(&v)
5786 }
5787}
5788
5789#[cfg(feature = "v4_8")]
5790#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
5791#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
5792#[non_exhaustive]
5793#[doc(alias = "GtkInscriptionOverflow")]
5794pub enum InscriptionOverflow {
5795 #[doc(alias = "GTK_INSCRIPTION_OVERFLOW_CLIP")]
5796 Clip,
5797 #[doc(alias = "GTK_INSCRIPTION_OVERFLOW_ELLIPSIZE_START")]
5798 EllipsizeStart,
5799 #[doc(alias = "GTK_INSCRIPTION_OVERFLOW_ELLIPSIZE_MIDDLE")]
5800 EllipsizeMiddle,
5801 #[doc(alias = "GTK_INSCRIPTION_OVERFLOW_ELLIPSIZE_END")]
5802 EllipsizeEnd,
5803 #[doc(hidden)]
5804 __Unknown(i32),
5805}
5806
5807#[cfg(feature = "v4_8")]
5808#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
5809#[doc(hidden)]
5810impl IntoGlib for InscriptionOverflow {
5811 type GlibType = ffi::GtkInscriptionOverflow;
5812
5813 #[inline]
5814 fn into_glib(self) -> ffi::GtkInscriptionOverflow {
5815 match self {
5816 Self::Clip => ffi::GTK_INSCRIPTION_OVERFLOW_CLIP,
5817 Self::EllipsizeStart => ffi::GTK_INSCRIPTION_OVERFLOW_ELLIPSIZE_START,
5818 Self::EllipsizeMiddle => ffi::GTK_INSCRIPTION_OVERFLOW_ELLIPSIZE_MIDDLE,
5819 Self::EllipsizeEnd => ffi::GTK_INSCRIPTION_OVERFLOW_ELLIPSIZE_END,
5820 Self::__Unknown(value) => value,
5821 }
5822 }
5823}
5824
5825#[cfg(feature = "v4_8")]
5826#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
5827#[doc(hidden)]
5828impl FromGlib<ffi::GtkInscriptionOverflow> for InscriptionOverflow {
5829 #[inline]
5830 unsafe fn from_glib(value: ffi::GtkInscriptionOverflow) -> Self {
5831 skip_assert_initialized!();
5832
5833 match value {
5834 ffi::GTK_INSCRIPTION_OVERFLOW_CLIP => Self::Clip,
5835 ffi::GTK_INSCRIPTION_OVERFLOW_ELLIPSIZE_START => Self::EllipsizeStart,
5836 ffi::GTK_INSCRIPTION_OVERFLOW_ELLIPSIZE_MIDDLE => Self::EllipsizeMiddle,
5837 ffi::GTK_INSCRIPTION_OVERFLOW_ELLIPSIZE_END => Self::EllipsizeEnd,
5838 value => Self::__Unknown(value),
5839 }
5840 }
5841}
5842
5843#[cfg(feature = "v4_8")]
5844#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
5845impl StaticType for InscriptionOverflow {
5846 #[inline]
5847 #[doc(alias = "gtk_inscription_overflow_get_type")]
5848 fn static_type() -> glib::Type {
5849 unsafe { from_glib(ffi::gtk_inscription_overflow_get_type()) }
5850 }
5851}
5852
5853#[cfg(feature = "v4_8")]
5854#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
5855impl glib::HasParamSpec for InscriptionOverflow {
5856 type ParamSpec = glib::ParamSpecEnum;
5857 type SetValue = Self;
5858 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
5859
5860 fn param_spec_builder() -> Self::BuilderFn {
5861 Self::ParamSpec::builder_with_default
5862 }
5863}
5864
5865#[cfg(feature = "v4_8")]
5866#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
5867impl glib::value::ValueType for InscriptionOverflow {
5868 type Type = Self;
5869}
5870
5871#[cfg(feature = "v4_8")]
5872#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
5873unsafe impl<'a> glib::value::FromValue<'a> for InscriptionOverflow {
5874 type Checker = glib::value::GenericValueTypeChecker<Self>;
5875
5876 #[inline]
5877 unsafe fn from_value(value: &'a glib::Value) -> Self {
5878 skip_assert_initialized!();
5879 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
5880 }
5881}
5882
5883#[cfg(feature = "v4_8")]
5884#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
5885impl ToValue for InscriptionOverflow {
5886 #[inline]
5887 fn to_value(&self) -> glib::Value {
5888 let mut value = glib::Value::for_value_type::<Self>();
5889 unsafe {
5890 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
5891 }
5892 value
5893 }
5894
5895 #[inline]
5896 fn value_type(&self) -> glib::Type {
5897 Self::static_type()
5898 }
5899}
5900
5901#[cfg(feature = "v4_8")]
5902#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
5903impl From<InscriptionOverflow> for glib::Value {
5904 #[inline]
5905 fn from(v: InscriptionOverflow) -> Self {
5906 skip_assert_initialized!();
5907 ToValue::to_value(&v)
5908 }
5909}
5910
5911#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
5912#[non_exhaustive]
5913#[doc(alias = "GtkJustification")]
5914pub enum Justification {
5915 #[doc(alias = "GTK_JUSTIFY_LEFT")]
5916 Left,
5917 #[doc(alias = "GTK_JUSTIFY_RIGHT")]
5918 Right,
5919 #[doc(alias = "GTK_JUSTIFY_CENTER")]
5920 Center,
5921 #[doc(alias = "GTK_JUSTIFY_FILL")]
5922 Fill,
5923 #[doc(hidden)]
5924 __Unknown(i32),
5925}
5926
5927#[doc(hidden)]
5928impl IntoGlib for Justification {
5929 type GlibType = ffi::GtkJustification;
5930
5931 #[inline]
5932 fn into_glib(self) -> ffi::GtkJustification {
5933 match self {
5934 Self::Left => ffi::GTK_JUSTIFY_LEFT,
5935 Self::Right => ffi::GTK_JUSTIFY_RIGHT,
5936 Self::Center => ffi::GTK_JUSTIFY_CENTER,
5937 Self::Fill => ffi::GTK_JUSTIFY_FILL,
5938 Self::__Unknown(value) => value,
5939 }
5940 }
5941}
5942
5943#[doc(hidden)]
5944impl FromGlib<ffi::GtkJustification> for Justification {
5945 #[inline]
5946 unsafe fn from_glib(value: ffi::GtkJustification) -> Self {
5947 skip_assert_initialized!();
5948
5949 match value {
5950 ffi::GTK_JUSTIFY_LEFT => Self::Left,
5951 ffi::GTK_JUSTIFY_RIGHT => Self::Right,
5952 ffi::GTK_JUSTIFY_CENTER => Self::Center,
5953 ffi::GTK_JUSTIFY_FILL => Self::Fill,
5954 value => Self::__Unknown(value),
5955 }
5956 }
5957}
5958
5959impl StaticType for Justification {
5960 #[inline]
5961 #[doc(alias = "gtk_justification_get_type")]
5962 fn static_type() -> glib::Type {
5963 unsafe { from_glib(ffi::gtk_justification_get_type()) }
5964 }
5965}
5966
5967impl glib::HasParamSpec for Justification {
5968 type ParamSpec = glib::ParamSpecEnum;
5969 type SetValue = Self;
5970 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
5971
5972 fn param_spec_builder() -> Self::BuilderFn {
5973 Self::ParamSpec::builder_with_default
5974 }
5975}
5976
5977impl glib::value::ValueType for Justification {
5978 type Type = Self;
5979}
5980
5981unsafe impl<'a> glib::value::FromValue<'a> for Justification {
5982 type Checker = glib::value::GenericValueTypeChecker<Self>;
5983
5984 #[inline]
5985 unsafe fn from_value(value: &'a glib::Value) -> Self {
5986 skip_assert_initialized!();
5987 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
5988 }
5989}
5990
5991impl ToValue for Justification {
5992 #[inline]
5993 fn to_value(&self) -> glib::Value {
5994 let mut value = glib::Value::for_value_type::<Self>();
5995 unsafe {
5996 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
5997 }
5998 value
5999 }
6000
6001 #[inline]
6002 fn value_type(&self) -> glib::Type {
6003 Self::static_type()
6004 }
6005}
6006
6007impl From<Justification> for glib::Value {
6008 #[inline]
6009 fn from(v: Justification) -> Self {
6010 skip_assert_initialized!();
6011 ToValue::to_value(&v)
6012 }
6013}
6014
6015#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
6016#[non_exhaustive]
6017#[doc(alias = "GtkLevelBarMode")]
6018pub enum LevelBarMode {
6019 #[doc(alias = "GTK_LEVEL_BAR_MODE_CONTINUOUS")]
6020 Continuous,
6021 #[doc(alias = "GTK_LEVEL_BAR_MODE_DISCRETE")]
6022 Discrete,
6023 #[doc(hidden)]
6024 __Unknown(i32),
6025}
6026
6027#[doc(hidden)]
6028impl IntoGlib for LevelBarMode {
6029 type GlibType = ffi::GtkLevelBarMode;
6030
6031 #[inline]
6032 fn into_glib(self) -> ffi::GtkLevelBarMode {
6033 match self {
6034 Self::Continuous => ffi::GTK_LEVEL_BAR_MODE_CONTINUOUS,
6035 Self::Discrete => ffi::GTK_LEVEL_BAR_MODE_DISCRETE,
6036 Self::__Unknown(value) => value,
6037 }
6038 }
6039}
6040
6041#[doc(hidden)]
6042impl FromGlib<ffi::GtkLevelBarMode> for LevelBarMode {
6043 #[inline]
6044 unsafe fn from_glib(value: ffi::GtkLevelBarMode) -> Self {
6045 skip_assert_initialized!();
6046
6047 match value {
6048 ffi::GTK_LEVEL_BAR_MODE_CONTINUOUS => Self::Continuous,
6049 ffi::GTK_LEVEL_BAR_MODE_DISCRETE => Self::Discrete,
6050 value => Self::__Unknown(value),
6051 }
6052 }
6053}
6054
6055impl StaticType for LevelBarMode {
6056 #[inline]
6057 #[doc(alias = "gtk_level_bar_mode_get_type")]
6058 fn static_type() -> glib::Type {
6059 unsafe { from_glib(ffi::gtk_level_bar_mode_get_type()) }
6060 }
6061}
6062
6063impl glib::HasParamSpec for LevelBarMode {
6064 type ParamSpec = glib::ParamSpecEnum;
6065 type SetValue = Self;
6066 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
6067
6068 fn param_spec_builder() -> Self::BuilderFn {
6069 Self::ParamSpec::builder_with_default
6070 }
6071}
6072
6073impl glib::value::ValueType for LevelBarMode {
6074 type Type = Self;
6075}
6076
6077unsafe impl<'a> glib::value::FromValue<'a> for LevelBarMode {
6078 type Checker = glib::value::GenericValueTypeChecker<Self>;
6079
6080 #[inline]
6081 unsafe fn from_value(value: &'a glib::Value) -> Self {
6082 skip_assert_initialized!();
6083 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
6084 }
6085}
6086
6087impl ToValue for LevelBarMode {
6088 #[inline]
6089 fn to_value(&self) -> glib::Value {
6090 let mut value = glib::Value::for_value_type::<Self>();
6091 unsafe {
6092 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
6093 }
6094 value
6095 }
6096
6097 #[inline]
6098 fn value_type(&self) -> glib::Type {
6099 Self::static_type()
6100 }
6101}
6102
6103impl From<LevelBarMode> for glib::Value {
6104 #[inline]
6105 fn from(v: LevelBarMode) -> Self {
6106 skip_assert_initialized!();
6107 ToValue::to_value(&v)
6108 }
6109}
6110
6111#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
6112#[non_exhaustive]
6113#[doc(alias = "GtkLicense")]
6114pub enum License {
6115 #[doc(alias = "GTK_LICENSE_UNKNOWN")]
6116 Unknown,
6117 #[doc(alias = "GTK_LICENSE_CUSTOM")]
6118 Custom,
6119 #[doc(alias = "GTK_LICENSE_GPL_2_0")]
6120 Gpl20,
6121 #[doc(alias = "GTK_LICENSE_GPL_3_0")]
6122 Gpl30,
6123 #[doc(alias = "GTK_LICENSE_LGPL_2_1")]
6124 Lgpl21,
6125 #[doc(alias = "GTK_LICENSE_LGPL_3_0")]
6126 Lgpl30,
6127 #[doc(alias = "GTK_LICENSE_BSD")]
6128 Bsd,
6129 #[doc(alias = "GTK_LICENSE_MIT_X11")]
6130 MitX11,
6131 #[doc(alias = "GTK_LICENSE_ARTISTIC")]
6132 Artistic,
6133 #[doc(alias = "GTK_LICENSE_GPL_2_0_ONLY")]
6134 Gpl20Only,
6135 #[doc(alias = "GTK_LICENSE_GPL_3_0_ONLY")]
6136 Gpl30Only,
6137 #[doc(alias = "GTK_LICENSE_LGPL_2_1_ONLY")]
6138 Lgpl21Only,
6139 #[doc(alias = "GTK_LICENSE_LGPL_3_0_ONLY")]
6140 Lgpl30Only,
6141 #[doc(alias = "GTK_LICENSE_AGPL_3_0")]
6142 Agpl30,
6143 #[doc(alias = "GTK_LICENSE_AGPL_3_0_ONLY")]
6144 Agpl30Only,
6145 #[doc(alias = "GTK_LICENSE_BSD_3")]
6146 Bsd3,
6147 #[doc(alias = "GTK_LICENSE_APACHE_2_0")]
6148 Apache20,
6149 #[doc(alias = "GTK_LICENSE_MPL_2_0")]
6150 Mpl20,
6151 #[cfg(feature = "v4_14")]
6152 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
6153 #[doc(alias = "GTK_LICENSE_0BSD")]
6154 _0bsd,
6155 #[doc(hidden)]
6156 __Unknown(i32),
6157}
6158
6159#[doc(hidden)]
6160impl IntoGlib for License {
6161 type GlibType = ffi::GtkLicense;
6162
6163 fn into_glib(self) -> ffi::GtkLicense {
6164 match self {
6165 Self::Unknown => ffi::GTK_LICENSE_UNKNOWN,
6166 Self::Custom => ffi::GTK_LICENSE_CUSTOM,
6167 Self::Gpl20 => ffi::GTK_LICENSE_GPL_2_0,
6168 Self::Gpl30 => ffi::GTK_LICENSE_GPL_3_0,
6169 Self::Lgpl21 => ffi::GTK_LICENSE_LGPL_2_1,
6170 Self::Lgpl30 => ffi::GTK_LICENSE_LGPL_3_0,
6171 Self::Bsd => ffi::GTK_LICENSE_BSD,
6172 Self::MitX11 => ffi::GTK_LICENSE_MIT_X11,
6173 Self::Artistic => ffi::GTK_LICENSE_ARTISTIC,
6174 Self::Gpl20Only => ffi::GTK_LICENSE_GPL_2_0_ONLY,
6175 Self::Gpl30Only => ffi::GTK_LICENSE_GPL_3_0_ONLY,
6176 Self::Lgpl21Only => ffi::GTK_LICENSE_LGPL_2_1_ONLY,
6177 Self::Lgpl30Only => ffi::GTK_LICENSE_LGPL_3_0_ONLY,
6178 Self::Agpl30 => ffi::GTK_LICENSE_AGPL_3_0,
6179 Self::Agpl30Only => ffi::GTK_LICENSE_AGPL_3_0_ONLY,
6180 Self::Bsd3 => ffi::GTK_LICENSE_BSD_3,
6181 Self::Apache20 => ffi::GTK_LICENSE_APACHE_2_0,
6182 Self::Mpl20 => ffi::GTK_LICENSE_MPL_2_0,
6183 #[cfg(feature = "v4_14")]
6184 Self::_0bsd => ffi::GTK_LICENSE_0BSD,
6185 Self::__Unknown(value) => value,
6186 }
6187 }
6188}
6189
6190#[doc(hidden)]
6191impl FromGlib<ffi::GtkLicense> for License {
6192 unsafe fn from_glib(value: ffi::GtkLicense) -> Self {
6193 skip_assert_initialized!();
6194
6195 match value {
6196 ffi::GTK_LICENSE_UNKNOWN => Self::Unknown,
6197 ffi::GTK_LICENSE_CUSTOM => Self::Custom,
6198 ffi::GTK_LICENSE_GPL_2_0 => Self::Gpl20,
6199 ffi::GTK_LICENSE_GPL_3_0 => Self::Gpl30,
6200 ffi::GTK_LICENSE_LGPL_2_1 => Self::Lgpl21,
6201 ffi::GTK_LICENSE_LGPL_3_0 => Self::Lgpl30,
6202 ffi::GTK_LICENSE_BSD => Self::Bsd,
6203 ffi::GTK_LICENSE_MIT_X11 => Self::MitX11,
6204 ffi::GTK_LICENSE_ARTISTIC => Self::Artistic,
6205 ffi::GTK_LICENSE_GPL_2_0_ONLY => Self::Gpl20Only,
6206 ffi::GTK_LICENSE_GPL_3_0_ONLY => Self::Gpl30Only,
6207 ffi::GTK_LICENSE_LGPL_2_1_ONLY => Self::Lgpl21Only,
6208 ffi::GTK_LICENSE_LGPL_3_0_ONLY => Self::Lgpl30Only,
6209 ffi::GTK_LICENSE_AGPL_3_0 => Self::Agpl30,
6210 ffi::GTK_LICENSE_AGPL_3_0_ONLY => Self::Agpl30Only,
6211 ffi::GTK_LICENSE_BSD_3 => Self::Bsd3,
6212 ffi::GTK_LICENSE_APACHE_2_0 => Self::Apache20,
6213 ffi::GTK_LICENSE_MPL_2_0 => Self::Mpl20,
6214 #[cfg(feature = "v4_14")]
6215 ffi::GTK_LICENSE_0BSD => Self::_0bsd,
6216 value => Self::__Unknown(value),
6217 }
6218 }
6219}
6220
6221impl StaticType for License {
6222 #[inline]
6223 #[doc(alias = "gtk_license_get_type")]
6224 fn static_type() -> glib::Type {
6225 unsafe { from_glib(ffi::gtk_license_get_type()) }
6226 }
6227}
6228
6229impl glib::HasParamSpec for License {
6230 type ParamSpec = glib::ParamSpecEnum;
6231 type SetValue = Self;
6232 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
6233
6234 fn param_spec_builder() -> Self::BuilderFn {
6235 Self::ParamSpec::builder_with_default
6236 }
6237}
6238
6239impl glib::value::ValueType for License {
6240 type Type = Self;
6241}
6242
6243unsafe impl<'a> glib::value::FromValue<'a> for License {
6244 type Checker = glib::value::GenericValueTypeChecker<Self>;
6245
6246 #[inline]
6247 unsafe fn from_value(value: &'a glib::Value) -> Self {
6248 skip_assert_initialized!();
6249 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
6250 }
6251}
6252
6253impl ToValue for License {
6254 #[inline]
6255 fn to_value(&self) -> glib::Value {
6256 let mut value = glib::Value::for_value_type::<Self>();
6257 unsafe {
6258 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
6259 }
6260 value
6261 }
6262
6263 #[inline]
6264 fn value_type(&self) -> glib::Type {
6265 Self::static_type()
6266 }
6267}
6268
6269impl From<License> for glib::Value {
6270 #[inline]
6271 fn from(v: License) -> Self {
6272 skip_assert_initialized!();
6273 ToValue::to_value(&v)
6274 }
6275}
6276
6277#[cfg(feature = "v4_12")]
6278#[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
6279#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
6280#[non_exhaustive]
6281#[doc(alias = "GtkListTabBehavior")]
6282pub enum ListTabBehavior {
6283 #[doc(alias = "GTK_LIST_TAB_ALL")]
6284 All,
6285 #[doc(alias = "GTK_LIST_TAB_ITEM")]
6286 Item,
6287 #[doc(alias = "GTK_LIST_TAB_CELL")]
6288 Cell,
6289 #[doc(hidden)]
6290 __Unknown(i32),
6291}
6292
6293#[cfg(feature = "v4_12")]
6294#[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
6295#[doc(hidden)]
6296impl IntoGlib for ListTabBehavior {
6297 type GlibType = ffi::GtkListTabBehavior;
6298
6299 #[inline]
6300 fn into_glib(self) -> ffi::GtkListTabBehavior {
6301 match self {
6302 Self::All => ffi::GTK_LIST_TAB_ALL,
6303 Self::Item => ffi::GTK_LIST_TAB_ITEM,
6304 Self::Cell => ffi::GTK_LIST_TAB_CELL,
6305 Self::__Unknown(value) => value,
6306 }
6307 }
6308}
6309
6310#[cfg(feature = "v4_12")]
6311#[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
6312#[doc(hidden)]
6313impl FromGlib<ffi::GtkListTabBehavior> for ListTabBehavior {
6314 #[inline]
6315 unsafe fn from_glib(value: ffi::GtkListTabBehavior) -> Self {
6316 skip_assert_initialized!();
6317
6318 match value {
6319 ffi::GTK_LIST_TAB_ALL => Self::All,
6320 ffi::GTK_LIST_TAB_ITEM => Self::Item,
6321 ffi::GTK_LIST_TAB_CELL => Self::Cell,
6322 value => Self::__Unknown(value),
6323 }
6324 }
6325}
6326
6327#[cfg(feature = "v4_12")]
6328#[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
6329impl StaticType for ListTabBehavior {
6330 #[inline]
6331 #[doc(alias = "gtk_list_tab_behavior_get_type")]
6332 fn static_type() -> glib::Type {
6333 unsafe { from_glib(ffi::gtk_list_tab_behavior_get_type()) }
6334 }
6335}
6336
6337#[cfg(feature = "v4_12")]
6338#[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
6339impl glib::HasParamSpec for ListTabBehavior {
6340 type ParamSpec = glib::ParamSpecEnum;
6341 type SetValue = Self;
6342 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
6343
6344 fn param_spec_builder() -> Self::BuilderFn {
6345 Self::ParamSpec::builder_with_default
6346 }
6347}
6348
6349#[cfg(feature = "v4_12")]
6350#[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
6351impl glib::value::ValueType for ListTabBehavior {
6352 type Type = Self;
6353}
6354
6355#[cfg(feature = "v4_12")]
6356#[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
6357unsafe impl<'a> glib::value::FromValue<'a> for ListTabBehavior {
6358 type Checker = glib::value::GenericValueTypeChecker<Self>;
6359
6360 #[inline]
6361 unsafe fn from_value(value: &'a glib::Value) -> Self {
6362 skip_assert_initialized!();
6363 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
6364 }
6365}
6366
6367#[cfg(feature = "v4_12")]
6368#[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
6369impl ToValue for ListTabBehavior {
6370 #[inline]
6371 fn to_value(&self) -> glib::Value {
6372 let mut value = glib::Value::for_value_type::<Self>();
6373 unsafe {
6374 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
6375 }
6376 value
6377 }
6378
6379 #[inline]
6380 fn value_type(&self) -> glib::Type {
6381 Self::static_type()
6382 }
6383}
6384
6385#[cfg(feature = "v4_12")]
6386#[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
6387impl From<ListTabBehavior> for glib::Value {
6388 #[inline]
6389 fn from(v: ListTabBehavior) -> Self {
6390 skip_assert_initialized!();
6391 ToValue::to_value(&v)
6392 }
6393}
6394
6395#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
6396#[non_exhaustive]
6397#[doc(alias = "GtkMessageType")]
6398pub enum MessageType {
6399 #[doc(alias = "GTK_MESSAGE_INFO")]
6400 Info,
6401 #[doc(alias = "GTK_MESSAGE_WARNING")]
6402 Warning,
6403 #[doc(alias = "GTK_MESSAGE_QUESTION")]
6404 Question,
6405 #[doc(alias = "GTK_MESSAGE_ERROR")]
6406 Error,
6407 #[doc(alias = "GTK_MESSAGE_OTHER")]
6408 Other,
6409 #[doc(hidden)]
6410 __Unknown(i32),
6411}
6412
6413#[doc(hidden)]
6414impl IntoGlib for MessageType {
6415 type GlibType = ffi::GtkMessageType;
6416
6417 #[inline]
6418 fn into_glib(self) -> ffi::GtkMessageType {
6419 match self {
6420 Self::Info => ffi::GTK_MESSAGE_INFO,
6421 Self::Warning => ffi::GTK_MESSAGE_WARNING,
6422 Self::Question => ffi::GTK_MESSAGE_QUESTION,
6423 Self::Error => ffi::GTK_MESSAGE_ERROR,
6424 Self::Other => ffi::GTK_MESSAGE_OTHER,
6425 Self::__Unknown(value) => value,
6426 }
6427 }
6428}
6429
6430#[doc(hidden)]
6431impl FromGlib<ffi::GtkMessageType> for MessageType {
6432 #[inline]
6433 unsafe fn from_glib(value: ffi::GtkMessageType) -> Self {
6434 skip_assert_initialized!();
6435
6436 match value {
6437 ffi::GTK_MESSAGE_INFO => Self::Info,
6438 ffi::GTK_MESSAGE_WARNING => Self::Warning,
6439 ffi::GTK_MESSAGE_QUESTION => Self::Question,
6440 ffi::GTK_MESSAGE_ERROR => Self::Error,
6441 ffi::GTK_MESSAGE_OTHER => Self::Other,
6442 value => Self::__Unknown(value),
6443 }
6444 }
6445}
6446
6447impl StaticType for MessageType {
6448 #[inline]
6449 #[doc(alias = "gtk_message_type_get_type")]
6450 fn static_type() -> glib::Type {
6451 unsafe { from_glib(ffi::gtk_message_type_get_type()) }
6452 }
6453}
6454
6455impl glib::HasParamSpec for MessageType {
6456 type ParamSpec = glib::ParamSpecEnum;
6457 type SetValue = Self;
6458 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
6459
6460 fn param_spec_builder() -> Self::BuilderFn {
6461 Self::ParamSpec::builder_with_default
6462 }
6463}
6464
6465impl glib::value::ValueType for MessageType {
6466 type Type = Self;
6467}
6468
6469unsafe impl<'a> glib::value::FromValue<'a> for MessageType {
6470 type Checker = glib::value::GenericValueTypeChecker<Self>;
6471
6472 #[inline]
6473 unsafe fn from_value(value: &'a glib::Value) -> Self {
6474 skip_assert_initialized!();
6475 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
6476 }
6477}
6478
6479impl ToValue for MessageType {
6480 #[inline]
6481 fn to_value(&self) -> glib::Value {
6482 let mut value = glib::Value::for_value_type::<Self>();
6483 unsafe {
6484 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
6485 }
6486 value
6487 }
6488
6489 #[inline]
6490 fn value_type(&self) -> glib::Type {
6491 Self::static_type()
6492 }
6493}
6494
6495impl From<MessageType> for glib::Value {
6496 #[inline]
6497 fn from(v: MessageType) -> Self {
6498 skip_assert_initialized!();
6499 ToValue::to_value(&v)
6500 }
6501}
6502
6503#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
6504#[non_exhaustive]
6505#[doc(alias = "GtkMovementStep")]
6506pub enum MovementStep {
6507 #[doc(alias = "GTK_MOVEMENT_LOGICAL_POSITIONS")]
6508 LogicalPositions,
6509 #[doc(alias = "GTK_MOVEMENT_VISUAL_POSITIONS")]
6510 VisualPositions,
6511 #[doc(alias = "GTK_MOVEMENT_WORDS")]
6512 Words,
6513 #[doc(alias = "GTK_MOVEMENT_DISPLAY_LINES")]
6514 DisplayLines,
6515 #[doc(alias = "GTK_MOVEMENT_DISPLAY_LINE_ENDS")]
6516 DisplayLineEnds,
6517 #[doc(alias = "GTK_MOVEMENT_PARAGRAPHS")]
6518 Paragraphs,
6519 #[doc(alias = "GTK_MOVEMENT_PARAGRAPH_ENDS")]
6520 ParagraphEnds,
6521 #[doc(alias = "GTK_MOVEMENT_PAGES")]
6522 Pages,
6523 #[doc(alias = "GTK_MOVEMENT_BUFFER_ENDS")]
6524 BufferEnds,
6525 #[doc(alias = "GTK_MOVEMENT_HORIZONTAL_PAGES")]
6526 HorizontalPages,
6527 #[doc(hidden)]
6528 __Unknown(i32),
6529}
6530
6531#[doc(hidden)]
6532impl IntoGlib for MovementStep {
6533 type GlibType = ffi::GtkMovementStep;
6534
6535 #[inline]
6536 fn into_glib(self) -> ffi::GtkMovementStep {
6537 match self {
6538 Self::LogicalPositions => ffi::GTK_MOVEMENT_LOGICAL_POSITIONS,
6539 Self::VisualPositions => ffi::GTK_MOVEMENT_VISUAL_POSITIONS,
6540 Self::Words => ffi::GTK_MOVEMENT_WORDS,
6541 Self::DisplayLines => ffi::GTK_MOVEMENT_DISPLAY_LINES,
6542 Self::DisplayLineEnds => ffi::GTK_MOVEMENT_DISPLAY_LINE_ENDS,
6543 Self::Paragraphs => ffi::GTK_MOVEMENT_PARAGRAPHS,
6544 Self::ParagraphEnds => ffi::GTK_MOVEMENT_PARAGRAPH_ENDS,
6545 Self::Pages => ffi::GTK_MOVEMENT_PAGES,
6546 Self::BufferEnds => ffi::GTK_MOVEMENT_BUFFER_ENDS,
6547 Self::HorizontalPages => ffi::GTK_MOVEMENT_HORIZONTAL_PAGES,
6548 Self::__Unknown(value) => value,
6549 }
6550 }
6551}
6552
6553#[doc(hidden)]
6554impl FromGlib<ffi::GtkMovementStep> for MovementStep {
6555 #[inline]
6556 unsafe fn from_glib(value: ffi::GtkMovementStep) -> Self {
6557 skip_assert_initialized!();
6558
6559 match value {
6560 ffi::GTK_MOVEMENT_LOGICAL_POSITIONS => Self::LogicalPositions,
6561 ffi::GTK_MOVEMENT_VISUAL_POSITIONS => Self::VisualPositions,
6562 ffi::GTK_MOVEMENT_WORDS => Self::Words,
6563 ffi::GTK_MOVEMENT_DISPLAY_LINES => Self::DisplayLines,
6564 ffi::GTK_MOVEMENT_DISPLAY_LINE_ENDS => Self::DisplayLineEnds,
6565 ffi::GTK_MOVEMENT_PARAGRAPHS => Self::Paragraphs,
6566 ffi::GTK_MOVEMENT_PARAGRAPH_ENDS => Self::ParagraphEnds,
6567 ffi::GTK_MOVEMENT_PAGES => Self::Pages,
6568 ffi::GTK_MOVEMENT_BUFFER_ENDS => Self::BufferEnds,
6569 ffi::GTK_MOVEMENT_HORIZONTAL_PAGES => Self::HorizontalPages,
6570 value => Self::__Unknown(value),
6571 }
6572 }
6573}
6574
6575impl StaticType for MovementStep {
6576 #[inline]
6577 #[doc(alias = "gtk_movement_step_get_type")]
6578 fn static_type() -> glib::Type {
6579 unsafe { from_glib(ffi::gtk_movement_step_get_type()) }
6580 }
6581}
6582
6583impl glib::HasParamSpec for MovementStep {
6584 type ParamSpec = glib::ParamSpecEnum;
6585 type SetValue = Self;
6586 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
6587
6588 fn param_spec_builder() -> Self::BuilderFn {
6589 Self::ParamSpec::builder_with_default
6590 }
6591}
6592
6593impl glib::value::ValueType for MovementStep {
6594 type Type = Self;
6595}
6596
6597unsafe impl<'a> glib::value::FromValue<'a> for MovementStep {
6598 type Checker = glib::value::GenericValueTypeChecker<Self>;
6599
6600 #[inline]
6601 unsafe fn from_value(value: &'a glib::Value) -> Self {
6602 skip_assert_initialized!();
6603 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
6604 }
6605}
6606
6607impl ToValue for MovementStep {
6608 #[inline]
6609 fn to_value(&self) -> glib::Value {
6610 let mut value = glib::Value::for_value_type::<Self>();
6611 unsafe {
6612 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
6613 }
6614 value
6615 }
6616
6617 #[inline]
6618 fn value_type(&self) -> glib::Type {
6619 Self::static_type()
6620 }
6621}
6622
6623impl From<MovementStep> for glib::Value {
6624 #[inline]
6625 fn from(v: MovementStep) -> Self {
6626 skip_assert_initialized!();
6627 ToValue::to_value(&v)
6628 }
6629}
6630
6631#[cfg(feature = "v4_6")]
6632#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
6633#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
6634#[non_exhaustive]
6635#[doc(alias = "GtkNaturalWrapMode")]
6636pub enum NaturalWrapMode {
6637 #[doc(alias = "GTK_NATURAL_WRAP_INHERIT")]
6638 Inherit,
6639 #[doc(alias = "GTK_NATURAL_WRAP_NONE")]
6640 None,
6641 #[doc(alias = "GTK_NATURAL_WRAP_WORD")]
6642 Word,
6643 #[doc(hidden)]
6644 __Unknown(i32),
6645}
6646
6647#[cfg(feature = "v4_6")]
6648#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
6649#[doc(hidden)]
6650impl IntoGlib for NaturalWrapMode {
6651 type GlibType = ffi::GtkNaturalWrapMode;
6652
6653 #[inline]
6654 fn into_glib(self) -> ffi::GtkNaturalWrapMode {
6655 match self {
6656 Self::Inherit => ffi::GTK_NATURAL_WRAP_INHERIT,
6657 Self::None => ffi::GTK_NATURAL_WRAP_NONE,
6658 Self::Word => ffi::GTK_NATURAL_WRAP_WORD,
6659 Self::__Unknown(value) => value,
6660 }
6661 }
6662}
6663
6664#[cfg(feature = "v4_6")]
6665#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
6666#[doc(hidden)]
6667impl FromGlib<ffi::GtkNaturalWrapMode> for NaturalWrapMode {
6668 #[inline]
6669 unsafe fn from_glib(value: ffi::GtkNaturalWrapMode) -> Self {
6670 skip_assert_initialized!();
6671
6672 match value {
6673 ffi::GTK_NATURAL_WRAP_INHERIT => Self::Inherit,
6674 ffi::GTK_NATURAL_WRAP_NONE => Self::None,
6675 ffi::GTK_NATURAL_WRAP_WORD => Self::Word,
6676 value => Self::__Unknown(value),
6677 }
6678 }
6679}
6680
6681#[cfg(feature = "v4_6")]
6682#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
6683impl StaticType for NaturalWrapMode {
6684 #[inline]
6685 #[doc(alias = "gtk_natural_wrap_mode_get_type")]
6686 fn static_type() -> glib::Type {
6687 unsafe { from_glib(ffi::gtk_natural_wrap_mode_get_type()) }
6688 }
6689}
6690
6691#[cfg(feature = "v4_6")]
6692#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
6693impl glib::HasParamSpec for NaturalWrapMode {
6694 type ParamSpec = glib::ParamSpecEnum;
6695 type SetValue = Self;
6696 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
6697
6698 fn param_spec_builder() -> Self::BuilderFn {
6699 Self::ParamSpec::builder_with_default
6700 }
6701}
6702
6703#[cfg(feature = "v4_6")]
6704#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
6705impl glib::value::ValueType for NaturalWrapMode {
6706 type Type = Self;
6707}
6708
6709#[cfg(feature = "v4_6")]
6710#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
6711unsafe impl<'a> glib::value::FromValue<'a> for NaturalWrapMode {
6712 type Checker = glib::value::GenericValueTypeChecker<Self>;
6713
6714 #[inline]
6715 unsafe fn from_value(value: &'a glib::Value) -> Self {
6716 skip_assert_initialized!();
6717 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
6718 }
6719}
6720
6721#[cfg(feature = "v4_6")]
6722#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
6723impl ToValue for NaturalWrapMode {
6724 #[inline]
6725 fn to_value(&self) -> glib::Value {
6726 let mut value = glib::Value::for_value_type::<Self>();
6727 unsafe {
6728 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
6729 }
6730 value
6731 }
6732
6733 #[inline]
6734 fn value_type(&self) -> glib::Type {
6735 Self::static_type()
6736 }
6737}
6738
6739#[cfg(feature = "v4_6")]
6740#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
6741impl From<NaturalWrapMode> for glib::Value {
6742 #[inline]
6743 fn from(v: NaturalWrapMode) -> Self {
6744 skip_assert_initialized!();
6745 ToValue::to_value(&v)
6746 }
6747}
6748
6749#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
6750#[non_exhaustive]
6751#[doc(alias = "GtkNotebookTab")]
6752pub enum NotebookTab {
6753 #[doc(alias = "GTK_NOTEBOOK_TAB_FIRST")]
6754 First,
6755 #[doc(alias = "GTK_NOTEBOOK_TAB_LAST")]
6756 Last,
6757 #[doc(hidden)]
6758 __Unknown(i32),
6759}
6760
6761#[doc(hidden)]
6762impl IntoGlib for NotebookTab {
6763 type GlibType = ffi::GtkNotebookTab;
6764
6765 #[inline]
6766 fn into_glib(self) -> ffi::GtkNotebookTab {
6767 match self {
6768 Self::First => ffi::GTK_NOTEBOOK_TAB_FIRST,
6769 Self::Last => ffi::GTK_NOTEBOOK_TAB_LAST,
6770 Self::__Unknown(value) => value,
6771 }
6772 }
6773}
6774
6775#[doc(hidden)]
6776impl FromGlib<ffi::GtkNotebookTab> for NotebookTab {
6777 #[inline]
6778 unsafe fn from_glib(value: ffi::GtkNotebookTab) -> Self {
6779 skip_assert_initialized!();
6780
6781 match value {
6782 ffi::GTK_NOTEBOOK_TAB_FIRST => Self::First,
6783 ffi::GTK_NOTEBOOK_TAB_LAST => Self::Last,
6784 value => Self::__Unknown(value),
6785 }
6786 }
6787}
6788
6789impl StaticType for NotebookTab {
6790 #[inline]
6791 #[doc(alias = "gtk_notebook_tab_get_type")]
6792 fn static_type() -> glib::Type {
6793 unsafe { from_glib(ffi::gtk_notebook_tab_get_type()) }
6794 }
6795}
6796
6797impl glib::HasParamSpec for NotebookTab {
6798 type ParamSpec = glib::ParamSpecEnum;
6799 type SetValue = Self;
6800 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
6801
6802 fn param_spec_builder() -> Self::BuilderFn {
6803 Self::ParamSpec::builder_with_default
6804 }
6805}
6806
6807impl glib::value::ValueType for NotebookTab {
6808 type Type = Self;
6809}
6810
6811unsafe impl<'a> glib::value::FromValue<'a> for NotebookTab {
6812 type Checker = glib::value::GenericValueTypeChecker<Self>;
6813
6814 #[inline]
6815 unsafe fn from_value(value: &'a glib::Value) -> Self {
6816 skip_assert_initialized!();
6817 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
6818 }
6819}
6820
6821impl ToValue for NotebookTab {
6822 #[inline]
6823 fn to_value(&self) -> glib::Value {
6824 let mut value = glib::Value::for_value_type::<Self>();
6825 unsafe {
6826 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
6827 }
6828 value
6829 }
6830
6831 #[inline]
6832 fn value_type(&self) -> glib::Type {
6833 Self::static_type()
6834 }
6835}
6836
6837impl From<NotebookTab> for glib::Value {
6838 #[inline]
6839 fn from(v: NotebookTab) -> Self {
6840 skip_assert_initialized!();
6841 ToValue::to_value(&v)
6842 }
6843}
6844
6845#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
6846#[non_exhaustive]
6847#[doc(alias = "GtkNumberUpLayout")]
6848pub enum NumberUpLayout {
6849 #[doc(alias = "GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_TOP_TO_BOTTOM")]
6850 Lrtb,
6851 #[doc(alias = "GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_BOTTOM_TO_TOP")]
6852 Lrbt,
6853 #[doc(alias = "GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_TOP_TO_BOTTOM")]
6854 Rltb,
6855 #[doc(alias = "GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_BOTTOM_TO_TOP")]
6856 Rlbt,
6857 #[doc(alias = "GTK_NUMBER_UP_LAYOUT_TOP_TO_BOTTOM_LEFT_TO_RIGHT")]
6858 Tblr,
6859 #[doc(alias = "GTK_NUMBER_UP_LAYOUT_TOP_TO_BOTTOM_RIGHT_TO_LEFT")]
6860 Tbrl,
6861 #[doc(alias = "GTK_NUMBER_UP_LAYOUT_BOTTOM_TO_TOP_LEFT_TO_RIGHT")]
6862 Btlr,
6863 #[doc(alias = "GTK_NUMBER_UP_LAYOUT_BOTTOM_TO_TOP_RIGHT_TO_LEFT")]
6864 Btrl,
6865 #[doc(hidden)]
6866 __Unknown(i32),
6867}
6868
6869#[doc(hidden)]
6870impl IntoGlib for NumberUpLayout {
6871 type GlibType = ffi::GtkNumberUpLayout;
6872
6873 #[inline]
6874 fn into_glib(self) -> ffi::GtkNumberUpLayout {
6875 match self {
6876 Self::Lrtb => ffi::GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_TOP_TO_BOTTOM,
6877 Self::Lrbt => ffi::GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_BOTTOM_TO_TOP,
6878 Self::Rltb => ffi::GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_TOP_TO_BOTTOM,
6879 Self::Rlbt => ffi::GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_BOTTOM_TO_TOP,
6880 Self::Tblr => ffi::GTK_NUMBER_UP_LAYOUT_TOP_TO_BOTTOM_LEFT_TO_RIGHT,
6881 Self::Tbrl => ffi::GTK_NUMBER_UP_LAYOUT_TOP_TO_BOTTOM_RIGHT_TO_LEFT,
6882 Self::Btlr => ffi::GTK_NUMBER_UP_LAYOUT_BOTTOM_TO_TOP_LEFT_TO_RIGHT,
6883 Self::Btrl => ffi::GTK_NUMBER_UP_LAYOUT_BOTTOM_TO_TOP_RIGHT_TO_LEFT,
6884 Self::__Unknown(value) => value,
6885 }
6886 }
6887}
6888
6889#[doc(hidden)]
6890impl FromGlib<ffi::GtkNumberUpLayout> for NumberUpLayout {
6891 #[inline]
6892 unsafe fn from_glib(value: ffi::GtkNumberUpLayout) -> Self {
6893 skip_assert_initialized!();
6894
6895 match value {
6896 ffi::GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_TOP_TO_BOTTOM => Self::Lrtb,
6897 ffi::GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_BOTTOM_TO_TOP => Self::Lrbt,
6898 ffi::GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_TOP_TO_BOTTOM => Self::Rltb,
6899 ffi::GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_BOTTOM_TO_TOP => Self::Rlbt,
6900 ffi::GTK_NUMBER_UP_LAYOUT_TOP_TO_BOTTOM_LEFT_TO_RIGHT => Self::Tblr,
6901 ffi::GTK_NUMBER_UP_LAYOUT_TOP_TO_BOTTOM_RIGHT_TO_LEFT => Self::Tbrl,
6902 ffi::GTK_NUMBER_UP_LAYOUT_BOTTOM_TO_TOP_LEFT_TO_RIGHT => Self::Btlr,
6903 ffi::GTK_NUMBER_UP_LAYOUT_BOTTOM_TO_TOP_RIGHT_TO_LEFT => Self::Btrl,
6904 value => Self::__Unknown(value),
6905 }
6906 }
6907}
6908
6909impl StaticType for NumberUpLayout {
6910 #[inline]
6911 #[doc(alias = "gtk_number_up_layout_get_type")]
6912 fn static_type() -> glib::Type {
6913 unsafe { from_glib(ffi::gtk_number_up_layout_get_type()) }
6914 }
6915}
6916
6917impl glib::HasParamSpec for NumberUpLayout {
6918 type ParamSpec = glib::ParamSpecEnum;
6919 type SetValue = Self;
6920 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
6921
6922 fn param_spec_builder() -> Self::BuilderFn {
6923 Self::ParamSpec::builder_with_default
6924 }
6925}
6926
6927impl glib::value::ValueType for NumberUpLayout {
6928 type Type = Self;
6929}
6930
6931unsafe impl<'a> glib::value::FromValue<'a> for NumberUpLayout {
6932 type Checker = glib::value::GenericValueTypeChecker<Self>;
6933
6934 #[inline]
6935 unsafe fn from_value(value: &'a glib::Value) -> Self {
6936 skip_assert_initialized!();
6937 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
6938 }
6939}
6940
6941impl ToValue for NumberUpLayout {
6942 #[inline]
6943 fn to_value(&self) -> glib::Value {
6944 let mut value = glib::Value::for_value_type::<Self>();
6945 unsafe {
6946 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
6947 }
6948 value
6949 }
6950
6951 #[inline]
6952 fn value_type(&self) -> glib::Type {
6953 Self::static_type()
6954 }
6955}
6956
6957impl From<NumberUpLayout> for glib::Value {
6958 #[inline]
6959 fn from(v: NumberUpLayout) -> Self {
6960 skip_assert_initialized!();
6961 ToValue::to_value(&v)
6962 }
6963}
6964
6965#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
6966#[non_exhaustive]
6967#[doc(alias = "GtkOrdering")]
6968pub enum Ordering {
6969 #[doc(alias = "GTK_ORDERING_SMALLER")]
6970 Smaller,
6971 #[doc(alias = "GTK_ORDERING_EQUAL")]
6972 Equal,
6973 #[doc(alias = "GTK_ORDERING_LARGER")]
6974 Larger,
6975 #[doc(hidden)]
6976 __Unknown(i32),
6977}
6978
6979#[doc(hidden)]
6980impl IntoGlib for Ordering {
6981 type GlibType = ffi::GtkOrdering;
6982
6983 #[inline]
6984 fn into_glib(self) -> ffi::GtkOrdering {
6985 match self {
6986 Self::Smaller => ffi::GTK_ORDERING_SMALLER,
6987 Self::Equal => ffi::GTK_ORDERING_EQUAL,
6988 Self::Larger => ffi::GTK_ORDERING_LARGER,
6989 Self::__Unknown(value) => value,
6990 }
6991 }
6992}
6993
6994#[doc(hidden)]
6995impl FromGlib<ffi::GtkOrdering> for Ordering {
6996 #[inline]
6997 unsafe fn from_glib(value: ffi::GtkOrdering) -> Self {
6998 skip_assert_initialized!();
6999
7000 match value {
7001 ffi::GTK_ORDERING_SMALLER => Self::Smaller,
7002 ffi::GTK_ORDERING_EQUAL => Self::Equal,
7003 ffi::GTK_ORDERING_LARGER => Self::Larger,
7004 value => Self::__Unknown(value),
7005 }
7006 }
7007}
7008
7009impl StaticType for Ordering {
7010 #[inline]
7011 #[doc(alias = "gtk_ordering_get_type")]
7012 fn static_type() -> glib::Type {
7013 unsafe { from_glib(ffi::gtk_ordering_get_type()) }
7014 }
7015}
7016
7017impl glib::HasParamSpec for Ordering {
7018 type ParamSpec = glib::ParamSpecEnum;
7019 type SetValue = Self;
7020 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
7021
7022 fn param_spec_builder() -> Self::BuilderFn {
7023 Self::ParamSpec::builder_with_default
7024 }
7025}
7026
7027impl glib::value::ValueType for Ordering {
7028 type Type = Self;
7029}
7030
7031unsafe impl<'a> glib::value::FromValue<'a> for Ordering {
7032 type Checker = glib::value::GenericValueTypeChecker<Self>;
7033
7034 #[inline]
7035 unsafe fn from_value(value: &'a glib::Value) -> Self {
7036 skip_assert_initialized!();
7037 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
7038 }
7039}
7040
7041impl ToValue for Ordering {
7042 #[inline]
7043 fn to_value(&self) -> glib::Value {
7044 let mut value = glib::Value::for_value_type::<Self>();
7045 unsafe {
7046 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
7047 }
7048 value
7049 }
7050
7051 #[inline]
7052 fn value_type(&self) -> glib::Type {
7053 Self::static_type()
7054 }
7055}
7056
7057impl From<Ordering> for glib::Value {
7058 #[inline]
7059 fn from(v: Ordering) -> Self {
7060 skip_assert_initialized!();
7061 ToValue::to_value(&v)
7062 }
7063}
7064
7065#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
7066#[non_exhaustive]
7067#[doc(alias = "GtkOrientation")]
7068pub enum Orientation {
7069 #[doc(alias = "GTK_ORIENTATION_HORIZONTAL")]
7070 Horizontal,
7071 #[doc(alias = "GTK_ORIENTATION_VERTICAL")]
7072 Vertical,
7073 #[doc(hidden)]
7074 __Unknown(i32),
7075}
7076
7077#[doc(hidden)]
7078impl IntoGlib for Orientation {
7079 type GlibType = ffi::GtkOrientation;
7080
7081 #[inline]
7082 fn into_glib(self) -> ffi::GtkOrientation {
7083 match self {
7084 Self::Horizontal => ffi::GTK_ORIENTATION_HORIZONTAL,
7085 Self::Vertical => ffi::GTK_ORIENTATION_VERTICAL,
7086 Self::__Unknown(value) => value,
7087 }
7088 }
7089}
7090
7091#[doc(hidden)]
7092impl FromGlib<ffi::GtkOrientation> for Orientation {
7093 #[inline]
7094 unsafe fn from_glib(value: ffi::GtkOrientation) -> Self {
7095 skip_assert_initialized!();
7096
7097 match value {
7098 ffi::GTK_ORIENTATION_HORIZONTAL => Self::Horizontal,
7099 ffi::GTK_ORIENTATION_VERTICAL => Self::Vertical,
7100 value => Self::__Unknown(value),
7101 }
7102 }
7103}
7104
7105impl StaticType for Orientation {
7106 #[inline]
7107 #[doc(alias = "gtk_orientation_get_type")]
7108 fn static_type() -> glib::Type {
7109 unsafe { from_glib(ffi::gtk_orientation_get_type()) }
7110 }
7111}
7112
7113impl glib::HasParamSpec for Orientation {
7114 type ParamSpec = glib::ParamSpecEnum;
7115 type SetValue = Self;
7116 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
7117
7118 fn param_spec_builder() -> Self::BuilderFn {
7119 Self::ParamSpec::builder_with_default
7120 }
7121}
7122
7123impl glib::value::ValueType for Orientation {
7124 type Type = Self;
7125}
7126
7127unsafe impl<'a> glib::value::FromValue<'a> for Orientation {
7128 type Checker = glib::value::GenericValueTypeChecker<Self>;
7129
7130 #[inline]
7131 unsafe fn from_value(value: &'a glib::Value) -> Self {
7132 skip_assert_initialized!();
7133 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
7134 }
7135}
7136
7137impl ToValue for Orientation {
7138 #[inline]
7139 fn to_value(&self) -> glib::Value {
7140 let mut value = glib::Value::for_value_type::<Self>();
7141 unsafe {
7142 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
7143 }
7144 value
7145 }
7146
7147 #[inline]
7148 fn value_type(&self) -> glib::Type {
7149 Self::static_type()
7150 }
7151}
7152
7153impl From<Orientation> for glib::Value {
7154 #[inline]
7155 fn from(v: Orientation) -> Self {
7156 skip_assert_initialized!();
7157 ToValue::to_value(&v)
7158 }
7159}
7160
7161#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
7162#[non_exhaustive]
7163#[doc(alias = "GtkOverflow")]
7164pub enum Overflow {
7165 #[doc(alias = "GTK_OVERFLOW_VISIBLE")]
7166 Visible,
7167 #[doc(alias = "GTK_OVERFLOW_HIDDEN")]
7168 Hidden,
7169 #[doc(hidden)]
7170 __Unknown(i32),
7171}
7172
7173#[doc(hidden)]
7174impl IntoGlib for Overflow {
7175 type GlibType = ffi::GtkOverflow;
7176
7177 #[inline]
7178 fn into_glib(self) -> ffi::GtkOverflow {
7179 match self {
7180 Self::Visible => ffi::GTK_OVERFLOW_VISIBLE,
7181 Self::Hidden => ffi::GTK_OVERFLOW_HIDDEN,
7182 Self::__Unknown(value) => value,
7183 }
7184 }
7185}
7186
7187#[doc(hidden)]
7188impl FromGlib<ffi::GtkOverflow> for Overflow {
7189 #[inline]
7190 unsafe fn from_glib(value: ffi::GtkOverflow) -> Self {
7191 skip_assert_initialized!();
7192
7193 match value {
7194 ffi::GTK_OVERFLOW_VISIBLE => Self::Visible,
7195 ffi::GTK_OVERFLOW_HIDDEN => Self::Hidden,
7196 value => Self::__Unknown(value),
7197 }
7198 }
7199}
7200
7201impl StaticType for Overflow {
7202 #[inline]
7203 #[doc(alias = "gtk_overflow_get_type")]
7204 fn static_type() -> glib::Type {
7205 unsafe { from_glib(ffi::gtk_overflow_get_type()) }
7206 }
7207}
7208
7209impl glib::HasParamSpec for Overflow {
7210 type ParamSpec = glib::ParamSpecEnum;
7211 type SetValue = Self;
7212 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
7213
7214 fn param_spec_builder() -> Self::BuilderFn {
7215 Self::ParamSpec::builder_with_default
7216 }
7217}
7218
7219impl glib::value::ValueType for Overflow {
7220 type Type = Self;
7221}
7222
7223unsafe impl<'a> glib::value::FromValue<'a> for Overflow {
7224 type Checker = glib::value::GenericValueTypeChecker<Self>;
7225
7226 #[inline]
7227 unsafe fn from_value(value: &'a glib::Value) -> Self {
7228 skip_assert_initialized!();
7229 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
7230 }
7231}
7232
7233impl ToValue for Overflow {
7234 #[inline]
7235 fn to_value(&self) -> glib::Value {
7236 let mut value = glib::Value::for_value_type::<Self>();
7237 unsafe {
7238 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
7239 }
7240 value
7241 }
7242
7243 #[inline]
7244 fn value_type(&self) -> glib::Type {
7245 Self::static_type()
7246 }
7247}
7248
7249impl From<Overflow> for glib::Value {
7250 #[inline]
7251 fn from(v: Overflow) -> Self {
7252 skip_assert_initialized!();
7253 ToValue::to_value(&v)
7254 }
7255}
7256
7257#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
7258#[non_exhaustive]
7259#[doc(alias = "GtkPackType")]
7260pub enum PackType {
7261 #[doc(alias = "GTK_PACK_START")]
7262 Start,
7263 #[doc(alias = "GTK_PACK_END")]
7264 End,
7265 #[doc(hidden)]
7266 __Unknown(i32),
7267}
7268
7269#[doc(hidden)]
7270impl IntoGlib for PackType {
7271 type GlibType = ffi::GtkPackType;
7272
7273 #[inline]
7274 fn into_glib(self) -> ffi::GtkPackType {
7275 match self {
7276 Self::Start => ffi::GTK_PACK_START,
7277 Self::End => ffi::GTK_PACK_END,
7278 Self::__Unknown(value) => value,
7279 }
7280 }
7281}
7282
7283#[doc(hidden)]
7284impl FromGlib<ffi::GtkPackType> for PackType {
7285 #[inline]
7286 unsafe fn from_glib(value: ffi::GtkPackType) -> Self {
7287 skip_assert_initialized!();
7288
7289 match value {
7290 ffi::GTK_PACK_START => Self::Start,
7291 ffi::GTK_PACK_END => Self::End,
7292 value => Self::__Unknown(value),
7293 }
7294 }
7295}
7296
7297impl StaticType for PackType {
7298 #[inline]
7299 #[doc(alias = "gtk_pack_type_get_type")]
7300 fn static_type() -> glib::Type {
7301 unsafe { from_glib(ffi::gtk_pack_type_get_type()) }
7302 }
7303}
7304
7305impl glib::HasParamSpec for PackType {
7306 type ParamSpec = glib::ParamSpecEnum;
7307 type SetValue = Self;
7308 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
7309
7310 fn param_spec_builder() -> Self::BuilderFn {
7311 Self::ParamSpec::builder_with_default
7312 }
7313}
7314
7315impl glib::value::ValueType for PackType {
7316 type Type = Self;
7317}
7318
7319unsafe impl<'a> glib::value::FromValue<'a> for PackType {
7320 type Checker = glib::value::GenericValueTypeChecker<Self>;
7321
7322 #[inline]
7323 unsafe fn from_value(value: &'a glib::Value) -> Self {
7324 skip_assert_initialized!();
7325 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
7326 }
7327}
7328
7329impl ToValue for PackType {
7330 #[inline]
7331 fn to_value(&self) -> glib::Value {
7332 let mut value = glib::Value::for_value_type::<Self>();
7333 unsafe {
7334 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
7335 }
7336 value
7337 }
7338
7339 #[inline]
7340 fn value_type(&self) -> glib::Type {
7341 Self::static_type()
7342 }
7343}
7344
7345impl From<PackType> for glib::Value {
7346 #[inline]
7347 fn from(v: PackType) -> Self {
7348 skip_assert_initialized!();
7349 ToValue::to_value(&v)
7350 }
7351}
7352
7353#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
7354#[non_exhaustive]
7355#[doc(alias = "GtkPadActionType")]
7356pub enum PadActionType {
7357 #[doc(alias = "GTK_PAD_ACTION_BUTTON")]
7358 Button,
7359 #[doc(alias = "GTK_PAD_ACTION_RING")]
7360 Ring,
7361 #[doc(alias = "GTK_PAD_ACTION_STRIP")]
7362 Strip,
7363 #[doc(hidden)]
7364 __Unknown(i32),
7365}
7366
7367#[doc(hidden)]
7368impl IntoGlib for PadActionType {
7369 type GlibType = ffi::GtkPadActionType;
7370
7371 #[inline]
7372 fn into_glib(self) -> ffi::GtkPadActionType {
7373 match self {
7374 Self::Button => ffi::GTK_PAD_ACTION_BUTTON,
7375 Self::Ring => ffi::GTK_PAD_ACTION_RING,
7376 Self::Strip => ffi::GTK_PAD_ACTION_STRIP,
7377 Self::__Unknown(value) => value,
7378 }
7379 }
7380}
7381
7382#[doc(hidden)]
7383impl FromGlib<ffi::GtkPadActionType> for PadActionType {
7384 #[inline]
7385 unsafe fn from_glib(value: ffi::GtkPadActionType) -> Self {
7386 skip_assert_initialized!();
7387
7388 match value {
7389 ffi::GTK_PAD_ACTION_BUTTON => Self::Button,
7390 ffi::GTK_PAD_ACTION_RING => Self::Ring,
7391 ffi::GTK_PAD_ACTION_STRIP => Self::Strip,
7392 value => Self::__Unknown(value),
7393 }
7394 }
7395}
7396
7397impl StaticType for PadActionType {
7398 #[inline]
7399 #[doc(alias = "gtk_pad_action_type_get_type")]
7400 fn static_type() -> glib::Type {
7401 unsafe { from_glib(ffi::gtk_pad_action_type_get_type()) }
7402 }
7403}
7404
7405impl glib::HasParamSpec for PadActionType {
7406 type ParamSpec = glib::ParamSpecEnum;
7407 type SetValue = Self;
7408 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
7409
7410 fn param_spec_builder() -> Self::BuilderFn {
7411 Self::ParamSpec::builder_with_default
7412 }
7413}
7414
7415impl glib::value::ValueType for PadActionType {
7416 type Type = Self;
7417}
7418
7419unsafe impl<'a> glib::value::FromValue<'a> for PadActionType {
7420 type Checker = glib::value::GenericValueTypeChecker<Self>;
7421
7422 #[inline]
7423 unsafe fn from_value(value: &'a glib::Value) -> Self {
7424 skip_assert_initialized!();
7425 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
7426 }
7427}
7428
7429impl ToValue for PadActionType {
7430 #[inline]
7431 fn to_value(&self) -> glib::Value {
7432 let mut value = glib::Value::for_value_type::<Self>();
7433 unsafe {
7434 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
7435 }
7436 value
7437 }
7438
7439 #[inline]
7440 fn value_type(&self) -> glib::Type {
7441 Self::static_type()
7442 }
7443}
7444
7445impl From<PadActionType> for glib::Value {
7446 #[inline]
7447 fn from(v: PadActionType) -> Self {
7448 skip_assert_initialized!();
7449 ToValue::to_value(&v)
7450 }
7451}
7452
7453#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
7454#[non_exhaustive]
7455#[doc(alias = "GtkPageOrientation")]
7456pub enum PageOrientation {
7457 #[doc(alias = "GTK_PAGE_ORIENTATION_PORTRAIT")]
7458 Portrait,
7459 #[doc(alias = "GTK_PAGE_ORIENTATION_LANDSCAPE")]
7460 Landscape,
7461 #[doc(alias = "GTK_PAGE_ORIENTATION_REVERSE_PORTRAIT")]
7462 ReversePortrait,
7463 #[doc(alias = "GTK_PAGE_ORIENTATION_REVERSE_LANDSCAPE")]
7464 ReverseLandscape,
7465 #[doc(hidden)]
7466 __Unknown(i32),
7467}
7468
7469#[doc(hidden)]
7470impl IntoGlib for PageOrientation {
7471 type GlibType = ffi::GtkPageOrientation;
7472
7473 #[inline]
7474 fn into_glib(self) -> ffi::GtkPageOrientation {
7475 match self {
7476 Self::Portrait => ffi::GTK_PAGE_ORIENTATION_PORTRAIT,
7477 Self::Landscape => ffi::GTK_PAGE_ORIENTATION_LANDSCAPE,
7478 Self::ReversePortrait => ffi::GTK_PAGE_ORIENTATION_REVERSE_PORTRAIT,
7479 Self::ReverseLandscape => ffi::GTK_PAGE_ORIENTATION_REVERSE_LANDSCAPE,
7480 Self::__Unknown(value) => value,
7481 }
7482 }
7483}
7484
7485#[doc(hidden)]
7486impl FromGlib<ffi::GtkPageOrientation> for PageOrientation {
7487 #[inline]
7488 unsafe fn from_glib(value: ffi::GtkPageOrientation) -> Self {
7489 skip_assert_initialized!();
7490
7491 match value {
7492 ffi::GTK_PAGE_ORIENTATION_PORTRAIT => Self::Portrait,
7493 ffi::GTK_PAGE_ORIENTATION_LANDSCAPE => Self::Landscape,
7494 ffi::GTK_PAGE_ORIENTATION_REVERSE_PORTRAIT => Self::ReversePortrait,
7495 ffi::GTK_PAGE_ORIENTATION_REVERSE_LANDSCAPE => Self::ReverseLandscape,
7496 value => Self::__Unknown(value),
7497 }
7498 }
7499}
7500
7501impl StaticType for PageOrientation {
7502 #[inline]
7503 #[doc(alias = "gtk_page_orientation_get_type")]
7504 fn static_type() -> glib::Type {
7505 unsafe { from_glib(ffi::gtk_page_orientation_get_type()) }
7506 }
7507}
7508
7509impl glib::HasParamSpec for PageOrientation {
7510 type ParamSpec = glib::ParamSpecEnum;
7511 type SetValue = Self;
7512 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
7513
7514 fn param_spec_builder() -> Self::BuilderFn {
7515 Self::ParamSpec::builder_with_default
7516 }
7517}
7518
7519impl glib::value::ValueType for PageOrientation {
7520 type Type = Self;
7521}
7522
7523unsafe impl<'a> glib::value::FromValue<'a> for PageOrientation {
7524 type Checker = glib::value::GenericValueTypeChecker<Self>;
7525
7526 #[inline]
7527 unsafe fn from_value(value: &'a glib::Value) -> Self {
7528 skip_assert_initialized!();
7529 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
7530 }
7531}
7532
7533impl ToValue for PageOrientation {
7534 #[inline]
7535 fn to_value(&self) -> glib::Value {
7536 let mut value = glib::Value::for_value_type::<Self>();
7537 unsafe {
7538 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
7539 }
7540 value
7541 }
7542
7543 #[inline]
7544 fn value_type(&self) -> glib::Type {
7545 Self::static_type()
7546 }
7547}
7548
7549impl From<PageOrientation> for glib::Value {
7550 #[inline]
7551 fn from(v: PageOrientation) -> Self {
7552 skip_assert_initialized!();
7553 ToValue::to_value(&v)
7554 }
7555}
7556
7557#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
7558#[non_exhaustive]
7559#[doc(alias = "GtkPageSet")]
7560pub enum PageSet {
7561 #[doc(alias = "GTK_PAGE_SET_ALL")]
7562 All,
7563 #[doc(alias = "GTK_PAGE_SET_EVEN")]
7564 Even,
7565 #[doc(alias = "GTK_PAGE_SET_ODD")]
7566 Odd,
7567 #[doc(hidden)]
7568 __Unknown(i32),
7569}
7570
7571#[doc(hidden)]
7572impl IntoGlib for PageSet {
7573 type GlibType = ffi::GtkPageSet;
7574
7575 #[inline]
7576 fn into_glib(self) -> ffi::GtkPageSet {
7577 match self {
7578 Self::All => ffi::GTK_PAGE_SET_ALL,
7579 Self::Even => ffi::GTK_PAGE_SET_EVEN,
7580 Self::Odd => ffi::GTK_PAGE_SET_ODD,
7581 Self::__Unknown(value) => value,
7582 }
7583 }
7584}
7585
7586#[doc(hidden)]
7587impl FromGlib<ffi::GtkPageSet> for PageSet {
7588 #[inline]
7589 unsafe fn from_glib(value: ffi::GtkPageSet) -> Self {
7590 skip_assert_initialized!();
7591
7592 match value {
7593 ffi::GTK_PAGE_SET_ALL => Self::All,
7594 ffi::GTK_PAGE_SET_EVEN => Self::Even,
7595 ffi::GTK_PAGE_SET_ODD => Self::Odd,
7596 value => Self::__Unknown(value),
7597 }
7598 }
7599}
7600
7601impl StaticType for PageSet {
7602 #[inline]
7603 #[doc(alias = "gtk_page_set_get_type")]
7604 fn static_type() -> glib::Type {
7605 unsafe { from_glib(ffi::gtk_page_set_get_type()) }
7606 }
7607}
7608
7609impl glib::HasParamSpec for PageSet {
7610 type ParamSpec = glib::ParamSpecEnum;
7611 type SetValue = Self;
7612 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
7613
7614 fn param_spec_builder() -> Self::BuilderFn {
7615 Self::ParamSpec::builder_with_default
7616 }
7617}
7618
7619impl glib::value::ValueType for PageSet {
7620 type Type = Self;
7621}
7622
7623unsafe impl<'a> glib::value::FromValue<'a> for PageSet {
7624 type Checker = glib::value::GenericValueTypeChecker<Self>;
7625
7626 #[inline]
7627 unsafe fn from_value(value: &'a glib::Value) -> Self {
7628 skip_assert_initialized!();
7629 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
7630 }
7631}
7632
7633impl ToValue for PageSet {
7634 #[inline]
7635 fn to_value(&self) -> glib::Value {
7636 let mut value = glib::Value::for_value_type::<Self>();
7637 unsafe {
7638 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
7639 }
7640 value
7641 }
7642
7643 #[inline]
7644 fn value_type(&self) -> glib::Type {
7645 Self::static_type()
7646 }
7647}
7648
7649impl From<PageSet> for glib::Value {
7650 #[inline]
7651 fn from(v: PageSet) -> Self {
7652 skip_assert_initialized!();
7653 ToValue::to_value(&v)
7654 }
7655}
7656
7657#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
7658#[non_exhaustive]
7659#[doc(alias = "GtkPanDirection")]
7660pub enum PanDirection {
7661 #[doc(alias = "GTK_PAN_DIRECTION_LEFT")]
7662 Left,
7663 #[doc(alias = "GTK_PAN_DIRECTION_RIGHT")]
7664 Right,
7665 #[doc(alias = "GTK_PAN_DIRECTION_UP")]
7666 Up,
7667 #[doc(alias = "GTK_PAN_DIRECTION_DOWN")]
7668 Down,
7669 #[doc(hidden)]
7670 __Unknown(i32),
7671}
7672
7673#[doc(hidden)]
7674impl IntoGlib for PanDirection {
7675 type GlibType = ffi::GtkPanDirection;
7676
7677 #[inline]
7678 fn into_glib(self) -> ffi::GtkPanDirection {
7679 match self {
7680 Self::Left => ffi::GTK_PAN_DIRECTION_LEFT,
7681 Self::Right => ffi::GTK_PAN_DIRECTION_RIGHT,
7682 Self::Up => ffi::GTK_PAN_DIRECTION_UP,
7683 Self::Down => ffi::GTK_PAN_DIRECTION_DOWN,
7684 Self::__Unknown(value) => value,
7685 }
7686 }
7687}
7688
7689#[doc(hidden)]
7690impl FromGlib<ffi::GtkPanDirection> for PanDirection {
7691 #[inline]
7692 unsafe fn from_glib(value: ffi::GtkPanDirection) -> Self {
7693 skip_assert_initialized!();
7694
7695 match value {
7696 ffi::GTK_PAN_DIRECTION_LEFT => Self::Left,
7697 ffi::GTK_PAN_DIRECTION_RIGHT => Self::Right,
7698 ffi::GTK_PAN_DIRECTION_UP => Self::Up,
7699 ffi::GTK_PAN_DIRECTION_DOWN => Self::Down,
7700 value => Self::__Unknown(value),
7701 }
7702 }
7703}
7704
7705impl StaticType for PanDirection {
7706 #[inline]
7707 #[doc(alias = "gtk_pan_direction_get_type")]
7708 fn static_type() -> glib::Type {
7709 unsafe { from_glib(ffi::gtk_pan_direction_get_type()) }
7710 }
7711}
7712
7713impl glib::HasParamSpec for PanDirection {
7714 type ParamSpec = glib::ParamSpecEnum;
7715 type SetValue = Self;
7716 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
7717
7718 fn param_spec_builder() -> Self::BuilderFn {
7719 Self::ParamSpec::builder_with_default
7720 }
7721}
7722
7723impl glib::value::ValueType for PanDirection {
7724 type Type = Self;
7725}
7726
7727unsafe impl<'a> glib::value::FromValue<'a> for PanDirection {
7728 type Checker = glib::value::GenericValueTypeChecker<Self>;
7729
7730 #[inline]
7731 unsafe fn from_value(value: &'a glib::Value) -> Self {
7732 skip_assert_initialized!();
7733 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
7734 }
7735}
7736
7737impl ToValue for PanDirection {
7738 #[inline]
7739 fn to_value(&self) -> glib::Value {
7740 let mut value = glib::Value::for_value_type::<Self>();
7741 unsafe {
7742 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
7743 }
7744 value
7745 }
7746
7747 #[inline]
7748 fn value_type(&self) -> glib::Type {
7749 Self::static_type()
7750 }
7751}
7752
7753impl From<PanDirection> for glib::Value {
7754 #[inline]
7755 fn from(v: PanDirection) -> Self {
7756 skip_assert_initialized!();
7757 ToValue::to_value(&v)
7758 }
7759}
7760
7761#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
7762#[non_exhaustive]
7763#[doc(alias = "GtkPolicyType")]
7764pub enum PolicyType {
7765 #[doc(alias = "GTK_POLICY_ALWAYS")]
7766 Always,
7767 #[doc(alias = "GTK_POLICY_AUTOMATIC")]
7768 Automatic,
7769 #[doc(alias = "GTK_POLICY_NEVER")]
7770 Never,
7771 #[doc(alias = "GTK_POLICY_EXTERNAL")]
7772 External,
7773 #[doc(hidden)]
7774 __Unknown(i32),
7775}
7776
7777#[doc(hidden)]
7778impl IntoGlib for PolicyType {
7779 type GlibType = ffi::GtkPolicyType;
7780
7781 #[inline]
7782 fn into_glib(self) -> ffi::GtkPolicyType {
7783 match self {
7784 Self::Always => ffi::GTK_POLICY_ALWAYS,
7785 Self::Automatic => ffi::GTK_POLICY_AUTOMATIC,
7786 Self::Never => ffi::GTK_POLICY_NEVER,
7787 Self::External => ffi::GTK_POLICY_EXTERNAL,
7788 Self::__Unknown(value) => value,
7789 }
7790 }
7791}
7792
7793#[doc(hidden)]
7794impl FromGlib<ffi::GtkPolicyType> for PolicyType {
7795 #[inline]
7796 unsafe fn from_glib(value: ffi::GtkPolicyType) -> Self {
7797 skip_assert_initialized!();
7798
7799 match value {
7800 ffi::GTK_POLICY_ALWAYS => Self::Always,
7801 ffi::GTK_POLICY_AUTOMATIC => Self::Automatic,
7802 ffi::GTK_POLICY_NEVER => Self::Never,
7803 ffi::GTK_POLICY_EXTERNAL => Self::External,
7804 value => Self::__Unknown(value),
7805 }
7806 }
7807}
7808
7809impl StaticType for PolicyType {
7810 #[inline]
7811 #[doc(alias = "gtk_policy_type_get_type")]
7812 fn static_type() -> glib::Type {
7813 unsafe { from_glib(ffi::gtk_policy_type_get_type()) }
7814 }
7815}
7816
7817impl glib::HasParamSpec for PolicyType {
7818 type ParamSpec = glib::ParamSpecEnum;
7819 type SetValue = Self;
7820 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
7821
7822 fn param_spec_builder() -> Self::BuilderFn {
7823 Self::ParamSpec::builder_with_default
7824 }
7825}
7826
7827impl glib::value::ValueType for PolicyType {
7828 type Type = Self;
7829}
7830
7831unsafe impl<'a> glib::value::FromValue<'a> for PolicyType {
7832 type Checker = glib::value::GenericValueTypeChecker<Self>;
7833
7834 #[inline]
7835 unsafe fn from_value(value: &'a glib::Value) -> Self {
7836 skip_assert_initialized!();
7837 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
7838 }
7839}
7840
7841impl ToValue for PolicyType {
7842 #[inline]
7843 fn to_value(&self) -> glib::Value {
7844 let mut value = glib::Value::for_value_type::<Self>();
7845 unsafe {
7846 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
7847 }
7848 value
7849 }
7850
7851 #[inline]
7852 fn value_type(&self) -> glib::Type {
7853 Self::static_type()
7854 }
7855}
7856
7857impl From<PolicyType> for glib::Value {
7858 #[inline]
7859 fn from(v: PolicyType) -> Self {
7860 skip_assert_initialized!();
7861 ToValue::to_value(&v)
7862 }
7863}
7864
7865#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
7866#[non_exhaustive]
7867#[doc(alias = "GtkPositionType")]
7868pub enum PositionType {
7869 #[doc(alias = "GTK_POS_LEFT")]
7870 Left,
7871 #[doc(alias = "GTK_POS_RIGHT")]
7872 Right,
7873 #[doc(alias = "GTK_POS_TOP")]
7874 Top,
7875 #[doc(alias = "GTK_POS_BOTTOM")]
7876 Bottom,
7877 #[doc(hidden)]
7878 __Unknown(i32),
7879}
7880
7881#[doc(hidden)]
7882impl IntoGlib for PositionType {
7883 type GlibType = ffi::GtkPositionType;
7884
7885 #[inline]
7886 fn into_glib(self) -> ffi::GtkPositionType {
7887 match self {
7888 Self::Left => ffi::GTK_POS_LEFT,
7889 Self::Right => ffi::GTK_POS_RIGHT,
7890 Self::Top => ffi::GTK_POS_TOP,
7891 Self::Bottom => ffi::GTK_POS_BOTTOM,
7892 Self::__Unknown(value) => value,
7893 }
7894 }
7895}
7896
7897#[doc(hidden)]
7898impl FromGlib<ffi::GtkPositionType> for PositionType {
7899 #[inline]
7900 unsafe fn from_glib(value: ffi::GtkPositionType) -> Self {
7901 skip_assert_initialized!();
7902
7903 match value {
7904 ffi::GTK_POS_LEFT => Self::Left,
7905 ffi::GTK_POS_RIGHT => Self::Right,
7906 ffi::GTK_POS_TOP => Self::Top,
7907 ffi::GTK_POS_BOTTOM => Self::Bottom,
7908 value => Self::__Unknown(value),
7909 }
7910 }
7911}
7912
7913impl StaticType for PositionType {
7914 #[inline]
7915 #[doc(alias = "gtk_position_type_get_type")]
7916 fn static_type() -> glib::Type {
7917 unsafe { from_glib(ffi::gtk_position_type_get_type()) }
7918 }
7919}
7920
7921impl glib::HasParamSpec for PositionType {
7922 type ParamSpec = glib::ParamSpecEnum;
7923 type SetValue = Self;
7924 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
7925
7926 fn param_spec_builder() -> Self::BuilderFn {
7927 Self::ParamSpec::builder_with_default
7928 }
7929}
7930
7931impl glib::value::ValueType for PositionType {
7932 type Type = Self;
7933}
7934
7935unsafe impl<'a> glib::value::FromValue<'a> for PositionType {
7936 type Checker = glib::value::GenericValueTypeChecker<Self>;
7937
7938 #[inline]
7939 unsafe fn from_value(value: &'a glib::Value) -> Self {
7940 skip_assert_initialized!();
7941 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
7942 }
7943}
7944
7945impl ToValue for PositionType {
7946 #[inline]
7947 fn to_value(&self) -> glib::Value {
7948 let mut value = glib::Value::for_value_type::<Self>();
7949 unsafe {
7950 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
7951 }
7952 value
7953 }
7954
7955 #[inline]
7956 fn value_type(&self) -> glib::Type {
7957 Self::static_type()
7958 }
7959}
7960
7961impl From<PositionType> for glib::Value {
7962 #[inline]
7963 fn from(v: PositionType) -> Self {
7964 skip_assert_initialized!();
7965 ToValue::to_value(&v)
7966 }
7967}
7968
7969#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
7970#[non_exhaustive]
7971#[doc(alias = "GtkPrintDuplex")]
7972pub enum PrintDuplex {
7973 #[doc(alias = "GTK_PRINT_DUPLEX_SIMPLEX")]
7974 Simplex,
7975 #[doc(alias = "GTK_PRINT_DUPLEX_HORIZONTAL")]
7976 Horizontal,
7977 #[doc(alias = "GTK_PRINT_DUPLEX_VERTICAL")]
7978 Vertical,
7979 #[doc(hidden)]
7980 __Unknown(i32),
7981}
7982
7983#[doc(hidden)]
7984impl IntoGlib for PrintDuplex {
7985 type GlibType = ffi::GtkPrintDuplex;
7986
7987 #[inline]
7988 fn into_glib(self) -> ffi::GtkPrintDuplex {
7989 match self {
7990 Self::Simplex => ffi::GTK_PRINT_DUPLEX_SIMPLEX,
7991 Self::Horizontal => ffi::GTK_PRINT_DUPLEX_HORIZONTAL,
7992 Self::Vertical => ffi::GTK_PRINT_DUPLEX_VERTICAL,
7993 Self::__Unknown(value) => value,
7994 }
7995 }
7996}
7997
7998#[doc(hidden)]
7999impl FromGlib<ffi::GtkPrintDuplex> for PrintDuplex {
8000 #[inline]
8001 unsafe fn from_glib(value: ffi::GtkPrintDuplex) -> Self {
8002 skip_assert_initialized!();
8003
8004 match value {
8005 ffi::GTK_PRINT_DUPLEX_SIMPLEX => Self::Simplex,
8006 ffi::GTK_PRINT_DUPLEX_HORIZONTAL => Self::Horizontal,
8007 ffi::GTK_PRINT_DUPLEX_VERTICAL => Self::Vertical,
8008 value => Self::__Unknown(value),
8009 }
8010 }
8011}
8012
8013impl StaticType for PrintDuplex {
8014 #[inline]
8015 #[doc(alias = "gtk_print_duplex_get_type")]
8016 fn static_type() -> glib::Type {
8017 unsafe { from_glib(ffi::gtk_print_duplex_get_type()) }
8018 }
8019}
8020
8021impl glib::HasParamSpec for PrintDuplex {
8022 type ParamSpec = glib::ParamSpecEnum;
8023 type SetValue = Self;
8024 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
8025
8026 fn param_spec_builder() -> Self::BuilderFn {
8027 Self::ParamSpec::builder_with_default
8028 }
8029}
8030
8031impl glib::value::ValueType for PrintDuplex {
8032 type Type = Self;
8033}
8034
8035unsafe impl<'a> glib::value::FromValue<'a> for PrintDuplex {
8036 type Checker = glib::value::GenericValueTypeChecker<Self>;
8037
8038 #[inline]
8039 unsafe fn from_value(value: &'a glib::Value) -> Self {
8040 skip_assert_initialized!();
8041 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
8042 }
8043}
8044
8045impl ToValue for PrintDuplex {
8046 #[inline]
8047 fn to_value(&self) -> glib::Value {
8048 let mut value = glib::Value::for_value_type::<Self>();
8049 unsafe {
8050 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
8051 }
8052 value
8053 }
8054
8055 #[inline]
8056 fn value_type(&self) -> glib::Type {
8057 Self::static_type()
8058 }
8059}
8060
8061impl From<PrintDuplex> for glib::Value {
8062 #[inline]
8063 fn from(v: PrintDuplex) -> Self {
8064 skip_assert_initialized!();
8065 ToValue::to_value(&v)
8066 }
8067}
8068
8069#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
8070#[non_exhaustive]
8071#[doc(alias = "GtkPrintError")]
8072pub enum PrintError {
8073 #[doc(alias = "GTK_PRINT_ERROR_GENERAL")]
8074 General,
8075 #[doc(alias = "GTK_PRINT_ERROR_INTERNAL_ERROR")]
8076 InternalError,
8077 #[doc(alias = "GTK_PRINT_ERROR_NOMEM")]
8078 Nomem,
8079 #[doc(alias = "GTK_PRINT_ERROR_INVALID_FILE")]
8080 InvalidFile,
8081 #[doc(hidden)]
8082 __Unknown(i32),
8083}
8084
8085#[doc(hidden)]
8086impl IntoGlib for PrintError {
8087 type GlibType = ffi::GtkPrintError;
8088
8089 #[inline]
8090 fn into_glib(self) -> ffi::GtkPrintError {
8091 match self {
8092 Self::General => ffi::GTK_PRINT_ERROR_GENERAL,
8093 Self::InternalError => ffi::GTK_PRINT_ERROR_INTERNAL_ERROR,
8094 Self::Nomem => ffi::GTK_PRINT_ERROR_NOMEM,
8095 Self::InvalidFile => ffi::GTK_PRINT_ERROR_INVALID_FILE,
8096 Self::__Unknown(value) => value,
8097 }
8098 }
8099}
8100
8101#[doc(hidden)]
8102impl FromGlib<ffi::GtkPrintError> for PrintError {
8103 #[inline]
8104 unsafe fn from_glib(value: ffi::GtkPrintError) -> Self {
8105 skip_assert_initialized!();
8106
8107 match value {
8108 ffi::GTK_PRINT_ERROR_GENERAL => Self::General,
8109 ffi::GTK_PRINT_ERROR_INTERNAL_ERROR => Self::InternalError,
8110 ffi::GTK_PRINT_ERROR_NOMEM => Self::Nomem,
8111 ffi::GTK_PRINT_ERROR_INVALID_FILE => Self::InvalidFile,
8112 value => Self::__Unknown(value),
8113 }
8114 }
8115}
8116
8117impl glib::error::ErrorDomain for PrintError {
8118 #[inline]
8119 fn domain() -> glib::Quark {
8120 skip_assert_initialized!();
8121
8122 unsafe { from_glib(ffi::gtk_print_error_quark()) }
8123 }
8124
8125 #[inline]
8126 fn code(self) -> i32 {
8127 self.into_glib()
8128 }
8129
8130 #[inline]
8131 #[allow(clippy::match_single_binding)]
8132 fn from(code: i32) -> Option<Self> {
8133 skip_assert_initialized!();
8134 match unsafe { from_glib(code) } {
8135 value => Some(value),
8136 }
8137 }
8138}
8139
8140impl StaticType for PrintError {
8141 #[inline]
8142 #[doc(alias = "gtk_print_error_get_type")]
8143 fn static_type() -> glib::Type {
8144 unsafe { from_glib(ffi::gtk_print_error_get_type()) }
8145 }
8146}
8147
8148impl glib::HasParamSpec for PrintError {
8149 type ParamSpec = glib::ParamSpecEnum;
8150 type SetValue = Self;
8151 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
8152
8153 fn param_spec_builder() -> Self::BuilderFn {
8154 Self::ParamSpec::builder_with_default
8155 }
8156}
8157
8158impl glib::value::ValueType for PrintError {
8159 type Type = Self;
8160}
8161
8162unsafe impl<'a> glib::value::FromValue<'a> for PrintError {
8163 type Checker = glib::value::GenericValueTypeChecker<Self>;
8164
8165 #[inline]
8166 unsafe fn from_value(value: &'a glib::Value) -> Self {
8167 skip_assert_initialized!();
8168 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
8169 }
8170}
8171
8172impl ToValue for PrintError {
8173 #[inline]
8174 fn to_value(&self) -> glib::Value {
8175 let mut value = glib::Value::for_value_type::<Self>();
8176 unsafe {
8177 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
8178 }
8179 value
8180 }
8181
8182 #[inline]
8183 fn value_type(&self) -> glib::Type {
8184 Self::static_type()
8185 }
8186}
8187
8188impl From<PrintError> for glib::Value {
8189 #[inline]
8190 fn from(v: PrintError) -> Self {
8191 skip_assert_initialized!();
8192 ToValue::to_value(&v)
8193 }
8194}
8195
8196#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
8197#[non_exhaustive]
8198#[doc(alias = "GtkPrintOperationAction")]
8199pub enum PrintOperationAction {
8200 #[doc(alias = "GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG")]
8201 PrintDialog,
8202 #[doc(alias = "GTK_PRINT_OPERATION_ACTION_PRINT")]
8203 Print,
8204 #[doc(alias = "GTK_PRINT_OPERATION_ACTION_PREVIEW")]
8205 Preview,
8206 #[doc(alias = "GTK_PRINT_OPERATION_ACTION_EXPORT")]
8207 Export,
8208 #[doc(hidden)]
8209 __Unknown(i32),
8210}
8211
8212#[doc(hidden)]
8213impl IntoGlib for PrintOperationAction {
8214 type GlibType = ffi::GtkPrintOperationAction;
8215
8216 #[inline]
8217 fn into_glib(self) -> ffi::GtkPrintOperationAction {
8218 match self {
8219 Self::PrintDialog => ffi::GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG,
8220 Self::Print => ffi::GTK_PRINT_OPERATION_ACTION_PRINT,
8221 Self::Preview => ffi::GTK_PRINT_OPERATION_ACTION_PREVIEW,
8222 Self::Export => ffi::GTK_PRINT_OPERATION_ACTION_EXPORT,
8223 Self::__Unknown(value) => value,
8224 }
8225 }
8226}
8227
8228#[doc(hidden)]
8229impl FromGlib<ffi::GtkPrintOperationAction> for PrintOperationAction {
8230 #[inline]
8231 unsafe fn from_glib(value: ffi::GtkPrintOperationAction) -> Self {
8232 skip_assert_initialized!();
8233
8234 match value {
8235 ffi::GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG => Self::PrintDialog,
8236 ffi::GTK_PRINT_OPERATION_ACTION_PRINT => Self::Print,
8237 ffi::GTK_PRINT_OPERATION_ACTION_PREVIEW => Self::Preview,
8238 ffi::GTK_PRINT_OPERATION_ACTION_EXPORT => Self::Export,
8239 value => Self::__Unknown(value),
8240 }
8241 }
8242}
8243
8244impl StaticType for PrintOperationAction {
8245 #[inline]
8246 #[doc(alias = "gtk_print_operation_action_get_type")]
8247 fn static_type() -> glib::Type {
8248 unsafe { from_glib(ffi::gtk_print_operation_action_get_type()) }
8249 }
8250}
8251
8252impl glib::HasParamSpec for PrintOperationAction {
8253 type ParamSpec = glib::ParamSpecEnum;
8254 type SetValue = Self;
8255 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
8256
8257 fn param_spec_builder() -> Self::BuilderFn {
8258 Self::ParamSpec::builder_with_default
8259 }
8260}
8261
8262impl glib::value::ValueType for PrintOperationAction {
8263 type Type = Self;
8264}
8265
8266unsafe impl<'a> glib::value::FromValue<'a> for PrintOperationAction {
8267 type Checker = glib::value::GenericValueTypeChecker<Self>;
8268
8269 #[inline]
8270 unsafe fn from_value(value: &'a glib::Value) -> Self {
8271 skip_assert_initialized!();
8272 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
8273 }
8274}
8275
8276impl ToValue for PrintOperationAction {
8277 #[inline]
8278 fn to_value(&self) -> glib::Value {
8279 let mut value = glib::Value::for_value_type::<Self>();
8280 unsafe {
8281 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
8282 }
8283 value
8284 }
8285
8286 #[inline]
8287 fn value_type(&self) -> glib::Type {
8288 Self::static_type()
8289 }
8290}
8291
8292impl From<PrintOperationAction> for glib::Value {
8293 #[inline]
8294 fn from(v: PrintOperationAction) -> Self {
8295 skip_assert_initialized!();
8296 ToValue::to_value(&v)
8297 }
8298}
8299
8300#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
8301#[non_exhaustive]
8302#[doc(alias = "GtkPrintOperationResult")]
8303pub enum PrintOperationResult {
8304 #[doc(alias = "GTK_PRINT_OPERATION_RESULT_ERROR")]
8305 Error,
8306 #[doc(alias = "GTK_PRINT_OPERATION_RESULT_APPLY")]
8307 Apply,
8308 #[doc(alias = "GTK_PRINT_OPERATION_RESULT_CANCEL")]
8309 Cancel,
8310 #[doc(alias = "GTK_PRINT_OPERATION_RESULT_IN_PROGRESS")]
8311 InProgress,
8312 #[doc(hidden)]
8313 __Unknown(i32),
8314}
8315
8316#[doc(hidden)]
8317impl IntoGlib for PrintOperationResult {
8318 type GlibType = ffi::GtkPrintOperationResult;
8319
8320 #[inline]
8321 fn into_glib(self) -> ffi::GtkPrintOperationResult {
8322 match self {
8323 Self::Error => ffi::GTK_PRINT_OPERATION_RESULT_ERROR,
8324 Self::Apply => ffi::GTK_PRINT_OPERATION_RESULT_APPLY,
8325 Self::Cancel => ffi::GTK_PRINT_OPERATION_RESULT_CANCEL,
8326 Self::InProgress => ffi::GTK_PRINT_OPERATION_RESULT_IN_PROGRESS,
8327 Self::__Unknown(value) => value,
8328 }
8329 }
8330}
8331
8332#[doc(hidden)]
8333impl FromGlib<ffi::GtkPrintOperationResult> for PrintOperationResult {
8334 #[inline]
8335 unsafe fn from_glib(value: ffi::GtkPrintOperationResult) -> Self {
8336 skip_assert_initialized!();
8337
8338 match value {
8339 ffi::GTK_PRINT_OPERATION_RESULT_ERROR => Self::Error,
8340 ffi::GTK_PRINT_OPERATION_RESULT_APPLY => Self::Apply,
8341 ffi::GTK_PRINT_OPERATION_RESULT_CANCEL => Self::Cancel,
8342 ffi::GTK_PRINT_OPERATION_RESULT_IN_PROGRESS => Self::InProgress,
8343 value => Self::__Unknown(value),
8344 }
8345 }
8346}
8347
8348impl StaticType for PrintOperationResult {
8349 #[inline]
8350 #[doc(alias = "gtk_print_operation_result_get_type")]
8351 fn static_type() -> glib::Type {
8352 unsafe { from_glib(ffi::gtk_print_operation_result_get_type()) }
8353 }
8354}
8355
8356impl glib::HasParamSpec for PrintOperationResult {
8357 type ParamSpec = glib::ParamSpecEnum;
8358 type SetValue = Self;
8359 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
8360
8361 fn param_spec_builder() -> Self::BuilderFn {
8362 Self::ParamSpec::builder_with_default
8363 }
8364}
8365
8366impl glib::value::ValueType for PrintOperationResult {
8367 type Type = Self;
8368}
8369
8370unsafe impl<'a> glib::value::FromValue<'a> for PrintOperationResult {
8371 type Checker = glib::value::GenericValueTypeChecker<Self>;
8372
8373 #[inline]
8374 unsafe fn from_value(value: &'a glib::Value) -> Self {
8375 skip_assert_initialized!();
8376 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
8377 }
8378}
8379
8380impl ToValue for PrintOperationResult {
8381 #[inline]
8382 fn to_value(&self) -> glib::Value {
8383 let mut value = glib::Value::for_value_type::<Self>();
8384 unsafe {
8385 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
8386 }
8387 value
8388 }
8389
8390 #[inline]
8391 fn value_type(&self) -> glib::Type {
8392 Self::static_type()
8393 }
8394}
8395
8396impl From<PrintOperationResult> for glib::Value {
8397 #[inline]
8398 fn from(v: PrintOperationResult) -> Self {
8399 skip_assert_initialized!();
8400 ToValue::to_value(&v)
8401 }
8402}
8403
8404#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
8405#[non_exhaustive]
8406#[doc(alias = "GtkPrintPages")]
8407pub enum PrintPages {
8408 #[doc(alias = "GTK_PRINT_PAGES_ALL")]
8409 All,
8410 #[doc(alias = "GTK_PRINT_PAGES_CURRENT")]
8411 Current,
8412 #[doc(alias = "GTK_PRINT_PAGES_RANGES")]
8413 Ranges,
8414 #[doc(alias = "GTK_PRINT_PAGES_SELECTION")]
8415 Selection,
8416 #[doc(hidden)]
8417 __Unknown(i32),
8418}
8419
8420#[doc(hidden)]
8421impl IntoGlib for PrintPages {
8422 type GlibType = ffi::GtkPrintPages;
8423
8424 #[inline]
8425 fn into_glib(self) -> ffi::GtkPrintPages {
8426 match self {
8427 Self::All => ffi::GTK_PRINT_PAGES_ALL,
8428 Self::Current => ffi::GTK_PRINT_PAGES_CURRENT,
8429 Self::Ranges => ffi::GTK_PRINT_PAGES_RANGES,
8430 Self::Selection => ffi::GTK_PRINT_PAGES_SELECTION,
8431 Self::__Unknown(value) => value,
8432 }
8433 }
8434}
8435
8436#[doc(hidden)]
8437impl FromGlib<ffi::GtkPrintPages> for PrintPages {
8438 #[inline]
8439 unsafe fn from_glib(value: ffi::GtkPrintPages) -> Self {
8440 skip_assert_initialized!();
8441
8442 match value {
8443 ffi::GTK_PRINT_PAGES_ALL => Self::All,
8444 ffi::GTK_PRINT_PAGES_CURRENT => Self::Current,
8445 ffi::GTK_PRINT_PAGES_RANGES => Self::Ranges,
8446 ffi::GTK_PRINT_PAGES_SELECTION => Self::Selection,
8447 value => Self::__Unknown(value),
8448 }
8449 }
8450}
8451
8452impl StaticType for PrintPages {
8453 #[inline]
8454 #[doc(alias = "gtk_print_pages_get_type")]
8455 fn static_type() -> glib::Type {
8456 unsafe { from_glib(ffi::gtk_print_pages_get_type()) }
8457 }
8458}
8459
8460impl glib::HasParamSpec for PrintPages {
8461 type ParamSpec = glib::ParamSpecEnum;
8462 type SetValue = Self;
8463 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
8464
8465 fn param_spec_builder() -> Self::BuilderFn {
8466 Self::ParamSpec::builder_with_default
8467 }
8468}
8469
8470impl glib::value::ValueType for PrintPages {
8471 type Type = Self;
8472}
8473
8474unsafe impl<'a> glib::value::FromValue<'a> for PrintPages {
8475 type Checker = glib::value::GenericValueTypeChecker<Self>;
8476
8477 #[inline]
8478 unsafe fn from_value(value: &'a glib::Value) -> Self {
8479 skip_assert_initialized!();
8480 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
8481 }
8482}
8483
8484impl ToValue for PrintPages {
8485 #[inline]
8486 fn to_value(&self) -> glib::Value {
8487 let mut value = glib::Value::for_value_type::<Self>();
8488 unsafe {
8489 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
8490 }
8491 value
8492 }
8493
8494 #[inline]
8495 fn value_type(&self) -> glib::Type {
8496 Self::static_type()
8497 }
8498}
8499
8500impl From<PrintPages> for glib::Value {
8501 #[inline]
8502 fn from(v: PrintPages) -> Self {
8503 skip_assert_initialized!();
8504 ToValue::to_value(&v)
8505 }
8506}
8507
8508#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
8509#[non_exhaustive]
8510#[doc(alias = "GtkPrintQuality")]
8511pub enum PrintQuality {
8512 #[doc(alias = "GTK_PRINT_QUALITY_LOW")]
8513 Low,
8514 #[doc(alias = "GTK_PRINT_QUALITY_NORMAL")]
8515 Normal,
8516 #[doc(alias = "GTK_PRINT_QUALITY_HIGH")]
8517 High,
8518 #[doc(alias = "GTK_PRINT_QUALITY_DRAFT")]
8519 Draft,
8520 #[doc(hidden)]
8521 __Unknown(i32),
8522}
8523
8524#[doc(hidden)]
8525impl IntoGlib for PrintQuality {
8526 type GlibType = ffi::GtkPrintQuality;
8527
8528 #[inline]
8529 fn into_glib(self) -> ffi::GtkPrintQuality {
8530 match self {
8531 Self::Low => ffi::GTK_PRINT_QUALITY_LOW,
8532 Self::Normal => ffi::GTK_PRINT_QUALITY_NORMAL,
8533 Self::High => ffi::GTK_PRINT_QUALITY_HIGH,
8534 Self::Draft => ffi::GTK_PRINT_QUALITY_DRAFT,
8535 Self::__Unknown(value) => value,
8536 }
8537 }
8538}
8539
8540#[doc(hidden)]
8541impl FromGlib<ffi::GtkPrintQuality> for PrintQuality {
8542 #[inline]
8543 unsafe fn from_glib(value: ffi::GtkPrintQuality) -> Self {
8544 skip_assert_initialized!();
8545
8546 match value {
8547 ffi::GTK_PRINT_QUALITY_LOW => Self::Low,
8548 ffi::GTK_PRINT_QUALITY_NORMAL => Self::Normal,
8549 ffi::GTK_PRINT_QUALITY_HIGH => Self::High,
8550 ffi::GTK_PRINT_QUALITY_DRAFT => Self::Draft,
8551 value => Self::__Unknown(value),
8552 }
8553 }
8554}
8555
8556impl StaticType for PrintQuality {
8557 #[inline]
8558 #[doc(alias = "gtk_print_quality_get_type")]
8559 fn static_type() -> glib::Type {
8560 unsafe { from_glib(ffi::gtk_print_quality_get_type()) }
8561 }
8562}
8563
8564impl glib::HasParamSpec for PrintQuality {
8565 type ParamSpec = glib::ParamSpecEnum;
8566 type SetValue = Self;
8567 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
8568
8569 fn param_spec_builder() -> Self::BuilderFn {
8570 Self::ParamSpec::builder_with_default
8571 }
8572}
8573
8574impl glib::value::ValueType for PrintQuality {
8575 type Type = Self;
8576}
8577
8578unsafe impl<'a> glib::value::FromValue<'a> for PrintQuality {
8579 type Checker = glib::value::GenericValueTypeChecker<Self>;
8580
8581 #[inline]
8582 unsafe fn from_value(value: &'a glib::Value) -> Self {
8583 skip_assert_initialized!();
8584 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
8585 }
8586}
8587
8588impl ToValue for PrintQuality {
8589 #[inline]
8590 fn to_value(&self) -> glib::Value {
8591 let mut value = glib::Value::for_value_type::<Self>();
8592 unsafe {
8593 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
8594 }
8595 value
8596 }
8597
8598 #[inline]
8599 fn value_type(&self) -> glib::Type {
8600 Self::static_type()
8601 }
8602}
8603
8604impl From<PrintQuality> for glib::Value {
8605 #[inline]
8606 fn from(v: PrintQuality) -> Self {
8607 skip_assert_initialized!();
8608 ToValue::to_value(&v)
8609 }
8610}
8611
8612#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
8613#[non_exhaustive]
8614#[doc(alias = "GtkPrintStatus")]
8615pub enum PrintStatus {
8616 #[doc(alias = "GTK_PRINT_STATUS_INITIAL")]
8617 Initial,
8618 #[doc(alias = "GTK_PRINT_STATUS_PREPARING")]
8619 Preparing,
8620 #[doc(alias = "GTK_PRINT_STATUS_GENERATING_DATA")]
8621 GeneratingData,
8622 #[doc(alias = "GTK_PRINT_STATUS_SENDING_DATA")]
8623 SendingData,
8624 #[doc(alias = "GTK_PRINT_STATUS_PENDING")]
8625 Pending,
8626 #[doc(alias = "GTK_PRINT_STATUS_PENDING_ISSUE")]
8627 PendingIssue,
8628 #[doc(alias = "GTK_PRINT_STATUS_PRINTING")]
8629 Printing,
8630 #[doc(alias = "GTK_PRINT_STATUS_FINISHED")]
8631 Finished,
8632 #[doc(alias = "GTK_PRINT_STATUS_FINISHED_ABORTED")]
8633 FinishedAborted,
8634 #[doc(hidden)]
8635 __Unknown(i32),
8636}
8637
8638#[doc(hidden)]
8639impl IntoGlib for PrintStatus {
8640 type GlibType = ffi::GtkPrintStatus;
8641
8642 #[inline]
8643 fn into_glib(self) -> ffi::GtkPrintStatus {
8644 match self {
8645 Self::Initial => ffi::GTK_PRINT_STATUS_INITIAL,
8646 Self::Preparing => ffi::GTK_PRINT_STATUS_PREPARING,
8647 Self::GeneratingData => ffi::GTK_PRINT_STATUS_GENERATING_DATA,
8648 Self::SendingData => ffi::GTK_PRINT_STATUS_SENDING_DATA,
8649 Self::Pending => ffi::GTK_PRINT_STATUS_PENDING,
8650 Self::PendingIssue => ffi::GTK_PRINT_STATUS_PENDING_ISSUE,
8651 Self::Printing => ffi::GTK_PRINT_STATUS_PRINTING,
8652 Self::Finished => ffi::GTK_PRINT_STATUS_FINISHED,
8653 Self::FinishedAborted => ffi::GTK_PRINT_STATUS_FINISHED_ABORTED,
8654 Self::__Unknown(value) => value,
8655 }
8656 }
8657}
8658
8659#[doc(hidden)]
8660impl FromGlib<ffi::GtkPrintStatus> for PrintStatus {
8661 #[inline]
8662 unsafe fn from_glib(value: ffi::GtkPrintStatus) -> Self {
8663 skip_assert_initialized!();
8664
8665 match value {
8666 ffi::GTK_PRINT_STATUS_INITIAL => Self::Initial,
8667 ffi::GTK_PRINT_STATUS_PREPARING => Self::Preparing,
8668 ffi::GTK_PRINT_STATUS_GENERATING_DATA => Self::GeneratingData,
8669 ffi::GTK_PRINT_STATUS_SENDING_DATA => Self::SendingData,
8670 ffi::GTK_PRINT_STATUS_PENDING => Self::Pending,
8671 ffi::GTK_PRINT_STATUS_PENDING_ISSUE => Self::PendingIssue,
8672 ffi::GTK_PRINT_STATUS_PRINTING => Self::Printing,
8673 ffi::GTK_PRINT_STATUS_FINISHED => Self::Finished,
8674 ffi::GTK_PRINT_STATUS_FINISHED_ABORTED => Self::FinishedAborted,
8675 value => Self::__Unknown(value),
8676 }
8677 }
8678}
8679
8680impl StaticType for PrintStatus {
8681 #[inline]
8682 #[doc(alias = "gtk_print_status_get_type")]
8683 fn static_type() -> glib::Type {
8684 unsafe { from_glib(ffi::gtk_print_status_get_type()) }
8685 }
8686}
8687
8688impl glib::HasParamSpec for PrintStatus {
8689 type ParamSpec = glib::ParamSpecEnum;
8690 type SetValue = Self;
8691 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
8692
8693 fn param_spec_builder() -> Self::BuilderFn {
8694 Self::ParamSpec::builder_with_default
8695 }
8696}
8697
8698impl glib::value::ValueType for PrintStatus {
8699 type Type = Self;
8700}
8701
8702unsafe impl<'a> glib::value::FromValue<'a> for PrintStatus {
8703 type Checker = glib::value::GenericValueTypeChecker<Self>;
8704
8705 #[inline]
8706 unsafe fn from_value(value: &'a glib::Value) -> Self {
8707 skip_assert_initialized!();
8708 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
8709 }
8710}
8711
8712impl ToValue for PrintStatus {
8713 #[inline]
8714 fn to_value(&self) -> glib::Value {
8715 let mut value = glib::Value::for_value_type::<Self>();
8716 unsafe {
8717 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
8718 }
8719 value
8720 }
8721
8722 #[inline]
8723 fn value_type(&self) -> glib::Type {
8724 Self::static_type()
8725 }
8726}
8727
8728impl From<PrintStatus> for glib::Value {
8729 #[inline]
8730 fn from(v: PrintStatus) -> Self {
8731 skip_assert_initialized!();
8732 ToValue::to_value(&v)
8733 }
8734}
8735
8736#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
8737#[non_exhaustive]
8738#[doc(alias = "GtkPropagationLimit")]
8739pub enum PropagationLimit {
8740 #[doc(alias = "GTK_LIMIT_NONE")]
8741 None,
8742 #[doc(alias = "GTK_LIMIT_SAME_NATIVE")]
8743 SameNative,
8744 #[doc(hidden)]
8745 __Unknown(i32),
8746}
8747
8748#[doc(hidden)]
8749impl IntoGlib for PropagationLimit {
8750 type GlibType = ffi::GtkPropagationLimit;
8751
8752 #[inline]
8753 fn into_glib(self) -> ffi::GtkPropagationLimit {
8754 match self {
8755 Self::None => ffi::GTK_LIMIT_NONE,
8756 Self::SameNative => ffi::GTK_LIMIT_SAME_NATIVE,
8757 Self::__Unknown(value) => value,
8758 }
8759 }
8760}
8761
8762#[doc(hidden)]
8763impl FromGlib<ffi::GtkPropagationLimit> for PropagationLimit {
8764 #[inline]
8765 unsafe fn from_glib(value: ffi::GtkPropagationLimit) -> Self {
8766 skip_assert_initialized!();
8767
8768 match value {
8769 ffi::GTK_LIMIT_NONE => Self::None,
8770 ffi::GTK_LIMIT_SAME_NATIVE => Self::SameNative,
8771 value => Self::__Unknown(value),
8772 }
8773 }
8774}
8775
8776impl StaticType for PropagationLimit {
8777 #[inline]
8778 #[doc(alias = "gtk_propagation_limit_get_type")]
8779 fn static_type() -> glib::Type {
8780 unsafe { from_glib(ffi::gtk_propagation_limit_get_type()) }
8781 }
8782}
8783
8784impl glib::HasParamSpec for PropagationLimit {
8785 type ParamSpec = glib::ParamSpecEnum;
8786 type SetValue = Self;
8787 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
8788
8789 fn param_spec_builder() -> Self::BuilderFn {
8790 Self::ParamSpec::builder_with_default
8791 }
8792}
8793
8794impl glib::value::ValueType for PropagationLimit {
8795 type Type = Self;
8796}
8797
8798unsafe impl<'a> glib::value::FromValue<'a> for PropagationLimit {
8799 type Checker = glib::value::GenericValueTypeChecker<Self>;
8800
8801 #[inline]
8802 unsafe fn from_value(value: &'a glib::Value) -> Self {
8803 skip_assert_initialized!();
8804 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
8805 }
8806}
8807
8808impl ToValue for PropagationLimit {
8809 #[inline]
8810 fn to_value(&self) -> glib::Value {
8811 let mut value = glib::Value::for_value_type::<Self>();
8812 unsafe {
8813 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
8814 }
8815 value
8816 }
8817
8818 #[inline]
8819 fn value_type(&self) -> glib::Type {
8820 Self::static_type()
8821 }
8822}
8823
8824impl From<PropagationLimit> for glib::Value {
8825 #[inline]
8826 fn from(v: PropagationLimit) -> Self {
8827 skip_assert_initialized!();
8828 ToValue::to_value(&v)
8829 }
8830}
8831
8832#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
8833#[non_exhaustive]
8834#[doc(alias = "GtkPropagationPhase")]
8835pub enum PropagationPhase {
8836 #[doc(alias = "GTK_PHASE_NONE")]
8837 None,
8838 #[doc(alias = "GTK_PHASE_CAPTURE")]
8839 Capture,
8840 #[doc(alias = "GTK_PHASE_BUBBLE")]
8841 Bubble,
8842 #[doc(alias = "GTK_PHASE_TARGET")]
8843 Target,
8844 #[doc(hidden)]
8845 __Unknown(i32),
8846}
8847
8848#[doc(hidden)]
8849impl IntoGlib for PropagationPhase {
8850 type GlibType = ffi::GtkPropagationPhase;
8851
8852 #[inline]
8853 fn into_glib(self) -> ffi::GtkPropagationPhase {
8854 match self {
8855 Self::None => ffi::GTK_PHASE_NONE,
8856 Self::Capture => ffi::GTK_PHASE_CAPTURE,
8857 Self::Bubble => ffi::GTK_PHASE_BUBBLE,
8858 Self::Target => ffi::GTK_PHASE_TARGET,
8859 Self::__Unknown(value) => value,
8860 }
8861 }
8862}
8863
8864#[doc(hidden)]
8865impl FromGlib<ffi::GtkPropagationPhase> for PropagationPhase {
8866 #[inline]
8867 unsafe fn from_glib(value: ffi::GtkPropagationPhase) -> Self {
8868 skip_assert_initialized!();
8869
8870 match value {
8871 ffi::GTK_PHASE_NONE => Self::None,
8872 ffi::GTK_PHASE_CAPTURE => Self::Capture,
8873 ffi::GTK_PHASE_BUBBLE => Self::Bubble,
8874 ffi::GTK_PHASE_TARGET => Self::Target,
8875 value => Self::__Unknown(value),
8876 }
8877 }
8878}
8879
8880impl StaticType for PropagationPhase {
8881 #[inline]
8882 #[doc(alias = "gtk_propagation_phase_get_type")]
8883 fn static_type() -> glib::Type {
8884 unsafe { from_glib(ffi::gtk_propagation_phase_get_type()) }
8885 }
8886}
8887
8888impl glib::HasParamSpec for PropagationPhase {
8889 type ParamSpec = glib::ParamSpecEnum;
8890 type SetValue = Self;
8891 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
8892
8893 fn param_spec_builder() -> Self::BuilderFn {
8894 Self::ParamSpec::builder_with_default
8895 }
8896}
8897
8898impl glib::value::ValueType for PropagationPhase {
8899 type Type = Self;
8900}
8901
8902unsafe impl<'a> glib::value::FromValue<'a> for PropagationPhase {
8903 type Checker = glib::value::GenericValueTypeChecker<Self>;
8904
8905 #[inline]
8906 unsafe fn from_value(value: &'a glib::Value) -> Self {
8907 skip_assert_initialized!();
8908 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
8909 }
8910}
8911
8912impl ToValue for PropagationPhase {
8913 #[inline]
8914 fn to_value(&self) -> glib::Value {
8915 let mut value = glib::Value::for_value_type::<Self>();
8916 unsafe {
8917 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
8918 }
8919 value
8920 }
8921
8922 #[inline]
8923 fn value_type(&self) -> glib::Type {
8924 Self::static_type()
8925 }
8926}
8927
8928impl From<PropagationPhase> for glib::Value {
8929 #[inline]
8930 fn from(v: PropagationPhase) -> Self {
8931 skip_assert_initialized!();
8932 ToValue::to_value(&v)
8933 }
8934}
8935
8936#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
8937#[non_exhaustive]
8938#[doc(alias = "GtkRecentManagerError")]
8939pub enum RecentManagerError {
8940 #[doc(alias = "GTK_RECENT_MANAGER_ERROR_NOT_FOUND")]
8941 NotFound,
8942 #[doc(alias = "GTK_RECENT_MANAGER_ERROR_INVALID_URI")]
8943 InvalidUri,
8944 #[doc(alias = "GTK_RECENT_MANAGER_ERROR_INVALID_ENCODING")]
8945 InvalidEncoding,
8946 #[doc(alias = "GTK_RECENT_MANAGER_ERROR_NOT_REGISTERED")]
8947 NotRegistered,
8948 #[doc(alias = "GTK_RECENT_MANAGER_ERROR_READ")]
8949 Read,
8950 #[doc(alias = "GTK_RECENT_MANAGER_ERROR_WRITE")]
8951 Write,
8952 #[doc(alias = "GTK_RECENT_MANAGER_ERROR_UNKNOWN")]
8953 Unknown,
8954 #[doc(hidden)]
8955 __Unknown(i32),
8956}
8957
8958#[doc(hidden)]
8959impl IntoGlib for RecentManagerError {
8960 type GlibType = ffi::GtkRecentManagerError;
8961
8962 #[inline]
8963 fn into_glib(self) -> ffi::GtkRecentManagerError {
8964 match self {
8965 Self::NotFound => ffi::GTK_RECENT_MANAGER_ERROR_NOT_FOUND,
8966 Self::InvalidUri => ffi::GTK_RECENT_MANAGER_ERROR_INVALID_URI,
8967 Self::InvalidEncoding => ffi::GTK_RECENT_MANAGER_ERROR_INVALID_ENCODING,
8968 Self::NotRegistered => ffi::GTK_RECENT_MANAGER_ERROR_NOT_REGISTERED,
8969 Self::Read => ffi::GTK_RECENT_MANAGER_ERROR_READ,
8970 Self::Write => ffi::GTK_RECENT_MANAGER_ERROR_WRITE,
8971 Self::Unknown => ffi::GTK_RECENT_MANAGER_ERROR_UNKNOWN,
8972 Self::__Unknown(value) => value,
8973 }
8974 }
8975}
8976
8977#[doc(hidden)]
8978impl FromGlib<ffi::GtkRecentManagerError> for RecentManagerError {
8979 #[inline]
8980 unsafe fn from_glib(value: ffi::GtkRecentManagerError) -> Self {
8981 skip_assert_initialized!();
8982
8983 match value {
8984 ffi::GTK_RECENT_MANAGER_ERROR_NOT_FOUND => Self::NotFound,
8985 ffi::GTK_RECENT_MANAGER_ERROR_INVALID_URI => Self::InvalidUri,
8986 ffi::GTK_RECENT_MANAGER_ERROR_INVALID_ENCODING => Self::InvalidEncoding,
8987 ffi::GTK_RECENT_MANAGER_ERROR_NOT_REGISTERED => Self::NotRegistered,
8988 ffi::GTK_RECENT_MANAGER_ERROR_READ => Self::Read,
8989 ffi::GTK_RECENT_MANAGER_ERROR_WRITE => Self::Write,
8990 ffi::GTK_RECENT_MANAGER_ERROR_UNKNOWN => Self::Unknown,
8991 value => Self::__Unknown(value),
8992 }
8993 }
8994}
8995
8996impl glib::error::ErrorDomain for RecentManagerError {
8997 #[inline]
8998 fn domain() -> glib::Quark {
8999 skip_assert_initialized!();
9000
9001 unsafe { from_glib(ffi::gtk_recent_manager_error_quark()) }
9002 }
9003
9004 #[inline]
9005 fn code(self) -> i32 {
9006 self.into_glib()
9007 }
9008
9009 #[inline]
9010 #[allow(clippy::match_single_binding)]
9011 fn from(code: i32) -> Option<Self> {
9012 skip_assert_initialized!();
9013 match unsafe { from_glib(code) } {
9014 value => Some(value),
9015 }
9016 }
9017}
9018
9019impl StaticType for RecentManagerError {
9020 #[inline]
9021 #[doc(alias = "gtk_recent_manager_error_get_type")]
9022 fn static_type() -> glib::Type {
9023 unsafe { from_glib(ffi::gtk_recent_manager_error_get_type()) }
9024 }
9025}
9026
9027impl glib::HasParamSpec for RecentManagerError {
9028 type ParamSpec = glib::ParamSpecEnum;
9029 type SetValue = Self;
9030 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
9031
9032 fn param_spec_builder() -> Self::BuilderFn {
9033 Self::ParamSpec::builder_with_default
9034 }
9035}
9036
9037impl glib::value::ValueType for RecentManagerError {
9038 type Type = Self;
9039}
9040
9041unsafe impl<'a> glib::value::FromValue<'a> for RecentManagerError {
9042 type Checker = glib::value::GenericValueTypeChecker<Self>;
9043
9044 #[inline]
9045 unsafe fn from_value(value: &'a glib::Value) -> Self {
9046 skip_assert_initialized!();
9047 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
9048 }
9049}
9050
9051impl ToValue for RecentManagerError {
9052 #[inline]
9053 fn to_value(&self) -> glib::Value {
9054 let mut value = glib::Value::for_value_type::<Self>();
9055 unsafe {
9056 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
9057 }
9058 value
9059 }
9060
9061 #[inline]
9062 fn value_type(&self) -> glib::Type {
9063 Self::static_type()
9064 }
9065}
9066
9067impl From<RecentManagerError> for glib::Value {
9068 #[inline]
9069 fn from(v: RecentManagerError) -> Self {
9070 skip_assert_initialized!();
9071 ToValue::to_value(&v)
9072 }
9073}
9074
9075#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
9076#[non_exhaustive]
9077#[doc(alias = "GtkRevealerTransitionType")]
9078pub enum RevealerTransitionType {
9079 #[doc(alias = "GTK_REVEALER_TRANSITION_TYPE_NONE")]
9080 None,
9081 #[doc(alias = "GTK_REVEALER_TRANSITION_TYPE_CROSSFADE")]
9082 Crossfade,
9083 #[doc(alias = "GTK_REVEALER_TRANSITION_TYPE_SLIDE_RIGHT")]
9084 SlideRight,
9085 #[doc(alias = "GTK_REVEALER_TRANSITION_TYPE_SLIDE_LEFT")]
9086 SlideLeft,
9087 #[doc(alias = "GTK_REVEALER_TRANSITION_TYPE_SLIDE_UP")]
9088 SlideUp,
9089 #[doc(alias = "GTK_REVEALER_TRANSITION_TYPE_SLIDE_DOWN")]
9090 SlideDown,
9091 #[doc(alias = "GTK_REVEALER_TRANSITION_TYPE_SWING_RIGHT")]
9092 SwingRight,
9093 #[doc(alias = "GTK_REVEALER_TRANSITION_TYPE_SWING_LEFT")]
9094 SwingLeft,
9095 #[doc(alias = "GTK_REVEALER_TRANSITION_TYPE_SWING_UP")]
9096 SwingUp,
9097 #[doc(alias = "GTK_REVEALER_TRANSITION_TYPE_SWING_DOWN")]
9098 SwingDown,
9099 #[doc(hidden)]
9100 __Unknown(i32),
9101}
9102
9103#[doc(hidden)]
9104impl IntoGlib for RevealerTransitionType {
9105 type GlibType = ffi::GtkRevealerTransitionType;
9106
9107 #[inline]
9108 fn into_glib(self) -> ffi::GtkRevealerTransitionType {
9109 match self {
9110 Self::None => ffi::GTK_REVEALER_TRANSITION_TYPE_NONE,
9111 Self::Crossfade => ffi::GTK_REVEALER_TRANSITION_TYPE_CROSSFADE,
9112 Self::SlideRight => ffi::GTK_REVEALER_TRANSITION_TYPE_SLIDE_RIGHT,
9113 Self::SlideLeft => ffi::GTK_REVEALER_TRANSITION_TYPE_SLIDE_LEFT,
9114 Self::SlideUp => ffi::GTK_REVEALER_TRANSITION_TYPE_SLIDE_UP,
9115 Self::SlideDown => ffi::GTK_REVEALER_TRANSITION_TYPE_SLIDE_DOWN,
9116 Self::SwingRight => ffi::GTK_REVEALER_TRANSITION_TYPE_SWING_RIGHT,
9117 Self::SwingLeft => ffi::GTK_REVEALER_TRANSITION_TYPE_SWING_LEFT,
9118 Self::SwingUp => ffi::GTK_REVEALER_TRANSITION_TYPE_SWING_UP,
9119 Self::SwingDown => ffi::GTK_REVEALER_TRANSITION_TYPE_SWING_DOWN,
9120 Self::__Unknown(value) => value,
9121 }
9122 }
9123}
9124
9125#[doc(hidden)]
9126impl FromGlib<ffi::GtkRevealerTransitionType> for RevealerTransitionType {
9127 #[inline]
9128 unsafe fn from_glib(value: ffi::GtkRevealerTransitionType) -> Self {
9129 skip_assert_initialized!();
9130
9131 match value {
9132 ffi::GTK_REVEALER_TRANSITION_TYPE_NONE => Self::None,
9133 ffi::GTK_REVEALER_TRANSITION_TYPE_CROSSFADE => Self::Crossfade,
9134 ffi::GTK_REVEALER_TRANSITION_TYPE_SLIDE_RIGHT => Self::SlideRight,
9135 ffi::GTK_REVEALER_TRANSITION_TYPE_SLIDE_LEFT => Self::SlideLeft,
9136 ffi::GTK_REVEALER_TRANSITION_TYPE_SLIDE_UP => Self::SlideUp,
9137 ffi::GTK_REVEALER_TRANSITION_TYPE_SLIDE_DOWN => Self::SlideDown,
9138 ffi::GTK_REVEALER_TRANSITION_TYPE_SWING_RIGHT => Self::SwingRight,
9139 ffi::GTK_REVEALER_TRANSITION_TYPE_SWING_LEFT => Self::SwingLeft,
9140 ffi::GTK_REVEALER_TRANSITION_TYPE_SWING_UP => Self::SwingUp,
9141 ffi::GTK_REVEALER_TRANSITION_TYPE_SWING_DOWN => Self::SwingDown,
9142 value => Self::__Unknown(value),
9143 }
9144 }
9145}
9146
9147impl StaticType for RevealerTransitionType {
9148 #[inline]
9149 #[doc(alias = "gtk_revealer_transition_type_get_type")]
9150 fn static_type() -> glib::Type {
9151 unsafe { from_glib(ffi::gtk_revealer_transition_type_get_type()) }
9152 }
9153}
9154
9155impl glib::HasParamSpec for RevealerTransitionType {
9156 type ParamSpec = glib::ParamSpecEnum;
9157 type SetValue = Self;
9158 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
9159
9160 fn param_spec_builder() -> Self::BuilderFn {
9161 Self::ParamSpec::builder_with_default
9162 }
9163}
9164
9165impl glib::value::ValueType for RevealerTransitionType {
9166 type Type = Self;
9167}
9168
9169unsafe impl<'a> glib::value::FromValue<'a> for RevealerTransitionType {
9170 type Checker = glib::value::GenericValueTypeChecker<Self>;
9171
9172 #[inline]
9173 unsafe fn from_value(value: &'a glib::Value) -> Self {
9174 skip_assert_initialized!();
9175 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
9176 }
9177}
9178
9179impl ToValue for RevealerTransitionType {
9180 #[inline]
9181 fn to_value(&self) -> glib::Value {
9182 let mut value = glib::Value::for_value_type::<Self>();
9183 unsafe {
9184 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
9185 }
9186 value
9187 }
9188
9189 #[inline]
9190 fn value_type(&self) -> glib::Type {
9191 Self::static_type()
9192 }
9193}
9194
9195impl From<RevealerTransitionType> for glib::Value {
9196 #[inline]
9197 fn from(v: RevealerTransitionType) -> Self {
9198 skip_assert_initialized!();
9199 ToValue::to_value(&v)
9200 }
9201}
9202
9203#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
9204#[non_exhaustive]
9205#[doc(alias = "GtkScrollStep")]
9206pub enum ScrollStep {
9207 #[doc(alias = "GTK_SCROLL_STEPS")]
9208 Steps,
9209 #[doc(alias = "GTK_SCROLL_PAGES")]
9210 Pages,
9211 #[doc(alias = "GTK_SCROLL_ENDS")]
9212 Ends,
9213 #[doc(alias = "GTK_SCROLL_HORIZONTAL_STEPS")]
9214 HorizontalSteps,
9215 #[doc(alias = "GTK_SCROLL_HORIZONTAL_PAGES")]
9216 HorizontalPages,
9217 #[doc(alias = "GTK_SCROLL_HORIZONTAL_ENDS")]
9218 HorizontalEnds,
9219 #[doc(hidden)]
9220 __Unknown(i32),
9221}
9222
9223#[doc(hidden)]
9224impl IntoGlib for ScrollStep {
9225 type GlibType = ffi::GtkScrollStep;
9226
9227 #[inline]
9228 fn into_glib(self) -> ffi::GtkScrollStep {
9229 match self {
9230 Self::Steps => ffi::GTK_SCROLL_STEPS,
9231 Self::Pages => ffi::GTK_SCROLL_PAGES,
9232 Self::Ends => ffi::GTK_SCROLL_ENDS,
9233 Self::HorizontalSteps => ffi::GTK_SCROLL_HORIZONTAL_STEPS,
9234 Self::HorizontalPages => ffi::GTK_SCROLL_HORIZONTAL_PAGES,
9235 Self::HorizontalEnds => ffi::GTK_SCROLL_HORIZONTAL_ENDS,
9236 Self::__Unknown(value) => value,
9237 }
9238 }
9239}
9240
9241#[doc(hidden)]
9242impl FromGlib<ffi::GtkScrollStep> for ScrollStep {
9243 #[inline]
9244 unsafe fn from_glib(value: ffi::GtkScrollStep) -> Self {
9245 skip_assert_initialized!();
9246
9247 match value {
9248 ffi::GTK_SCROLL_STEPS => Self::Steps,
9249 ffi::GTK_SCROLL_PAGES => Self::Pages,
9250 ffi::GTK_SCROLL_ENDS => Self::Ends,
9251 ffi::GTK_SCROLL_HORIZONTAL_STEPS => Self::HorizontalSteps,
9252 ffi::GTK_SCROLL_HORIZONTAL_PAGES => Self::HorizontalPages,
9253 ffi::GTK_SCROLL_HORIZONTAL_ENDS => Self::HorizontalEnds,
9254 value => Self::__Unknown(value),
9255 }
9256 }
9257}
9258
9259impl StaticType for ScrollStep {
9260 #[inline]
9261 #[doc(alias = "gtk_scroll_step_get_type")]
9262 fn static_type() -> glib::Type {
9263 unsafe { from_glib(ffi::gtk_scroll_step_get_type()) }
9264 }
9265}
9266
9267impl glib::HasParamSpec for ScrollStep {
9268 type ParamSpec = glib::ParamSpecEnum;
9269 type SetValue = Self;
9270 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
9271
9272 fn param_spec_builder() -> Self::BuilderFn {
9273 Self::ParamSpec::builder_with_default
9274 }
9275}
9276
9277impl glib::value::ValueType for ScrollStep {
9278 type Type = Self;
9279}
9280
9281unsafe impl<'a> glib::value::FromValue<'a> for ScrollStep {
9282 type Checker = glib::value::GenericValueTypeChecker<Self>;
9283
9284 #[inline]
9285 unsafe fn from_value(value: &'a glib::Value) -> Self {
9286 skip_assert_initialized!();
9287 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
9288 }
9289}
9290
9291impl ToValue for ScrollStep {
9292 #[inline]
9293 fn to_value(&self) -> glib::Value {
9294 let mut value = glib::Value::for_value_type::<Self>();
9295 unsafe {
9296 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
9297 }
9298 value
9299 }
9300
9301 #[inline]
9302 fn value_type(&self) -> glib::Type {
9303 Self::static_type()
9304 }
9305}
9306
9307impl From<ScrollStep> for glib::Value {
9308 #[inline]
9309 fn from(v: ScrollStep) -> Self {
9310 skip_assert_initialized!();
9311 ToValue::to_value(&v)
9312 }
9313}
9314
9315#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
9316#[non_exhaustive]
9317#[doc(alias = "GtkScrollType")]
9318pub enum ScrollType {
9319 #[doc(alias = "GTK_SCROLL_NONE")]
9320 None,
9321 #[doc(alias = "GTK_SCROLL_JUMP")]
9322 Jump,
9323 #[doc(alias = "GTK_SCROLL_STEP_BACKWARD")]
9324 StepBackward,
9325 #[doc(alias = "GTK_SCROLL_STEP_FORWARD")]
9326 StepForward,
9327 #[doc(alias = "GTK_SCROLL_PAGE_BACKWARD")]
9328 PageBackward,
9329 #[doc(alias = "GTK_SCROLL_PAGE_FORWARD")]
9330 PageForward,
9331 #[doc(alias = "GTK_SCROLL_STEP_UP")]
9332 StepUp,
9333 #[doc(alias = "GTK_SCROLL_STEP_DOWN")]
9334 StepDown,
9335 #[doc(alias = "GTK_SCROLL_PAGE_UP")]
9336 PageUp,
9337 #[doc(alias = "GTK_SCROLL_PAGE_DOWN")]
9338 PageDown,
9339 #[doc(alias = "GTK_SCROLL_STEP_LEFT")]
9340 StepLeft,
9341 #[doc(alias = "GTK_SCROLL_STEP_RIGHT")]
9342 StepRight,
9343 #[doc(alias = "GTK_SCROLL_PAGE_LEFT")]
9344 PageLeft,
9345 #[doc(alias = "GTK_SCROLL_PAGE_RIGHT")]
9346 PageRight,
9347 #[doc(alias = "GTK_SCROLL_START")]
9348 Start,
9349 #[doc(alias = "GTK_SCROLL_END")]
9350 End,
9351 #[doc(hidden)]
9352 __Unknown(i32),
9353}
9354
9355#[doc(hidden)]
9356impl IntoGlib for ScrollType {
9357 type GlibType = ffi::GtkScrollType;
9358
9359 fn into_glib(self) -> ffi::GtkScrollType {
9360 match self {
9361 Self::None => ffi::GTK_SCROLL_NONE,
9362 Self::Jump => ffi::GTK_SCROLL_JUMP,
9363 Self::StepBackward => ffi::GTK_SCROLL_STEP_BACKWARD,
9364 Self::StepForward => ffi::GTK_SCROLL_STEP_FORWARD,
9365 Self::PageBackward => ffi::GTK_SCROLL_PAGE_BACKWARD,
9366 Self::PageForward => ffi::GTK_SCROLL_PAGE_FORWARD,
9367 Self::StepUp => ffi::GTK_SCROLL_STEP_UP,
9368 Self::StepDown => ffi::GTK_SCROLL_STEP_DOWN,
9369 Self::PageUp => ffi::GTK_SCROLL_PAGE_UP,
9370 Self::PageDown => ffi::GTK_SCROLL_PAGE_DOWN,
9371 Self::StepLeft => ffi::GTK_SCROLL_STEP_LEFT,
9372 Self::StepRight => ffi::GTK_SCROLL_STEP_RIGHT,
9373 Self::PageLeft => ffi::GTK_SCROLL_PAGE_LEFT,
9374 Self::PageRight => ffi::GTK_SCROLL_PAGE_RIGHT,
9375 Self::Start => ffi::GTK_SCROLL_START,
9376 Self::End => ffi::GTK_SCROLL_END,
9377 Self::__Unknown(value) => value,
9378 }
9379 }
9380}
9381
9382#[doc(hidden)]
9383impl FromGlib<ffi::GtkScrollType> for ScrollType {
9384 unsafe fn from_glib(value: ffi::GtkScrollType) -> Self {
9385 skip_assert_initialized!();
9386
9387 match value {
9388 ffi::GTK_SCROLL_NONE => Self::None,
9389 ffi::GTK_SCROLL_JUMP => Self::Jump,
9390 ffi::GTK_SCROLL_STEP_BACKWARD => Self::StepBackward,
9391 ffi::GTK_SCROLL_STEP_FORWARD => Self::StepForward,
9392 ffi::GTK_SCROLL_PAGE_BACKWARD => Self::PageBackward,
9393 ffi::GTK_SCROLL_PAGE_FORWARD => Self::PageForward,
9394 ffi::GTK_SCROLL_STEP_UP => Self::StepUp,
9395 ffi::GTK_SCROLL_STEP_DOWN => Self::StepDown,
9396 ffi::GTK_SCROLL_PAGE_UP => Self::PageUp,
9397 ffi::GTK_SCROLL_PAGE_DOWN => Self::PageDown,
9398 ffi::GTK_SCROLL_STEP_LEFT => Self::StepLeft,
9399 ffi::GTK_SCROLL_STEP_RIGHT => Self::StepRight,
9400 ffi::GTK_SCROLL_PAGE_LEFT => Self::PageLeft,
9401 ffi::GTK_SCROLL_PAGE_RIGHT => Self::PageRight,
9402 ffi::GTK_SCROLL_START => Self::Start,
9403 ffi::GTK_SCROLL_END => Self::End,
9404 value => Self::__Unknown(value),
9405 }
9406 }
9407}
9408
9409impl StaticType for ScrollType {
9410 #[inline]
9411 #[doc(alias = "gtk_scroll_type_get_type")]
9412 fn static_type() -> glib::Type {
9413 unsafe { from_glib(ffi::gtk_scroll_type_get_type()) }
9414 }
9415}
9416
9417impl glib::HasParamSpec for ScrollType {
9418 type ParamSpec = glib::ParamSpecEnum;
9419 type SetValue = Self;
9420 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
9421
9422 fn param_spec_builder() -> Self::BuilderFn {
9423 Self::ParamSpec::builder_with_default
9424 }
9425}
9426
9427impl glib::value::ValueType for ScrollType {
9428 type Type = Self;
9429}
9430
9431unsafe impl<'a> glib::value::FromValue<'a> for ScrollType {
9432 type Checker = glib::value::GenericValueTypeChecker<Self>;
9433
9434 #[inline]
9435 unsafe fn from_value(value: &'a glib::Value) -> Self {
9436 skip_assert_initialized!();
9437 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
9438 }
9439}
9440
9441impl ToValue for ScrollType {
9442 #[inline]
9443 fn to_value(&self) -> glib::Value {
9444 let mut value = glib::Value::for_value_type::<Self>();
9445 unsafe {
9446 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
9447 }
9448 value
9449 }
9450
9451 #[inline]
9452 fn value_type(&self) -> glib::Type {
9453 Self::static_type()
9454 }
9455}
9456
9457impl From<ScrollType> for glib::Value {
9458 #[inline]
9459 fn from(v: ScrollType) -> Self {
9460 skip_assert_initialized!();
9461 ToValue::to_value(&v)
9462 }
9463}
9464
9465#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
9466#[non_exhaustive]
9467#[doc(alias = "GtkScrollablePolicy")]
9468pub enum ScrollablePolicy {
9469 #[doc(alias = "GTK_SCROLL_MINIMUM")]
9470 Minimum,
9471 #[doc(alias = "GTK_SCROLL_NATURAL")]
9472 Natural,
9473 #[doc(hidden)]
9474 __Unknown(i32),
9475}
9476
9477#[doc(hidden)]
9478impl IntoGlib for ScrollablePolicy {
9479 type GlibType = ffi::GtkScrollablePolicy;
9480
9481 #[inline]
9482 fn into_glib(self) -> ffi::GtkScrollablePolicy {
9483 match self {
9484 Self::Minimum => ffi::GTK_SCROLL_MINIMUM,
9485 Self::Natural => ffi::GTK_SCROLL_NATURAL,
9486 Self::__Unknown(value) => value,
9487 }
9488 }
9489}
9490
9491#[doc(hidden)]
9492impl FromGlib<ffi::GtkScrollablePolicy> for ScrollablePolicy {
9493 #[inline]
9494 unsafe fn from_glib(value: ffi::GtkScrollablePolicy) -> Self {
9495 skip_assert_initialized!();
9496
9497 match value {
9498 ffi::GTK_SCROLL_MINIMUM => Self::Minimum,
9499 ffi::GTK_SCROLL_NATURAL => Self::Natural,
9500 value => Self::__Unknown(value),
9501 }
9502 }
9503}
9504
9505impl StaticType for ScrollablePolicy {
9506 #[inline]
9507 #[doc(alias = "gtk_scrollable_policy_get_type")]
9508 fn static_type() -> glib::Type {
9509 unsafe { from_glib(ffi::gtk_scrollable_policy_get_type()) }
9510 }
9511}
9512
9513impl glib::HasParamSpec for ScrollablePolicy {
9514 type ParamSpec = glib::ParamSpecEnum;
9515 type SetValue = Self;
9516 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
9517
9518 fn param_spec_builder() -> Self::BuilderFn {
9519 Self::ParamSpec::builder_with_default
9520 }
9521}
9522
9523impl glib::value::ValueType for ScrollablePolicy {
9524 type Type = Self;
9525}
9526
9527unsafe impl<'a> glib::value::FromValue<'a> for ScrollablePolicy {
9528 type Checker = glib::value::GenericValueTypeChecker<Self>;
9529
9530 #[inline]
9531 unsafe fn from_value(value: &'a glib::Value) -> Self {
9532 skip_assert_initialized!();
9533 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
9534 }
9535}
9536
9537impl ToValue for ScrollablePolicy {
9538 #[inline]
9539 fn to_value(&self) -> glib::Value {
9540 let mut value = glib::Value::for_value_type::<Self>();
9541 unsafe {
9542 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
9543 }
9544 value
9545 }
9546
9547 #[inline]
9548 fn value_type(&self) -> glib::Type {
9549 Self::static_type()
9550 }
9551}
9552
9553impl From<ScrollablePolicy> for glib::Value {
9554 #[inline]
9555 fn from(v: ScrollablePolicy) -> Self {
9556 skip_assert_initialized!();
9557 ToValue::to_value(&v)
9558 }
9559}
9560
9561#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
9562#[non_exhaustive]
9563#[doc(alias = "GtkSelectionMode")]
9564pub enum SelectionMode {
9565 #[doc(alias = "GTK_SELECTION_NONE")]
9566 None,
9567 #[doc(alias = "GTK_SELECTION_SINGLE")]
9568 Single,
9569 #[doc(alias = "GTK_SELECTION_BROWSE")]
9570 Browse,
9571 #[doc(alias = "GTK_SELECTION_MULTIPLE")]
9572 Multiple,
9573 #[doc(hidden)]
9574 __Unknown(i32),
9575}
9576
9577#[doc(hidden)]
9578impl IntoGlib for SelectionMode {
9579 type GlibType = ffi::GtkSelectionMode;
9580
9581 #[inline]
9582 fn into_glib(self) -> ffi::GtkSelectionMode {
9583 match self {
9584 Self::None => ffi::GTK_SELECTION_NONE,
9585 Self::Single => ffi::GTK_SELECTION_SINGLE,
9586 Self::Browse => ffi::GTK_SELECTION_BROWSE,
9587 Self::Multiple => ffi::GTK_SELECTION_MULTIPLE,
9588 Self::__Unknown(value) => value,
9589 }
9590 }
9591}
9592
9593#[doc(hidden)]
9594impl FromGlib<ffi::GtkSelectionMode> for SelectionMode {
9595 #[inline]
9596 unsafe fn from_glib(value: ffi::GtkSelectionMode) -> Self {
9597 skip_assert_initialized!();
9598
9599 match value {
9600 ffi::GTK_SELECTION_NONE => Self::None,
9601 ffi::GTK_SELECTION_SINGLE => Self::Single,
9602 ffi::GTK_SELECTION_BROWSE => Self::Browse,
9603 ffi::GTK_SELECTION_MULTIPLE => Self::Multiple,
9604 value => Self::__Unknown(value),
9605 }
9606 }
9607}
9608
9609impl StaticType for SelectionMode {
9610 #[inline]
9611 #[doc(alias = "gtk_selection_mode_get_type")]
9612 fn static_type() -> glib::Type {
9613 unsafe { from_glib(ffi::gtk_selection_mode_get_type()) }
9614 }
9615}
9616
9617impl glib::HasParamSpec for SelectionMode {
9618 type ParamSpec = glib::ParamSpecEnum;
9619 type SetValue = Self;
9620 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
9621
9622 fn param_spec_builder() -> Self::BuilderFn {
9623 Self::ParamSpec::builder_with_default
9624 }
9625}
9626
9627impl glib::value::ValueType for SelectionMode {
9628 type Type = Self;
9629}
9630
9631unsafe impl<'a> glib::value::FromValue<'a> for SelectionMode {
9632 type Checker = glib::value::GenericValueTypeChecker<Self>;
9633
9634 #[inline]
9635 unsafe fn from_value(value: &'a glib::Value) -> Self {
9636 skip_assert_initialized!();
9637 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
9638 }
9639}
9640
9641impl ToValue for SelectionMode {
9642 #[inline]
9643 fn to_value(&self) -> glib::Value {
9644 let mut value = glib::Value::for_value_type::<Self>();
9645 unsafe {
9646 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
9647 }
9648 value
9649 }
9650
9651 #[inline]
9652 fn value_type(&self) -> glib::Type {
9653 Self::static_type()
9654 }
9655}
9656
9657impl From<SelectionMode> for glib::Value {
9658 #[inline]
9659 fn from(v: SelectionMode) -> Self {
9660 skip_assert_initialized!();
9661 ToValue::to_value(&v)
9662 }
9663}
9664
9665#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
9666#[non_exhaustive]
9667#[doc(alias = "GtkSensitivityType")]
9668pub enum SensitivityType {
9669 #[doc(alias = "GTK_SENSITIVITY_AUTO")]
9670 Auto,
9671 #[doc(alias = "GTK_SENSITIVITY_ON")]
9672 On,
9673 #[doc(alias = "GTK_SENSITIVITY_OFF")]
9674 Off,
9675 #[doc(hidden)]
9676 __Unknown(i32),
9677}
9678
9679#[doc(hidden)]
9680impl IntoGlib for SensitivityType {
9681 type GlibType = ffi::GtkSensitivityType;
9682
9683 #[inline]
9684 fn into_glib(self) -> ffi::GtkSensitivityType {
9685 match self {
9686 Self::Auto => ffi::GTK_SENSITIVITY_AUTO,
9687 Self::On => ffi::GTK_SENSITIVITY_ON,
9688 Self::Off => ffi::GTK_SENSITIVITY_OFF,
9689 Self::__Unknown(value) => value,
9690 }
9691 }
9692}
9693
9694#[doc(hidden)]
9695impl FromGlib<ffi::GtkSensitivityType> for SensitivityType {
9696 #[inline]
9697 unsafe fn from_glib(value: ffi::GtkSensitivityType) -> Self {
9698 skip_assert_initialized!();
9699
9700 match value {
9701 ffi::GTK_SENSITIVITY_AUTO => Self::Auto,
9702 ffi::GTK_SENSITIVITY_ON => Self::On,
9703 ffi::GTK_SENSITIVITY_OFF => Self::Off,
9704 value => Self::__Unknown(value),
9705 }
9706 }
9707}
9708
9709impl StaticType for SensitivityType {
9710 #[inline]
9711 #[doc(alias = "gtk_sensitivity_type_get_type")]
9712 fn static_type() -> glib::Type {
9713 unsafe { from_glib(ffi::gtk_sensitivity_type_get_type()) }
9714 }
9715}
9716
9717impl glib::HasParamSpec for SensitivityType {
9718 type ParamSpec = glib::ParamSpecEnum;
9719 type SetValue = Self;
9720 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
9721
9722 fn param_spec_builder() -> Self::BuilderFn {
9723 Self::ParamSpec::builder_with_default
9724 }
9725}
9726
9727impl glib::value::ValueType for SensitivityType {
9728 type Type = Self;
9729}
9730
9731unsafe impl<'a> glib::value::FromValue<'a> for SensitivityType {
9732 type Checker = glib::value::GenericValueTypeChecker<Self>;
9733
9734 #[inline]
9735 unsafe fn from_value(value: &'a glib::Value) -> Self {
9736 skip_assert_initialized!();
9737 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
9738 }
9739}
9740
9741impl ToValue for SensitivityType {
9742 #[inline]
9743 fn to_value(&self) -> glib::Value {
9744 let mut value = glib::Value::for_value_type::<Self>();
9745 unsafe {
9746 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
9747 }
9748 value
9749 }
9750
9751 #[inline]
9752 fn value_type(&self) -> glib::Type {
9753 Self::static_type()
9754 }
9755}
9756
9757impl From<SensitivityType> for glib::Value {
9758 #[inline]
9759 fn from(v: SensitivityType) -> Self {
9760 skip_assert_initialized!();
9761 ToValue::to_value(&v)
9762 }
9763}
9764
9765#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
9766#[non_exhaustive]
9767#[doc(alias = "GtkShortcutScope")]
9768pub enum ShortcutScope {
9769 #[doc(alias = "GTK_SHORTCUT_SCOPE_LOCAL")]
9770 Local,
9771 #[doc(alias = "GTK_SHORTCUT_SCOPE_MANAGED")]
9772 Managed,
9773 #[doc(alias = "GTK_SHORTCUT_SCOPE_GLOBAL")]
9774 Global,
9775 #[doc(hidden)]
9776 __Unknown(i32),
9777}
9778
9779#[doc(hidden)]
9780impl IntoGlib for ShortcutScope {
9781 type GlibType = ffi::GtkShortcutScope;
9782
9783 #[inline]
9784 fn into_glib(self) -> ffi::GtkShortcutScope {
9785 match self {
9786 Self::Local => ffi::GTK_SHORTCUT_SCOPE_LOCAL,
9787 Self::Managed => ffi::GTK_SHORTCUT_SCOPE_MANAGED,
9788 Self::Global => ffi::GTK_SHORTCUT_SCOPE_GLOBAL,
9789 Self::__Unknown(value) => value,
9790 }
9791 }
9792}
9793
9794#[doc(hidden)]
9795impl FromGlib<ffi::GtkShortcutScope> for ShortcutScope {
9796 #[inline]
9797 unsafe fn from_glib(value: ffi::GtkShortcutScope) -> Self {
9798 skip_assert_initialized!();
9799
9800 match value {
9801 ffi::GTK_SHORTCUT_SCOPE_LOCAL => Self::Local,
9802 ffi::GTK_SHORTCUT_SCOPE_MANAGED => Self::Managed,
9803 ffi::GTK_SHORTCUT_SCOPE_GLOBAL => Self::Global,
9804 value => Self::__Unknown(value),
9805 }
9806 }
9807}
9808
9809impl StaticType for ShortcutScope {
9810 #[inline]
9811 #[doc(alias = "gtk_shortcut_scope_get_type")]
9812 fn static_type() -> glib::Type {
9813 unsafe { from_glib(ffi::gtk_shortcut_scope_get_type()) }
9814 }
9815}
9816
9817impl glib::HasParamSpec for ShortcutScope {
9818 type ParamSpec = glib::ParamSpecEnum;
9819 type SetValue = Self;
9820 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
9821
9822 fn param_spec_builder() -> Self::BuilderFn {
9823 Self::ParamSpec::builder_with_default
9824 }
9825}
9826
9827impl glib::value::ValueType for ShortcutScope {
9828 type Type = Self;
9829}
9830
9831unsafe impl<'a> glib::value::FromValue<'a> for ShortcutScope {
9832 type Checker = glib::value::GenericValueTypeChecker<Self>;
9833
9834 #[inline]
9835 unsafe fn from_value(value: &'a glib::Value) -> Self {
9836 skip_assert_initialized!();
9837 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
9838 }
9839}
9840
9841impl ToValue for ShortcutScope {
9842 #[inline]
9843 fn to_value(&self) -> glib::Value {
9844 let mut value = glib::Value::for_value_type::<Self>();
9845 unsafe {
9846 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
9847 }
9848 value
9849 }
9850
9851 #[inline]
9852 fn value_type(&self) -> glib::Type {
9853 Self::static_type()
9854 }
9855}
9856
9857impl From<ShortcutScope> for glib::Value {
9858 #[inline]
9859 fn from(v: ShortcutScope) -> Self {
9860 skip_assert_initialized!();
9861 ToValue::to_value(&v)
9862 }
9863}
9864
9865#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
9866#[non_exhaustive]
9867#[doc(alias = "GtkShortcutType")]
9868pub enum ShortcutType {
9869 #[doc(alias = "GTK_SHORTCUT_ACCELERATOR")]
9870 Accelerator,
9871 #[doc(alias = "GTK_SHORTCUT_GESTURE_PINCH")]
9872 GesturePinch,
9873 #[doc(alias = "GTK_SHORTCUT_GESTURE_STRETCH")]
9874 GestureStretch,
9875 #[doc(alias = "GTK_SHORTCUT_GESTURE_ROTATE_CLOCKWISE")]
9876 GestureRotateClockwise,
9877 #[doc(alias = "GTK_SHORTCUT_GESTURE_ROTATE_COUNTERCLOCKWISE")]
9878 GestureRotateCounterclockwise,
9879 #[doc(alias = "GTK_SHORTCUT_GESTURE_TWO_FINGER_SWIPE_LEFT")]
9880 GestureTwoFingerSwipeLeft,
9881 #[doc(alias = "GTK_SHORTCUT_GESTURE_TWO_FINGER_SWIPE_RIGHT")]
9882 GestureTwoFingerSwipeRight,
9883 #[doc(alias = "GTK_SHORTCUT_GESTURE")]
9884 Gesture,
9885 #[doc(alias = "GTK_SHORTCUT_GESTURE_SWIPE_LEFT")]
9886 GestureSwipeLeft,
9887 #[doc(alias = "GTK_SHORTCUT_GESTURE_SWIPE_RIGHT")]
9888 GestureSwipeRight,
9889 #[doc(hidden)]
9890 __Unknown(i32),
9891}
9892
9893#[doc(hidden)]
9894impl IntoGlib for ShortcutType {
9895 type GlibType = ffi::GtkShortcutType;
9896
9897 #[inline]
9898 fn into_glib(self) -> ffi::GtkShortcutType {
9899 match self {
9900 Self::Accelerator => ffi::GTK_SHORTCUT_ACCELERATOR,
9901 Self::GesturePinch => ffi::GTK_SHORTCUT_GESTURE_PINCH,
9902 Self::GestureStretch => ffi::GTK_SHORTCUT_GESTURE_STRETCH,
9903 Self::GestureRotateClockwise => ffi::GTK_SHORTCUT_GESTURE_ROTATE_CLOCKWISE,
9904 Self::GestureRotateCounterclockwise => {
9905 ffi::GTK_SHORTCUT_GESTURE_ROTATE_COUNTERCLOCKWISE
9906 }
9907 Self::GestureTwoFingerSwipeLeft => ffi::GTK_SHORTCUT_GESTURE_TWO_FINGER_SWIPE_LEFT,
9908 Self::GestureTwoFingerSwipeRight => ffi::GTK_SHORTCUT_GESTURE_TWO_FINGER_SWIPE_RIGHT,
9909 Self::Gesture => ffi::GTK_SHORTCUT_GESTURE,
9910 Self::GestureSwipeLeft => ffi::GTK_SHORTCUT_GESTURE_SWIPE_LEFT,
9911 Self::GestureSwipeRight => ffi::GTK_SHORTCUT_GESTURE_SWIPE_RIGHT,
9912 Self::__Unknown(value) => value,
9913 }
9914 }
9915}
9916
9917#[doc(hidden)]
9918impl FromGlib<ffi::GtkShortcutType> for ShortcutType {
9919 #[inline]
9920 unsafe fn from_glib(value: ffi::GtkShortcutType) -> Self {
9921 skip_assert_initialized!();
9922
9923 match value {
9924 ffi::GTK_SHORTCUT_ACCELERATOR => Self::Accelerator,
9925 ffi::GTK_SHORTCUT_GESTURE_PINCH => Self::GesturePinch,
9926 ffi::GTK_SHORTCUT_GESTURE_STRETCH => Self::GestureStretch,
9927 ffi::GTK_SHORTCUT_GESTURE_ROTATE_CLOCKWISE => Self::GestureRotateClockwise,
9928 ffi::GTK_SHORTCUT_GESTURE_ROTATE_COUNTERCLOCKWISE => {
9929 Self::GestureRotateCounterclockwise
9930 }
9931 ffi::GTK_SHORTCUT_GESTURE_TWO_FINGER_SWIPE_LEFT => Self::GestureTwoFingerSwipeLeft,
9932 ffi::GTK_SHORTCUT_GESTURE_TWO_FINGER_SWIPE_RIGHT => Self::GestureTwoFingerSwipeRight,
9933 ffi::GTK_SHORTCUT_GESTURE => Self::Gesture,
9934 ffi::GTK_SHORTCUT_GESTURE_SWIPE_LEFT => Self::GestureSwipeLeft,
9935 ffi::GTK_SHORTCUT_GESTURE_SWIPE_RIGHT => Self::GestureSwipeRight,
9936 value => Self::__Unknown(value),
9937 }
9938 }
9939}
9940
9941impl StaticType for ShortcutType {
9942 #[inline]
9943 #[doc(alias = "gtk_shortcut_type_get_type")]
9944 fn static_type() -> glib::Type {
9945 unsafe { from_glib(ffi::gtk_shortcut_type_get_type()) }
9946 }
9947}
9948
9949impl glib::HasParamSpec for ShortcutType {
9950 type ParamSpec = glib::ParamSpecEnum;
9951 type SetValue = Self;
9952 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
9953
9954 fn param_spec_builder() -> Self::BuilderFn {
9955 Self::ParamSpec::builder_with_default
9956 }
9957}
9958
9959impl glib::value::ValueType for ShortcutType {
9960 type Type = Self;
9961}
9962
9963unsafe impl<'a> glib::value::FromValue<'a> for ShortcutType {
9964 type Checker = glib::value::GenericValueTypeChecker<Self>;
9965
9966 #[inline]
9967 unsafe fn from_value(value: &'a glib::Value) -> Self {
9968 skip_assert_initialized!();
9969 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
9970 }
9971}
9972
9973impl ToValue for ShortcutType {
9974 #[inline]
9975 fn to_value(&self) -> glib::Value {
9976 let mut value = glib::Value::for_value_type::<Self>();
9977 unsafe {
9978 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
9979 }
9980 value
9981 }
9982
9983 #[inline]
9984 fn value_type(&self) -> glib::Type {
9985 Self::static_type()
9986 }
9987}
9988
9989impl From<ShortcutType> for glib::Value {
9990 #[inline]
9991 fn from(v: ShortcutType) -> Self {
9992 skip_assert_initialized!();
9993 ToValue::to_value(&v)
9994 }
9995}
9996
9997#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
9998#[non_exhaustive]
9999#[doc(alias = "GtkSizeGroupMode")]
10000pub enum SizeGroupMode {
10001 #[doc(alias = "GTK_SIZE_GROUP_NONE")]
10002 None,
10003 #[doc(alias = "GTK_SIZE_GROUP_HORIZONTAL")]
10004 Horizontal,
10005 #[doc(alias = "GTK_SIZE_GROUP_VERTICAL")]
10006 Vertical,
10007 #[doc(alias = "GTK_SIZE_GROUP_BOTH")]
10008 Both,
10009 #[doc(hidden)]
10010 __Unknown(i32),
10011}
10012
10013#[doc(hidden)]
10014impl IntoGlib for SizeGroupMode {
10015 type GlibType = ffi::GtkSizeGroupMode;
10016
10017 #[inline]
10018 fn into_glib(self) -> ffi::GtkSizeGroupMode {
10019 match self {
10020 Self::None => ffi::GTK_SIZE_GROUP_NONE,
10021 Self::Horizontal => ffi::GTK_SIZE_GROUP_HORIZONTAL,
10022 Self::Vertical => ffi::GTK_SIZE_GROUP_VERTICAL,
10023 Self::Both => ffi::GTK_SIZE_GROUP_BOTH,
10024 Self::__Unknown(value) => value,
10025 }
10026 }
10027}
10028
10029#[doc(hidden)]
10030impl FromGlib<ffi::GtkSizeGroupMode> for SizeGroupMode {
10031 #[inline]
10032 unsafe fn from_glib(value: ffi::GtkSizeGroupMode) -> Self {
10033 skip_assert_initialized!();
10034
10035 match value {
10036 ffi::GTK_SIZE_GROUP_NONE => Self::None,
10037 ffi::GTK_SIZE_GROUP_HORIZONTAL => Self::Horizontal,
10038 ffi::GTK_SIZE_GROUP_VERTICAL => Self::Vertical,
10039 ffi::GTK_SIZE_GROUP_BOTH => Self::Both,
10040 value => Self::__Unknown(value),
10041 }
10042 }
10043}
10044
10045impl StaticType for SizeGroupMode {
10046 #[inline]
10047 #[doc(alias = "gtk_size_group_mode_get_type")]
10048 fn static_type() -> glib::Type {
10049 unsafe { from_glib(ffi::gtk_size_group_mode_get_type()) }
10050 }
10051}
10052
10053impl glib::HasParamSpec for SizeGroupMode {
10054 type ParamSpec = glib::ParamSpecEnum;
10055 type SetValue = Self;
10056 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
10057
10058 fn param_spec_builder() -> Self::BuilderFn {
10059 Self::ParamSpec::builder_with_default
10060 }
10061}
10062
10063impl glib::value::ValueType for SizeGroupMode {
10064 type Type = Self;
10065}
10066
10067unsafe impl<'a> glib::value::FromValue<'a> for SizeGroupMode {
10068 type Checker = glib::value::GenericValueTypeChecker<Self>;
10069
10070 #[inline]
10071 unsafe fn from_value(value: &'a glib::Value) -> Self {
10072 skip_assert_initialized!();
10073 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
10074 }
10075}
10076
10077impl ToValue for SizeGroupMode {
10078 #[inline]
10079 fn to_value(&self) -> glib::Value {
10080 let mut value = glib::Value::for_value_type::<Self>();
10081 unsafe {
10082 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
10083 }
10084 value
10085 }
10086
10087 #[inline]
10088 fn value_type(&self) -> glib::Type {
10089 Self::static_type()
10090 }
10091}
10092
10093impl From<SizeGroupMode> for glib::Value {
10094 #[inline]
10095 fn from(v: SizeGroupMode) -> Self {
10096 skip_assert_initialized!();
10097 ToValue::to_value(&v)
10098 }
10099}
10100
10101#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
10102#[non_exhaustive]
10103#[doc(alias = "GtkSizeRequestMode")]
10104pub enum SizeRequestMode {
10105 #[doc(alias = "GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH")]
10106 HeightForWidth,
10107 #[doc(alias = "GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT")]
10108 WidthForHeight,
10109 #[doc(alias = "GTK_SIZE_REQUEST_CONSTANT_SIZE")]
10110 ConstantSize,
10111 #[doc(hidden)]
10112 __Unknown(i32),
10113}
10114
10115#[doc(hidden)]
10116impl IntoGlib for SizeRequestMode {
10117 type GlibType = ffi::GtkSizeRequestMode;
10118
10119 #[inline]
10120 fn into_glib(self) -> ffi::GtkSizeRequestMode {
10121 match self {
10122 Self::HeightForWidth => ffi::GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH,
10123 Self::WidthForHeight => ffi::GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT,
10124 Self::ConstantSize => ffi::GTK_SIZE_REQUEST_CONSTANT_SIZE,
10125 Self::__Unknown(value) => value,
10126 }
10127 }
10128}
10129
10130#[doc(hidden)]
10131impl FromGlib<ffi::GtkSizeRequestMode> for SizeRequestMode {
10132 #[inline]
10133 unsafe fn from_glib(value: ffi::GtkSizeRequestMode) -> Self {
10134 skip_assert_initialized!();
10135
10136 match value {
10137 ffi::GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH => Self::HeightForWidth,
10138 ffi::GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT => Self::WidthForHeight,
10139 ffi::GTK_SIZE_REQUEST_CONSTANT_SIZE => Self::ConstantSize,
10140 value => Self::__Unknown(value),
10141 }
10142 }
10143}
10144
10145impl StaticType for SizeRequestMode {
10146 #[inline]
10147 #[doc(alias = "gtk_size_request_mode_get_type")]
10148 fn static_type() -> glib::Type {
10149 unsafe { from_glib(ffi::gtk_size_request_mode_get_type()) }
10150 }
10151}
10152
10153impl glib::HasParamSpec for SizeRequestMode {
10154 type ParamSpec = glib::ParamSpecEnum;
10155 type SetValue = Self;
10156 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
10157
10158 fn param_spec_builder() -> Self::BuilderFn {
10159 Self::ParamSpec::builder_with_default
10160 }
10161}
10162
10163impl glib::value::ValueType for SizeRequestMode {
10164 type Type = Self;
10165}
10166
10167unsafe impl<'a> glib::value::FromValue<'a> for SizeRequestMode {
10168 type Checker = glib::value::GenericValueTypeChecker<Self>;
10169
10170 #[inline]
10171 unsafe fn from_value(value: &'a glib::Value) -> Self {
10172 skip_assert_initialized!();
10173 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
10174 }
10175}
10176
10177impl ToValue for SizeRequestMode {
10178 #[inline]
10179 fn to_value(&self) -> glib::Value {
10180 let mut value = glib::Value::for_value_type::<Self>();
10181 unsafe {
10182 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
10183 }
10184 value
10185 }
10186
10187 #[inline]
10188 fn value_type(&self) -> glib::Type {
10189 Self::static_type()
10190 }
10191}
10192
10193impl From<SizeRequestMode> for glib::Value {
10194 #[inline]
10195 fn from(v: SizeRequestMode) -> Self {
10196 skip_assert_initialized!();
10197 ToValue::to_value(&v)
10198 }
10199}
10200
10201#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
10202#[non_exhaustive]
10203#[doc(alias = "GtkSortType")]
10204pub enum SortType {
10205 #[doc(alias = "GTK_SORT_ASCENDING")]
10206 Ascending,
10207 #[doc(alias = "GTK_SORT_DESCENDING")]
10208 Descending,
10209 #[doc(hidden)]
10210 __Unknown(i32),
10211}
10212
10213#[doc(hidden)]
10214impl IntoGlib for SortType {
10215 type GlibType = ffi::GtkSortType;
10216
10217 #[inline]
10218 fn into_glib(self) -> ffi::GtkSortType {
10219 match self {
10220 Self::Ascending => ffi::GTK_SORT_ASCENDING,
10221 Self::Descending => ffi::GTK_SORT_DESCENDING,
10222 Self::__Unknown(value) => value,
10223 }
10224 }
10225}
10226
10227#[doc(hidden)]
10228impl FromGlib<ffi::GtkSortType> for SortType {
10229 #[inline]
10230 unsafe fn from_glib(value: ffi::GtkSortType) -> Self {
10231 skip_assert_initialized!();
10232
10233 match value {
10234 ffi::GTK_SORT_ASCENDING => Self::Ascending,
10235 ffi::GTK_SORT_DESCENDING => Self::Descending,
10236 value => Self::__Unknown(value),
10237 }
10238 }
10239}
10240
10241impl StaticType for SortType {
10242 #[inline]
10243 #[doc(alias = "gtk_sort_type_get_type")]
10244 fn static_type() -> glib::Type {
10245 unsafe { from_glib(ffi::gtk_sort_type_get_type()) }
10246 }
10247}
10248
10249impl glib::HasParamSpec for SortType {
10250 type ParamSpec = glib::ParamSpecEnum;
10251 type SetValue = Self;
10252 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
10253
10254 fn param_spec_builder() -> Self::BuilderFn {
10255 Self::ParamSpec::builder_with_default
10256 }
10257}
10258
10259impl glib::value::ValueType for SortType {
10260 type Type = Self;
10261}
10262
10263unsafe impl<'a> glib::value::FromValue<'a> for SortType {
10264 type Checker = glib::value::GenericValueTypeChecker<Self>;
10265
10266 #[inline]
10267 unsafe fn from_value(value: &'a glib::Value) -> Self {
10268 skip_assert_initialized!();
10269 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
10270 }
10271}
10272
10273impl ToValue for SortType {
10274 #[inline]
10275 fn to_value(&self) -> glib::Value {
10276 let mut value = glib::Value::for_value_type::<Self>();
10277 unsafe {
10278 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
10279 }
10280 value
10281 }
10282
10283 #[inline]
10284 fn value_type(&self) -> glib::Type {
10285 Self::static_type()
10286 }
10287}
10288
10289impl From<SortType> for glib::Value {
10290 #[inline]
10291 fn from(v: SortType) -> Self {
10292 skip_assert_initialized!();
10293 ToValue::to_value(&v)
10294 }
10295}
10296
10297#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
10298#[non_exhaustive]
10299#[doc(alias = "GtkSorterChange")]
10300pub enum SorterChange {
10301 #[doc(alias = "GTK_SORTER_CHANGE_DIFFERENT")]
10302 Different,
10303 #[doc(alias = "GTK_SORTER_CHANGE_INVERTED")]
10304 Inverted,
10305 #[doc(alias = "GTK_SORTER_CHANGE_LESS_STRICT")]
10306 LessStrict,
10307 #[doc(alias = "GTK_SORTER_CHANGE_MORE_STRICT")]
10308 MoreStrict,
10309 #[doc(hidden)]
10310 __Unknown(i32),
10311}
10312
10313#[doc(hidden)]
10314impl IntoGlib for SorterChange {
10315 type GlibType = ffi::GtkSorterChange;
10316
10317 #[inline]
10318 fn into_glib(self) -> ffi::GtkSorterChange {
10319 match self {
10320 Self::Different => ffi::GTK_SORTER_CHANGE_DIFFERENT,
10321 Self::Inverted => ffi::GTK_SORTER_CHANGE_INVERTED,
10322 Self::LessStrict => ffi::GTK_SORTER_CHANGE_LESS_STRICT,
10323 Self::MoreStrict => ffi::GTK_SORTER_CHANGE_MORE_STRICT,
10324 Self::__Unknown(value) => value,
10325 }
10326 }
10327}
10328
10329#[doc(hidden)]
10330impl FromGlib<ffi::GtkSorterChange> for SorterChange {
10331 #[inline]
10332 unsafe fn from_glib(value: ffi::GtkSorterChange) -> Self {
10333 skip_assert_initialized!();
10334
10335 match value {
10336 ffi::GTK_SORTER_CHANGE_DIFFERENT => Self::Different,
10337 ffi::GTK_SORTER_CHANGE_INVERTED => Self::Inverted,
10338 ffi::GTK_SORTER_CHANGE_LESS_STRICT => Self::LessStrict,
10339 ffi::GTK_SORTER_CHANGE_MORE_STRICT => Self::MoreStrict,
10340 value => Self::__Unknown(value),
10341 }
10342 }
10343}
10344
10345impl StaticType for SorterChange {
10346 #[inline]
10347 #[doc(alias = "gtk_sorter_change_get_type")]
10348 fn static_type() -> glib::Type {
10349 unsafe { from_glib(ffi::gtk_sorter_change_get_type()) }
10350 }
10351}
10352
10353impl glib::HasParamSpec for SorterChange {
10354 type ParamSpec = glib::ParamSpecEnum;
10355 type SetValue = Self;
10356 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
10357
10358 fn param_spec_builder() -> Self::BuilderFn {
10359 Self::ParamSpec::builder_with_default
10360 }
10361}
10362
10363impl glib::value::ValueType for SorterChange {
10364 type Type = Self;
10365}
10366
10367unsafe impl<'a> glib::value::FromValue<'a> for SorterChange {
10368 type Checker = glib::value::GenericValueTypeChecker<Self>;
10369
10370 #[inline]
10371 unsafe fn from_value(value: &'a glib::Value) -> Self {
10372 skip_assert_initialized!();
10373 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
10374 }
10375}
10376
10377impl ToValue for SorterChange {
10378 #[inline]
10379 fn to_value(&self) -> glib::Value {
10380 let mut value = glib::Value::for_value_type::<Self>();
10381 unsafe {
10382 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
10383 }
10384 value
10385 }
10386
10387 #[inline]
10388 fn value_type(&self) -> glib::Type {
10389 Self::static_type()
10390 }
10391}
10392
10393impl From<SorterChange> for glib::Value {
10394 #[inline]
10395 fn from(v: SorterChange) -> Self {
10396 skip_assert_initialized!();
10397 ToValue::to_value(&v)
10398 }
10399}
10400
10401#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
10402#[non_exhaustive]
10403#[doc(alias = "GtkSorterOrder")]
10404pub enum SorterOrder {
10405 #[doc(alias = "GTK_SORTER_ORDER_PARTIAL")]
10406 Partial,
10407 #[doc(alias = "GTK_SORTER_ORDER_NONE")]
10408 None,
10409 #[doc(alias = "GTK_SORTER_ORDER_TOTAL")]
10410 Total,
10411 #[doc(hidden)]
10412 __Unknown(i32),
10413}
10414
10415#[doc(hidden)]
10416impl IntoGlib for SorterOrder {
10417 type GlibType = ffi::GtkSorterOrder;
10418
10419 #[inline]
10420 fn into_glib(self) -> ffi::GtkSorterOrder {
10421 match self {
10422 Self::Partial => ffi::GTK_SORTER_ORDER_PARTIAL,
10423 Self::None => ffi::GTK_SORTER_ORDER_NONE,
10424 Self::Total => ffi::GTK_SORTER_ORDER_TOTAL,
10425 Self::__Unknown(value) => value,
10426 }
10427 }
10428}
10429
10430#[doc(hidden)]
10431impl FromGlib<ffi::GtkSorterOrder> for SorterOrder {
10432 #[inline]
10433 unsafe fn from_glib(value: ffi::GtkSorterOrder) -> Self {
10434 skip_assert_initialized!();
10435
10436 match value {
10437 ffi::GTK_SORTER_ORDER_PARTIAL => Self::Partial,
10438 ffi::GTK_SORTER_ORDER_NONE => Self::None,
10439 ffi::GTK_SORTER_ORDER_TOTAL => Self::Total,
10440 value => Self::__Unknown(value),
10441 }
10442 }
10443}
10444
10445impl StaticType for SorterOrder {
10446 #[inline]
10447 #[doc(alias = "gtk_sorter_order_get_type")]
10448 fn static_type() -> glib::Type {
10449 unsafe { from_glib(ffi::gtk_sorter_order_get_type()) }
10450 }
10451}
10452
10453impl glib::HasParamSpec for SorterOrder {
10454 type ParamSpec = glib::ParamSpecEnum;
10455 type SetValue = Self;
10456 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
10457
10458 fn param_spec_builder() -> Self::BuilderFn {
10459 Self::ParamSpec::builder_with_default
10460 }
10461}
10462
10463impl glib::value::ValueType for SorterOrder {
10464 type Type = Self;
10465}
10466
10467unsafe impl<'a> glib::value::FromValue<'a> for SorterOrder {
10468 type Checker = glib::value::GenericValueTypeChecker<Self>;
10469
10470 #[inline]
10471 unsafe fn from_value(value: &'a glib::Value) -> Self {
10472 skip_assert_initialized!();
10473 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
10474 }
10475}
10476
10477impl ToValue for SorterOrder {
10478 #[inline]
10479 fn to_value(&self) -> glib::Value {
10480 let mut value = glib::Value::for_value_type::<Self>();
10481 unsafe {
10482 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
10483 }
10484 value
10485 }
10486
10487 #[inline]
10488 fn value_type(&self) -> glib::Type {
10489 Self::static_type()
10490 }
10491}
10492
10493impl From<SorterOrder> for glib::Value {
10494 #[inline]
10495 fn from(v: SorterOrder) -> Self {
10496 skip_assert_initialized!();
10497 ToValue::to_value(&v)
10498 }
10499}
10500
10501#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
10502#[non_exhaustive]
10503#[doc(alias = "GtkSpinButtonUpdatePolicy")]
10504pub enum SpinButtonUpdatePolicy {
10505 #[doc(alias = "GTK_UPDATE_ALWAYS")]
10506 Always,
10507 #[doc(alias = "GTK_UPDATE_IF_VALID")]
10508 IfValid,
10509 #[doc(hidden)]
10510 __Unknown(i32),
10511}
10512
10513#[doc(hidden)]
10514impl IntoGlib for SpinButtonUpdatePolicy {
10515 type GlibType = ffi::GtkSpinButtonUpdatePolicy;
10516
10517 #[inline]
10518 fn into_glib(self) -> ffi::GtkSpinButtonUpdatePolicy {
10519 match self {
10520 Self::Always => ffi::GTK_UPDATE_ALWAYS,
10521 Self::IfValid => ffi::GTK_UPDATE_IF_VALID,
10522 Self::__Unknown(value) => value,
10523 }
10524 }
10525}
10526
10527#[doc(hidden)]
10528impl FromGlib<ffi::GtkSpinButtonUpdatePolicy> for SpinButtonUpdatePolicy {
10529 #[inline]
10530 unsafe fn from_glib(value: ffi::GtkSpinButtonUpdatePolicy) -> Self {
10531 skip_assert_initialized!();
10532
10533 match value {
10534 ffi::GTK_UPDATE_ALWAYS => Self::Always,
10535 ffi::GTK_UPDATE_IF_VALID => Self::IfValid,
10536 value => Self::__Unknown(value),
10537 }
10538 }
10539}
10540
10541impl StaticType for SpinButtonUpdatePolicy {
10542 #[inline]
10543 #[doc(alias = "gtk_spin_button_update_policy_get_type")]
10544 fn static_type() -> glib::Type {
10545 unsafe { from_glib(ffi::gtk_spin_button_update_policy_get_type()) }
10546 }
10547}
10548
10549impl glib::HasParamSpec for SpinButtonUpdatePolicy {
10550 type ParamSpec = glib::ParamSpecEnum;
10551 type SetValue = Self;
10552 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
10553
10554 fn param_spec_builder() -> Self::BuilderFn {
10555 Self::ParamSpec::builder_with_default
10556 }
10557}
10558
10559impl glib::value::ValueType for SpinButtonUpdatePolicy {
10560 type Type = Self;
10561}
10562
10563unsafe impl<'a> glib::value::FromValue<'a> for SpinButtonUpdatePolicy {
10564 type Checker = glib::value::GenericValueTypeChecker<Self>;
10565
10566 #[inline]
10567 unsafe fn from_value(value: &'a glib::Value) -> Self {
10568 skip_assert_initialized!();
10569 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
10570 }
10571}
10572
10573impl ToValue for SpinButtonUpdatePolicy {
10574 #[inline]
10575 fn to_value(&self) -> glib::Value {
10576 let mut value = glib::Value::for_value_type::<Self>();
10577 unsafe {
10578 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
10579 }
10580 value
10581 }
10582
10583 #[inline]
10584 fn value_type(&self) -> glib::Type {
10585 Self::static_type()
10586 }
10587}
10588
10589impl From<SpinButtonUpdatePolicy> for glib::Value {
10590 #[inline]
10591 fn from(v: SpinButtonUpdatePolicy) -> Self {
10592 skip_assert_initialized!();
10593 ToValue::to_value(&v)
10594 }
10595}
10596
10597#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
10598#[non_exhaustive]
10599#[doc(alias = "GtkSpinType")]
10600pub enum SpinType {
10601 #[doc(alias = "GTK_SPIN_STEP_FORWARD")]
10602 StepForward,
10603 #[doc(alias = "GTK_SPIN_STEP_BACKWARD")]
10604 StepBackward,
10605 #[doc(alias = "GTK_SPIN_PAGE_FORWARD")]
10606 PageForward,
10607 #[doc(alias = "GTK_SPIN_PAGE_BACKWARD")]
10608 PageBackward,
10609 #[doc(alias = "GTK_SPIN_HOME")]
10610 Home,
10611 #[doc(alias = "GTK_SPIN_END")]
10612 End,
10613 #[doc(alias = "GTK_SPIN_USER_DEFINED")]
10614 UserDefined,
10615 #[doc(hidden)]
10616 __Unknown(i32),
10617}
10618
10619#[doc(hidden)]
10620impl IntoGlib for SpinType {
10621 type GlibType = ffi::GtkSpinType;
10622
10623 #[inline]
10624 fn into_glib(self) -> ffi::GtkSpinType {
10625 match self {
10626 Self::StepForward => ffi::GTK_SPIN_STEP_FORWARD,
10627 Self::StepBackward => ffi::GTK_SPIN_STEP_BACKWARD,
10628 Self::PageForward => ffi::GTK_SPIN_PAGE_FORWARD,
10629 Self::PageBackward => ffi::GTK_SPIN_PAGE_BACKWARD,
10630 Self::Home => ffi::GTK_SPIN_HOME,
10631 Self::End => ffi::GTK_SPIN_END,
10632 Self::UserDefined => ffi::GTK_SPIN_USER_DEFINED,
10633 Self::__Unknown(value) => value,
10634 }
10635 }
10636}
10637
10638#[doc(hidden)]
10639impl FromGlib<ffi::GtkSpinType> for SpinType {
10640 #[inline]
10641 unsafe fn from_glib(value: ffi::GtkSpinType) -> Self {
10642 skip_assert_initialized!();
10643
10644 match value {
10645 ffi::GTK_SPIN_STEP_FORWARD => Self::StepForward,
10646 ffi::GTK_SPIN_STEP_BACKWARD => Self::StepBackward,
10647 ffi::GTK_SPIN_PAGE_FORWARD => Self::PageForward,
10648 ffi::GTK_SPIN_PAGE_BACKWARD => Self::PageBackward,
10649 ffi::GTK_SPIN_HOME => Self::Home,
10650 ffi::GTK_SPIN_END => Self::End,
10651 ffi::GTK_SPIN_USER_DEFINED => Self::UserDefined,
10652 value => Self::__Unknown(value),
10653 }
10654 }
10655}
10656
10657impl StaticType for SpinType {
10658 #[inline]
10659 #[doc(alias = "gtk_spin_type_get_type")]
10660 fn static_type() -> glib::Type {
10661 unsafe { from_glib(ffi::gtk_spin_type_get_type()) }
10662 }
10663}
10664
10665impl glib::HasParamSpec for SpinType {
10666 type ParamSpec = glib::ParamSpecEnum;
10667 type SetValue = Self;
10668 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
10669
10670 fn param_spec_builder() -> Self::BuilderFn {
10671 Self::ParamSpec::builder_with_default
10672 }
10673}
10674
10675impl glib::value::ValueType for SpinType {
10676 type Type = Self;
10677}
10678
10679unsafe impl<'a> glib::value::FromValue<'a> for SpinType {
10680 type Checker = glib::value::GenericValueTypeChecker<Self>;
10681
10682 #[inline]
10683 unsafe fn from_value(value: &'a glib::Value) -> Self {
10684 skip_assert_initialized!();
10685 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
10686 }
10687}
10688
10689impl ToValue for SpinType {
10690 #[inline]
10691 fn to_value(&self) -> glib::Value {
10692 let mut value = glib::Value::for_value_type::<Self>();
10693 unsafe {
10694 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
10695 }
10696 value
10697 }
10698
10699 #[inline]
10700 fn value_type(&self) -> glib::Type {
10701 Self::static_type()
10702 }
10703}
10704
10705impl From<SpinType> for glib::Value {
10706 #[inline]
10707 fn from(v: SpinType) -> Self {
10708 skip_assert_initialized!();
10709 ToValue::to_value(&v)
10710 }
10711}
10712
10713#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
10714#[non_exhaustive]
10715#[doc(alias = "GtkStackTransitionType")]
10716pub enum StackTransitionType {
10717 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_NONE")]
10718 None,
10719 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_CROSSFADE")]
10720 Crossfade,
10721 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_SLIDE_RIGHT")]
10722 SlideRight,
10723 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT")]
10724 SlideLeft,
10725 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_SLIDE_UP")]
10726 SlideUp,
10727 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_SLIDE_DOWN")]
10728 SlideDown,
10729 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT_RIGHT")]
10730 SlideLeftRight,
10731 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_SLIDE_UP_DOWN")]
10732 SlideUpDown,
10733 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_OVER_UP")]
10734 OverUp,
10735 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_OVER_DOWN")]
10736 OverDown,
10737 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_OVER_LEFT")]
10738 OverLeft,
10739 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_OVER_RIGHT")]
10740 OverRight,
10741 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_UNDER_UP")]
10742 UnderUp,
10743 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_UNDER_DOWN")]
10744 UnderDown,
10745 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_UNDER_LEFT")]
10746 UnderLeft,
10747 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_UNDER_RIGHT")]
10748 UnderRight,
10749 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_OVER_UP_DOWN")]
10750 OverUpDown,
10751 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_OVER_DOWN_UP")]
10752 OverDownUp,
10753 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_OVER_LEFT_RIGHT")]
10754 OverLeftRight,
10755 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_OVER_RIGHT_LEFT")]
10756 OverRightLeft,
10757 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_ROTATE_LEFT")]
10758 RotateLeft,
10759 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_ROTATE_RIGHT")]
10760 RotateRight,
10761 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_ROTATE_LEFT_RIGHT")]
10762 RotateLeftRight,
10763 #[doc(hidden)]
10764 __Unknown(i32),
10765}
10766
10767#[doc(hidden)]
10768impl IntoGlib for StackTransitionType {
10769 type GlibType = ffi::GtkStackTransitionType;
10770
10771 fn into_glib(self) -> ffi::GtkStackTransitionType {
10772 match self {
10773 Self::None => ffi::GTK_STACK_TRANSITION_TYPE_NONE,
10774 Self::Crossfade => ffi::GTK_STACK_TRANSITION_TYPE_CROSSFADE,
10775 Self::SlideRight => ffi::GTK_STACK_TRANSITION_TYPE_SLIDE_RIGHT,
10776 Self::SlideLeft => ffi::GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT,
10777 Self::SlideUp => ffi::GTK_STACK_TRANSITION_TYPE_SLIDE_UP,
10778 Self::SlideDown => ffi::GTK_STACK_TRANSITION_TYPE_SLIDE_DOWN,
10779 Self::SlideLeftRight => ffi::GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT_RIGHT,
10780 Self::SlideUpDown => ffi::GTK_STACK_TRANSITION_TYPE_SLIDE_UP_DOWN,
10781 Self::OverUp => ffi::GTK_STACK_TRANSITION_TYPE_OVER_UP,
10782 Self::OverDown => ffi::GTK_STACK_TRANSITION_TYPE_OVER_DOWN,
10783 Self::OverLeft => ffi::GTK_STACK_TRANSITION_TYPE_OVER_LEFT,
10784 Self::OverRight => ffi::GTK_STACK_TRANSITION_TYPE_OVER_RIGHT,
10785 Self::UnderUp => ffi::GTK_STACK_TRANSITION_TYPE_UNDER_UP,
10786 Self::UnderDown => ffi::GTK_STACK_TRANSITION_TYPE_UNDER_DOWN,
10787 Self::UnderLeft => ffi::GTK_STACK_TRANSITION_TYPE_UNDER_LEFT,
10788 Self::UnderRight => ffi::GTK_STACK_TRANSITION_TYPE_UNDER_RIGHT,
10789 Self::OverUpDown => ffi::GTK_STACK_TRANSITION_TYPE_OVER_UP_DOWN,
10790 Self::OverDownUp => ffi::GTK_STACK_TRANSITION_TYPE_OVER_DOWN_UP,
10791 Self::OverLeftRight => ffi::GTK_STACK_TRANSITION_TYPE_OVER_LEFT_RIGHT,
10792 Self::OverRightLeft => ffi::GTK_STACK_TRANSITION_TYPE_OVER_RIGHT_LEFT,
10793 Self::RotateLeft => ffi::GTK_STACK_TRANSITION_TYPE_ROTATE_LEFT,
10794 Self::RotateRight => ffi::GTK_STACK_TRANSITION_TYPE_ROTATE_RIGHT,
10795 Self::RotateLeftRight => ffi::GTK_STACK_TRANSITION_TYPE_ROTATE_LEFT_RIGHT,
10796 Self::__Unknown(value) => value,
10797 }
10798 }
10799}
10800
10801#[doc(hidden)]
10802impl FromGlib<ffi::GtkStackTransitionType> for StackTransitionType {
10803 unsafe fn from_glib(value: ffi::GtkStackTransitionType) -> Self {
10804 skip_assert_initialized!();
10805
10806 match value {
10807 ffi::GTK_STACK_TRANSITION_TYPE_NONE => Self::None,
10808 ffi::GTK_STACK_TRANSITION_TYPE_CROSSFADE => Self::Crossfade,
10809 ffi::GTK_STACK_TRANSITION_TYPE_SLIDE_RIGHT => Self::SlideRight,
10810 ffi::GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT => Self::SlideLeft,
10811 ffi::GTK_STACK_TRANSITION_TYPE_SLIDE_UP => Self::SlideUp,
10812 ffi::GTK_STACK_TRANSITION_TYPE_SLIDE_DOWN => Self::SlideDown,
10813 ffi::GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT_RIGHT => Self::SlideLeftRight,
10814 ffi::GTK_STACK_TRANSITION_TYPE_SLIDE_UP_DOWN => Self::SlideUpDown,
10815 ffi::GTK_STACK_TRANSITION_TYPE_OVER_UP => Self::OverUp,
10816 ffi::GTK_STACK_TRANSITION_TYPE_OVER_DOWN => Self::OverDown,
10817 ffi::GTK_STACK_TRANSITION_TYPE_OVER_LEFT => Self::OverLeft,
10818 ffi::GTK_STACK_TRANSITION_TYPE_OVER_RIGHT => Self::OverRight,
10819 ffi::GTK_STACK_TRANSITION_TYPE_UNDER_UP => Self::UnderUp,
10820 ffi::GTK_STACK_TRANSITION_TYPE_UNDER_DOWN => Self::UnderDown,
10821 ffi::GTK_STACK_TRANSITION_TYPE_UNDER_LEFT => Self::UnderLeft,
10822 ffi::GTK_STACK_TRANSITION_TYPE_UNDER_RIGHT => Self::UnderRight,
10823 ffi::GTK_STACK_TRANSITION_TYPE_OVER_UP_DOWN => Self::OverUpDown,
10824 ffi::GTK_STACK_TRANSITION_TYPE_OVER_DOWN_UP => Self::OverDownUp,
10825 ffi::GTK_STACK_TRANSITION_TYPE_OVER_LEFT_RIGHT => Self::OverLeftRight,
10826 ffi::GTK_STACK_TRANSITION_TYPE_OVER_RIGHT_LEFT => Self::OverRightLeft,
10827 ffi::GTK_STACK_TRANSITION_TYPE_ROTATE_LEFT => Self::RotateLeft,
10828 ffi::GTK_STACK_TRANSITION_TYPE_ROTATE_RIGHT => Self::RotateRight,
10829 ffi::GTK_STACK_TRANSITION_TYPE_ROTATE_LEFT_RIGHT => Self::RotateLeftRight,
10830 value => Self::__Unknown(value),
10831 }
10832 }
10833}
10834
10835impl StaticType for StackTransitionType {
10836 #[inline]
10837 #[doc(alias = "gtk_stack_transition_type_get_type")]
10838 fn static_type() -> glib::Type {
10839 unsafe { from_glib(ffi::gtk_stack_transition_type_get_type()) }
10840 }
10841}
10842
10843impl glib::HasParamSpec for StackTransitionType {
10844 type ParamSpec = glib::ParamSpecEnum;
10845 type SetValue = Self;
10846 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
10847
10848 fn param_spec_builder() -> Self::BuilderFn {
10849 Self::ParamSpec::builder_with_default
10850 }
10851}
10852
10853impl glib::value::ValueType for StackTransitionType {
10854 type Type = Self;
10855}
10856
10857unsafe impl<'a> glib::value::FromValue<'a> for StackTransitionType {
10858 type Checker = glib::value::GenericValueTypeChecker<Self>;
10859
10860 #[inline]
10861 unsafe fn from_value(value: &'a glib::Value) -> Self {
10862 skip_assert_initialized!();
10863 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
10864 }
10865}
10866
10867impl ToValue for StackTransitionType {
10868 #[inline]
10869 fn to_value(&self) -> glib::Value {
10870 let mut value = glib::Value::for_value_type::<Self>();
10871 unsafe {
10872 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
10873 }
10874 value
10875 }
10876
10877 #[inline]
10878 fn value_type(&self) -> glib::Type {
10879 Self::static_type()
10880 }
10881}
10882
10883impl From<StackTransitionType> for glib::Value {
10884 #[inline]
10885 fn from(v: StackTransitionType) -> Self {
10886 skip_assert_initialized!();
10887 ToValue::to_value(&v)
10888 }
10889}
10890
10891#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
10892#[non_exhaustive]
10893#[doc(alias = "GtkStringFilterMatchMode")]
10894pub enum StringFilterMatchMode {
10895 #[doc(alias = "GTK_STRING_FILTER_MATCH_MODE_EXACT")]
10896 Exact,
10897 #[doc(alias = "GTK_STRING_FILTER_MATCH_MODE_SUBSTRING")]
10898 Substring,
10899 #[doc(alias = "GTK_STRING_FILTER_MATCH_MODE_PREFIX")]
10900 Prefix,
10901 #[doc(hidden)]
10902 __Unknown(i32),
10903}
10904
10905#[doc(hidden)]
10906impl IntoGlib for StringFilterMatchMode {
10907 type GlibType = ffi::GtkStringFilterMatchMode;
10908
10909 #[inline]
10910 fn into_glib(self) -> ffi::GtkStringFilterMatchMode {
10911 match self {
10912 Self::Exact => ffi::GTK_STRING_FILTER_MATCH_MODE_EXACT,
10913 Self::Substring => ffi::GTK_STRING_FILTER_MATCH_MODE_SUBSTRING,
10914 Self::Prefix => ffi::GTK_STRING_FILTER_MATCH_MODE_PREFIX,
10915 Self::__Unknown(value) => value,
10916 }
10917 }
10918}
10919
10920#[doc(hidden)]
10921impl FromGlib<ffi::GtkStringFilterMatchMode> for StringFilterMatchMode {
10922 #[inline]
10923 unsafe fn from_glib(value: ffi::GtkStringFilterMatchMode) -> Self {
10924 skip_assert_initialized!();
10925
10926 match value {
10927 ffi::GTK_STRING_FILTER_MATCH_MODE_EXACT => Self::Exact,
10928 ffi::GTK_STRING_FILTER_MATCH_MODE_SUBSTRING => Self::Substring,
10929 ffi::GTK_STRING_FILTER_MATCH_MODE_PREFIX => Self::Prefix,
10930 value => Self::__Unknown(value),
10931 }
10932 }
10933}
10934
10935impl StaticType for StringFilterMatchMode {
10936 #[inline]
10937 #[doc(alias = "gtk_string_filter_match_mode_get_type")]
10938 fn static_type() -> glib::Type {
10939 unsafe { from_glib(ffi::gtk_string_filter_match_mode_get_type()) }
10940 }
10941}
10942
10943impl glib::HasParamSpec for StringFilterMatchMode {
10944 type ParamSpec = glib::ParamSpecEnum;
10945 type SetValue = Self;
10946 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
10947
10948 fn param_spec_builder() -> Self::BuilderFn {
10949 Self::ParamSpec::builder_with_default
10950 }
10951}
10952
10953impl glib::value::ValueType for StringFilterMatchMode {
10954 type Type = Self;
10955}
10956
10957unsafe impl<'a> glib::value::FromValue<'a> for StringFilterMatchMode {
10958 type Checker = glib::value::GenericValueTypeChecker<Self>;
10959
10960 #[inline]
10961 unsafe fn from_value(value: &'a glib::Value) -> Self {
10962 skip_assert_initialized!();
10963 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
10964 }
10965}
10966
10967impl ToValue for StringFilterMatchMode {
10968 #[inline]
10969 fn to_value(&self) -> glib::Value {
10970 let mut value = glib::Value::for_value_type::<Self>();
10971 unsafe {
10972 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
10973 }
10974 value
10975 }
10976
10977 #[inline]
10978 fn value_type(&self) -> glib::Type {
10979 Self::static_type()
10980 }
10981}
10982
10983impl From<StringFilterMatchMode> for glib::Value {
10984 #[inline]
10985 fn from(v: StringFilterMatchMode) -> Self {
10986 skip_assert_initialized!();
10987 ToValue::to_value(&v)
10988 }
10989}
10990
10991#[cfg(feature = "v4_6")]
10992#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
10993#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
10994#[non_exhaustive]
10995#[doc(alias = "GtkSymbolicColor")]
10996pub enum SymbolicColor {
10997 #[doc(alias = "GTK_SYMBOLIC_COLOR_FOREGROUND")]
10998 Foreground,
10999 #[doc(alias = "GTK_SYMBOLIC_COLOR_ERROR")]
11000 Error,
11001 #[doc(alias = "GTK_SYMBOLIC_COLOR_WARNING")]
11002 Warning,
11003 #[doc(alias = "GTK_SYMBOLIC_COLOR_SUCCESS")]
11004 Success,
11005 #[doc(hidden)]
11006 __Unknown(i32),
11007}
11008
11009#[cfg(feature = "v4_6")]
11010#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
11011#[doc(hidden)]
11012impl IntoGlib for SymbolicColor {
11013 type GlibType = ffi::GtkSymbolicColor;
11014
11015 #[inline]
11016 fn into_glib(self) -> ffi::GtkSymbolicColor {
11017 match self {
11018 Self::Foreground => ffi::GTK_SYMBOLIC_COLOR_FOREGROUND,
11019 Self::Error => ffi::GTK_SYMBOLIC_COLOR_ERROR,
11020 Self::Warning => ffi::GTK_SYMBOLIC_COLOR_WARNING,
11021 Self::Success => ffi::GTK_SYMBOLIC_COLOR_SUCCESS,
11022 Self::__Unknown(value) => value,
11023 }
11024 }
11025}
11026
11027#[cfg(feature = "v4_6")]
11028#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
11029#[doc(hidden)]
11030impl FromGlib<ffi::GtkSymbolicColor> for SymbolicColor {
11031 #[inline]
11032 unsafe fn from_glib(value: ffi::GtkSymbolicColor) -> Self {
11033 skip_assert_initialized!();
11034
11035 match value {
11036 ffi::GTK_SYMBOLIC_COLOR_FOREGROUND => Self::Foreground,
11037 ffi::GTK_SYMBOLIC_COLOR_ERROR => Self::Error,
11038 ffi::GTK_SYMBOLIC_COLOR_WARNING => Self::Warning,
11039 ffi::GTK_SYMBOLIC_COLOR_SUCCESS => Self::Success,
11040 value => Self::__Unknown(value),
11041 }
11042 }
11043}
11044
11045#[cfg(feature = "v4_6")]
11046#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
11047impl StaticType for SymbolicColor {
11048 #[inline]
11049 #[doc(alias = "gtk_symbolic_color_get_type")]
11050 fn static_type() -> glib::Type {
11051 unsafe { from_glib(ffi::gtk_symbolic_color_get_type()) }
11052 }
11053}
11054
11055#[cfg(feature = "v4_6")]
11056#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
11057impl glib::HasParamSpec for SymbolicColor {
11058 type ParamSpec = glib::ParamSpecEnum;
11059 type SetValue = Self;
11060 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
11061
11062 fn param_spec_builder() -> Self::BuilderFn {
11063 Self::ParamSpec::builder_with_default
11064 }
11065}
11066
11067#[cfg(feature = "v4_6")]
11068#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
11069impl glib::value::ValueType for SymbolicColor {
11070 type Type = Self;
11071}
11072
11073#[cfg(feature = "v4_6")]
11074#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
11075unsafe impl<'a> glib::value::FromValue<'a> for SymbolicColor {
11076 type Checker = glib::value::GenericValueTypeChecker<Self>;
11077
11078 #[inline]
11079 unsafe fn from_value(value: &'a glib::Value) -> Self {
11080 skip_assert_initialized!();
11081 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
11082 }
11083}
11084
11085#[cfg(feature = "v4_6")]
11086#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
11087impl ToValue for SymbolicColor {
11088 #[inline]
11089 fn to_value(&self) -> glib::Value {
11090 let mut value = glib::Value::for_value_type::<Self>();
11091 unsafe {
11092 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
11093 }
11094 value
11095 }
11096
11097 #[inline]
11098 fn value_type(&self) -> glib::Type {
11099 Self::static_type()
11100 }
11101}
11102
11103#[cfg(feature = "v4_6")]
11104#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
11105impl From<SymbolicColor> for glib::Value {
11106 #[inline]
11107 fn from(v: SymbolicColor) -> Self {
11108 skip_assert_initialized!();
11109 ToValue::to_value(&v)
11110 }
11111}
11112
11113#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
11114#[non_exhaustive]
11115#[doc(alias = "GtkSystemSetting")]
11116pub enum SystemSetting {
11117 #[doc(alias = "GTK_SYSTEM_SETTING_DPI")]
11118 Dpi,
11119 #[doc(alias = "GTK_SYSTEM_SETTING_FONT_NAME")]
11120 FontName,
11121 #[doc(alias = "GTK_SYSTEM_SETTING_FONT_CONFIG")]
11122 FontConfig,
11123 #[doc(alias = "GTK_SYSTEM_SETTING_DISPLAY")]
11124 Display,
11125 #[doc(alias = "GTK_SYSTEM_SETTING_ICON_THEME")]
11126 IconTheme,
11127 #[doc(hidden)]
11128 __Unknown(i32),
11129}
11130
11131#[doc(hidden)]
11132impl IntoGlib for SystemSetting {
11133 type GlibType = ffi::GtkSystemSetting;
11134
11135 #[inline]
11136 fn into_glib(self) -> ffi::GtkSystemSetting {
11137 match self {
11138 Self::Dpi => ffi::GTK_SYSTEM_SETTING_DPI,
11139 Self::FontName => ffi::GTK_SYSTEM_SETTING_FONT_NAME,
11140 Self::FontConfig => ffi::GTK_SYSTEM_SETTING_FONT_CONFIG,
11141 Self::Display => ffi::GTK_SYSTEM_SETTING_DISPLAY,
11142 Self::IconTheme => ffi::GTK_SYSTEM_SETTING_ICON_THEME,
11143 Self::__Unknown(value) => value,
11144 }
11145 }
11146}
11147
11148#[doc(hidden)]
11149impl FromGlib<ffi::GtkSystemSetting> for SystemSetting {
11150 #[inline]
11151 unsafe fn from_glib(value: ffi::GtkSystemSetting) -> Self {
11152 skip_assert_initialized!();
11153
11154 match value {
11155 ffi::GTK_SYSTEM_SETTING_DPI => Self::Dpi,
11156 ffi::GTK_SYSTEM_SETTING_FONT_NAME => Self::FontName,
11157 ffi::GTK_SYSTEM_SETTING_FONT_CONFIG => Self::FontConfig,
11158 ffi::GTK_SYSTEM_SETTING_DISPLAY => Self::Display,
11159 ffi::GTK_SYSTEM_SETTING_ICON_THEME => Self::IconTheme,
11160 value => Self::__Unknown(value),
11161 }
11162 }
11163}
11164
11165impl StaticType for SystemSetting {
11166 #[inline]
11167 #[doc(alias = "gtk_system_setting_get_type")]
11168 fn static_type() -> glib::Type {
11169 unsafe { from_glib(ffi::gtk_system_setting_get_type()) }
11170 }
11171}
11172
11173impl glib::HasParamSpec for SystemSetting {
11174 type ParamSpec = glib::ParamSpecEnum;
11175 type SetValue = Self;
11176 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
11177
11178 fn param_spec_builder() -> Self::BuilderFn {
11179 Self::ParamSpec::builder_with_default
11180 }
11181}
11182
11183impl glib::value::ValueType for SystemSetting {
11184 type Type = Self;
11185}
11186
11187unsafe impl<'a> glib::value::FromValue<'a> for SystemSetting {
11188 type Checker = glib::value::GenericValueTypeChecker<Self>;
11189
11190 #[inline]
11191 unsafe fn from_value(value: &'a glib::Value) -> Self {
11192 skip_assert_initialized!();
11193 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
11194 }
11195}
11196
11197impl ToValue for SystemSetting {
11198 #[inline]
11199 fn to_value(&self) -> glib::Value {
11200 let mut value = glib::Value::for_value_type::<Self>();
11201 unsafe {
11202 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
11203 }
11204 value
11205 }
11206
11207 #[inline]
11208 fn value_type(&self) -> glib::Type {
11209 Self::static_type()
11210 }
11211}
11212
11213impl From<SystemSetting> for glib::Value {
11214 #[inline]
11215 fn from(v: SystemSetting) -> Self {
11216 skip_assert_initialized!();
11217 ToValue::to_value(&v)
11218 }
11219}
11220
11221#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
11222#[non_exhaustive]
11223#[doc(alias = "GtkTextDirection")]
11224pub enum TextDirection {
11225 #[doc(alias = "GTK_TEXT_DIR_NONE")]
11226 None,
11227 #[doc(alias = "GTK_TEXT_DIR_LTR")]
11228 Ltr,
11229 #[doc(alias = "GTK_TEXT_DIR_RTL")]
11230 Rtl,
11231 #[doc(hidden)]
11232 __Unknown(i32),
11233}
11234
11235#[doc(hidden)]
11236impl IntoGlib for TextDirection {
11237 type GlibType = ffi::GtkTextDirection;
11238
11239 #[inline]
11240 fn into_glib(self) -> ffi::GtkTextDirection {
11241 match self {
11242 Self::None => ffi::GTK_TEXT_DIR_NONE,
11243 Self::Ltr => ffi::GTK_TEXT_DIR_LTR,
11244 Self::Rtl => ffi::GTK_TEXT_DIR_RTL,
11245 Self::__Unknown(value) => value,
11246 }
11247 }
11248}
11249
11250#[doc(hidden)]
11251impl FromGlib<ffi::GtkTextDirection> for TextDirection {
11252 #[inline]
11253 unsafe fn from_glib(value: ffi::GtkTextDirection) -> Self {
11254 skip_assert_initialized!();
11255
11256 match value {
11257 ffi::GTK_TEXT_DIR_NONE => Self::None,
11258 ffi::GTK_TEXT_DIR_LTR => Self::Ltr,
11259 ffi::GTK_TEXT_DIR_RTL => Self::Rtl,
11260 value => Self::__Unknown(value),
11261 }
11262 }
11263}
11264
11265impl StaticType for TextDirection {
11266 #[inline]
11267 #[doc(alias = "gtk_text_direction_get_type")]
11268 fn static_type() -> glib::Type {
11269 unsafe { from_glib(ffi::gtk_text_direction_get_type()) }
11270 }
11271}
11272
11273impl glib::HasParamSpec for TextDirection {
11274 type ParamSpec = glib::ParamSpecEnum;
11275 type SetValue = Self;
11276 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
11277
11278 fn param_spec_builder() -> Self::BuilderFn {
11279 Self::ParamSpec::builder_with_default
11280 }
11281}
11282
11283impl glib::value::ValueType for TextDirection {
11284 type Type = Self;
11285}
11286
11287unsafe impl<'a> glib::value::FromValue<'a> for TextDirection {
11288 type Checker = glib::value::GenericValueTypeChecker<Self>;
11289
11290 #[inline]
11291 unsafe fn from_value(value: &'a glib::Value) -> Self {
11292 skip_assert_initialized!();
11293 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
11294 }
11295}
11296
11297impl ToValue for TextDirection {
11298 #[inline]
11299 fn to_value(&self) -> glib::Value {
11300 let mut value = glib::Value::for_value_type::<Self>();
11301 unsafe {
11302 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
11303 }
11304 value
11305 }
11306
11307 #[inline]
11308 fn value_type(&self) -> glib::Type {
11309 Self::static_type()
11310 }
11311}
11312
11313impl From<TextDirection> for glib::Value {
11314 #[inline]
11315 fn from(v: TextDirection) -> Self {
11316 skip_assert_initialized!();
11317 ToValue::to_value(&v)
11318 }
11319}
11320
11321#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
11322#[non_exhaustive]
11323#[doc(alias = "GtkTextExtendSelection")]
11324pub enum TextExtendSelection {
11325 #[doc(alias = "GTK_TEXT_EXTEND_SELECTION_WORD")]
11326 Word,
11327 #[doc(alias = "GTK_TEXT_EXTEND_SELECTION_LINE")]
11328 Line,
11329 #[doc(hidden)]
11330 __Unknown(i32),
11331}
11332
11333#[doc(hidden)]
11334impl IntoGlib for TextExtendSelection {
11335 type GlibType = ffi::GtkTextExtendSelection;
11336
11337 #[inline]
11338 fn into_glib(self) -> ffi::GtkTextExtendSelection {
11339 match self {
11340 Self::Word => ffi::GTK_TEXT_EXTEND_SELECTION_WORD,
11341 Self::Line => ffi::GTK_TEXT_EXTEND_SELECTION_LINE,
11342 Self::__Unknown(value) => value,
11343 }
11344 }
11345}
11346
11347#[doc(hidden)]
11348impl FromGlib<ffi::GtkTextExtendSelection> for TextExtendSelection {
11349 #[inline]
11350 unsafe fn from_glib(value: ffi::GtkTextExtendSelection) -> Self {
11351 skip_assert_initialized!();
11352
11353 match value {
11354 ffi::GTK_TEXT_EXTEND_SELECTION_WORD => Self::Word,
11355 ffi::GTK_TEXT_EXTEND_SELECTION_LINE => Self::Line,
11356 value => Self::__Unknown(value),
11357 }
11358 }
11359}
11360
11361impl StaticType for TextExtendSelection {
11362 #[inline]
11363 #[doc(alias = "gtk_text_extend_selection_get_type")]
11364 fn static_type() -> glib::Type {
11365 unsafe { from_glib(ffi::gtk_text_extend_selection_get_type()) }
11366 }
11367}
11368
11369impl glib::HasParamSpec for TextExtendSelection {
11370 type ParamSpec = glib::ParamSpecEnum;
11371 type SetValue = Self;
11372 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
11373
11374 fn param_spec_builder() -> Self::BuilderFn {
11375 Self::ParamSpec::builder_with_default
11376 }
11377}
11378
11379impl glib::value::ValueType for TextExtendSelection {
11380 type Type = Self;
11381}
11382
11383unsafe impl<'a> glib::value::FromValue<'a> for TextExtendSelection {
11384 type Checker = glib::value::GenericValueTypeChecker<Self>;
11385
11386 #[inline]
11387 unsafe fn from_value(value: &'a glib::Value) -> Self {
11388 skip_assert_initialized!();
11389 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
11390 }
11391}
11392
11393impl ToValue for TextExtendSelection {
11394 #[inline]
11395 fn to_value(&self) -> glib::Value {
11396 let mut value = glib::Value::for_value_type::<Self>();
11397 unsafe {
11398 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
11399 }
11400 value
11401 }
11402
11403 #[inline]
11404 fn value_type(&self) -> glib::Type {
11405 Self::static_type()
11406 }
11407}
11408
11409impl From<TextExtendSelection> for glib::Value {
11410 #[inline]
11411 fn from(v: TextExtendSelection) -> Self {
11412 skip_assert_initialized!();
11413 ToValue::to_value(&v)
11414 }
11415}
11416
11417#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
11418#[non_exhaustive]
11419#[doc(alias = "GtkTextViewLayer")]
11420pub enum TextViewLayer {
11421 #[doc(alias = "GTK_TEXT_VIEW_LAYER_BELOW_TEXT")]
11422 BelowText,
11423 #[doc(alias = "GTK_TEXT_VIEW_LAYER_ABOVE_TEXT")]
11424 AboveText,
11425 #[doc(hidden)]
11426 __Unknown(i32),
11427}
11428
11429#[doc(hidden)]
11430impl IntoGlib for TextViewLayer {
11431 type GlibType = ffi::GtkTextViewLayer;
11432
11433 #[inline]
11434 fn into_glib(self) -> ffi::GtkTextViewLayer {
11435 match self {
11436 Self::BelowText => ffi::GTK_TEXT_VIEW_LAYER_BELOW_TEXT,
11437 Self::AboveText => ffi::GTK_TEXT_VIEW_LAYER_ABOVE_TEXT,
11438 Self::__Unknown(value) => value,
11439 }
11440 }
11441}
11442
11443#[doc(hidden)]
11444impl FromGlib<ffi::GtkTextViewLayer> for TextViewLayer {
11445 #[inline]
11446 unsafe fn from_glib(value: ffi::GtkTextViewLayer) -> Self {
11447 skip_assert_initialized!();
11448
11449 match value {
11450 ffi::GTK_TEXT_VIEW_LAYER_BELOW_TEXT => Self::BelowText,
11451 ffi::GTK_TEXT_VIEW_LAYER_ABOVE_TEXT => Self::AboveText,
11452 value => Self::__Unknown(value),
11453 }
11454 }
11455}
11456
11457impl StaticType for TextViewLayer {
11458 #[inline]
11459 #[doc(alias = "gtk_text_view_layer_get_type")]
11460 fn static_type() -> glib::Type {
11461 unsafe { from_glib(ffi::gtk_text_view_layer_get_type()) }
11462 }
11463}
11464
11465impl glib::HasParamSpec for TextViewLayer {
11466 type ParamSpec = glib::ParamSpecEnum;
11467 type SetValue = Self;
11468 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
11469
11470 fn param_spec_builder() -> Self::BuilderFn {
11471 Self::ParamSpec::builder_with_default
11472 }
11473}
11474
11475impl glib::value::ValueType for TextViewLayer {
11476 type Type = Self;
11477}
11478
11479unsafe impl<'a> glib::value::FromValue<'a> for TextViewLayer {
11480 type Checker = glib::value::GenericValueTypeChecker<Self>;
11481
11482 #[inline]
11483 unsafe fn from_value(value: &'a glib::Value) -> Self {
11484 skip_assert_initialized!();
11485 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
11486 }
11487}
11488
11489impl ToValue for TextViewLayer {
11490 #[inline]
11491 fn to_value(&self) -> glib::Value {
11492 let mut value = glib::Value::for_value_type::<Self>();
11493 unsafe {
11494 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
11495 }
11496 value
11497 }
11498
11499 #[inline]
11500 fn value_type(&self) -> glib::Type {
11501 Self::static_type()
11502 }
11503}
11504
11505impl From<TextViewLayer> for glib::Value {
11506 #[inline]
11507 fn from(v: TextViewLayer) -> Self {
11508 skip_assert_initialized!();
11509 ToValue::to_value(&v)
11510 }
11511}
11512
11513#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
11514#[non_exhaustive]
11515#[doc(alias = "GtkTextWindowType")]
11516pub enum TextWindowType {
11517 #[doc(alias = "GTK_TEXT_WINDOW_WIDGET")]
11518 Widget,
11519 #[doc(alias = "GTK_TEXT_WINDOW_TEXT")]
11520 Text,
11521 #[doc(alias = "GTK_TEXT_WINDOW_LEFT")]
11522 Left,
11523 #[doc(alias = "GTK_TEXT_WINDOW_RIGHT")]
11524 Right,
11525 #[doc(alias = "GTK_TEXT_WINDOW_TOP")]
11526 Top,
11527 #[doc(alias = "GTK_TEXT_WINDOW_BOTTOM")]
11528 Bottom,
11529 #[doc(hidden)]
11530 __Unknown(i32),
11531}
11532
11533#[doc(hidden)]
11534impl IntoGlib for TextWindowType {
11535 type GlibType = ffi::GtkTextWindowType;
11536
11537 #[inline]
11538 fn into_glib(self) -> ffi::GtkTextWindowType {
11539 match self {
11540 Self::Widget => ffi::GTK_TEXT_WINDOW_WIDGET,
11541 Self::Text => ffi::GTK_TEXT_WINDOW_TEXT,
11542 Self::Left => ffi::GTK_TEXT_WINDOW_LEFT,
11543 Self::Right => ffi::GTK_TEXT_WINDOW_RIGHT,
11544 Self::Top => ffi::GTK_TEXT_WINDOW_TOP,
11545 Self::Bottom => ffi::GTK_TEXT_WINDOW_BOTTOM,
11546 Self::__Unknown(value) => value,
11547 }
11548 }
11549}
11550
11551#[doc(hidden)]
11552impl FromGlib<ffi::GtkTextWindowType> for TextWindowType {
11553 #[inline]
11554 unsafe fn from_glib(value: ffi::GtkTextWindowType) -> Self {
11555 skip_assert_initialized!();
11556
11557 match value {
11558 ffi::GTK_TEXT_WINDOW_WIDGET => Self::Widget,
11559 ffi::GTK_TEXT_WINDOW_TEXT => Self::Text,
11560 ffi::GTK_TEXT_WINDOW_LEFT => Self::Left,
11561 ffi::GTK_TEXT_WINDOW_RIGHT => Self::Right,
11562 ffi::GTK_TEXT_WINDOW_TOP => Self::Top,
11563 ffi::GTK_TEXT_WINDOW_BOTTOM => Self::Bottom,
11564 value => Self::__Unknown(value),
11565 }
11566 }
11567}
11568
11569impl StaticType for TextWindowType {
11570 #[inline]
11571 #[doc(alias = "gtk_text_window_type_get_type")]
11572 fn static_type() -> glib::Type {
11573 unsafe { from_glib(ffi::gtk_text_window_type_get_type()) }
11574 }
11575}
11576
11577impl glib::HasParamSpec for TextWindowType {
11578 type ParamSpec = glib::ParamSpecEnum;
11579 type SetValue = Self;
11580 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
11581
11582 fn param_spec_builder() -> Self::BuilderFn {
11583 Self::ParamSpec::builder_with_default
11584 }
11585}
11586
11587impl glib::value::ValueType for TextWindowType {
11588 type Type = Self;
11589}
11590
11591unsafe impl<'a> glib::value::FromValue<'a> for TextWindowType {
11592 type Checker = glib::value::GenericValueTypeChecker<Self>;
11593
11594 #[inline]
11595 unsafe fn from_value(value: &'a glib::Value) -> Self {
11596 skip_assert_initialized!();
11597 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
11598 }
11599}
11600
11601impl ToValue for TextWindowType {
11602 #[inline]
11603 fn to_value(&self) -> glib::Value {
11604 let mut value = glib::Value::for_value_type::<Self>();
11605 unsafe {
11606 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
11607 }
11608 value
11609 }
11610
11611 #[inline]
11612 fn value_type(&self) -> glib::Type {
11613 Self::static_type()
11614 }
11615}
11616
11617impl From<TextWindowType> for glib::Value {
11618 #[inline]
11619 fn from(v: TextWindowType) -> Self {
11620 skip_assert_initialized!();
11621 ToValue::to_value(&v)
11622 }
11623}
11624
11625#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
11626#[non_exhaustive]
11627#[doc(alias = "GtkTreeViewColumnSizing")]
11628pub enum TreeViewColumnSizing {
11629 #[doc(alias = "GTK_TREE_VIEW_COLUMN_GROW_ONLY")]
11630 GrowOnly,
11631 #[doc(alias = "GTK_TREE_VIEW_COLUMN_AUTOSIZE")]
11632 Autosize,
11633 #[doc(alias = "GTK_TREE_VIEW_COLUMN_FIXED")]
11634 Fixed,
11635 #[doc(hidden)]
11636 __Unknown(i32),
11637}
11638
11639#[doc(hidden)]
11640impl IntoGlib for TreeViewColumnSizing {
11641 type GlibType = ffi::GtkTreeViewColumnSizing;
11642
11643 #[inline]
11644 fn into_glib(self) -> ffi::GtkTreeViewColumnSizing {
11645 match self {
11646 Self::GrowOnly => ffi::GTK_TREE_VIEW_COLUMN_GROW_ONLY,
11647 Self::Autosize => ffi::GTK_TREE_VIEW_COLUMN_AUTOSIZE,
11648 Self::Fixed => ffi::GTK_TREE_VIEW_COLUMN_FIXED,
11649 Self::__Unknown(value) => value,
11650 }
11651 }
11652}
11653
11654#[doc(hidden)]
11655impl FromGlib<ffi::GtkTreeViewColumnSizing> for TreeViewColumnSizing {
11656 #[inline]
11657 unsafe fn from_glib(value: ffi::GtkTreeViewColumnSizing) -> Self {
11658 skip_assert_initialized!();
11659
11660 match value {
11661 ffi::GTK_TREE_VIEW_COLUMN_GROW_ONLY => Self::GrowOnly,
11662 ffi::GTK_TREE_VIEW_COLUMN_AUTOSIZE => Self::Autosize,
11663 ffi::GTK_TREE_VIEW_COLUMN_FIXED => Self::Fixed,
11664 value => Self::__Unknown(value),
11665 }
11666 }
11667}
11668
11669impl StaticType for TreeViewColumnSizing {
11670 #[inline]
11671 #[doc(alias = "gtk_tree_view_column_sizing_get_type")]
11672 fn static_type() -> glib::Type {
11673 unsafe { from_glib(ffi::gtk_tree_view_column_sizing_get_type()) }
11674 }
11675}
11676
11677impl glib::HasParamSpec for TreeViewColumnSizing {
11678 type ParamSpec = glib::ParamSpecEnum;
11679 type SetValue = Self;
11680 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
11681
11682 fn param_spec_builder() -> Self::BuilderFn {
11683 Self::ParamSpec::builder_with_default
11684 }
11685}
11686
11687impl glib::value::ValueType for TreeViewColumnSizing {
11688 type Type = Self;
11689}
11690
11691unsafe impl<'a> glib::value::FromValue<'a> for TreeViewColumnSizing {
11692 type Checker = glib::value::GenericValueTypeChecker<Self>;
11693
11694 #[inline]
11695 unsafe fn from_value(value: &'a glib::Value) -> Self {
11696 skip_assert_initialized!();
11697 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
11698 }
11699}
11700
11701impl ToValue for TreeViewColumnSizing {
11702 #[inline]
11703 fn to_value(&self) -> glib::Value {
11704 let mut value = glib::Value::for_value_type::<Self>();
11705 unsafe {
11706 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
11707 }
11708 value
11709 }
11710
11711 #[inline]
11712 fn value_type(&self) -> glib::Type {
11713 Self::static_type()
11714 }
11715}
11716
11717impl From<TreeViewColumnSizing> for glib::Value {
11718 #[inline]
11719 fn from(v: TreeViewColumnSizing) -> Self {
11720 skip_assert_initialized!();
11721 ToValue::to_value(&v)
11722 }
11723}
11724
11725#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
11726#[non_exhaustive]
11727#[doc(alias = "GtkTreeViewDropPosition")]
11728pub enum TreeViewDropPosition {
11729 #[doc(alias = "GTK_TREE_VIEW_DROP_BEFORE")]
11730 Before,
11731 #[doc(alias = "GTK_TREE_VIEW_DROP_AFTER")]
11732 After,
11733 #[doc(alias = "GTK_TREE_VIEW_DROP_INTO_OR_BEFORE")]
11734 IntoOrBefore,
11735 #[doc(alias = "GTK_TREE_VIEW_DROP_INTO_OR_AFTER")]
11736 IntoOrAfter,
11737 #[doc(hidden)]
11738 __Unknown(i32),
11739}
11740
11741#[doc(hidden)]
11742impl IntoGlib for TreeViewDropPosition {
11743 type GlibType = ffi::GtkTreeViewDropPosition;
11744
11745 #[inline]
11746 fn into_glib(self) -> ffi::GtkTreeViewDropPosition {
11747 match self {
11748 Self::Before => ffi::GTK_TREE_VIEW_DROP_BEFORE,
11749 Self::After => ffi::GTK_TREE_VIEW_DROP_AFTER,
11750 Self::IntoOrBefore => ffi::GTK_TREE_VIEW_DROP_INTO_OR_BEFORE,
11751 Self::IntoOrAfter => ffi::GTK_TREE_VIEW_DROP_INTO_OR_AFTER,
11752 Self::__Unknown(value) => value,
11753 }
11754 }
11755}
11756
11757#[doc(hidden)]
11758impl FromGlib<ffi::GtkTreeViewDropPosition> for TreeViewDropPosition {
11759 #[inline]
11760 unsafe fn from_glib(value: ffi::GtkTreeViewDropPosition) -> Self {
11761 skip_assert_initialized!();
11762
11763 match value {
11764 ffi::GTK_TREE_VIEW_DROP_BEFORE => Self::Before,
11765 ffi::GTK_TREE_VIEW_DROP_AFTER => Self::After,
11766 ffi::GTK_TREE_VIEW_DROP_INTO_OR_BEFORE => Self::IntoOrBefore,
11767 ffi::GTK_TREE_VIEW_DROP_INTO_OR_AFTER => Self::IntoOrAfter,
11768 value => Self::__Unknown(value),
11769 }
11770 }
11771}
11772
11773impl StaticType for TreeViewDropPosition {
11774 #[inline]
11775 #[doc(alias = "gtk_tree_view_drop_position_get_type")]
11776 fn static_type() -> glib::Type {
11777 unsafe { from_glib(ffi::gtk_tree_view_drop_position_get_type()) }
11778 }
11779}
11780
11781impl glib::HasParamSpec for TreeViewDropPosition {
11782 type ParamSpec = glib::ParamSpecEnum;
11783 type SetValue = Self;
11784 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
11785
11786 fn param_spec_builder() -> Self::BuilderFn {
11787 Self::ParamSpec::builder_with_default
11788 }
11789}
11790
11791impl glib::value::ValueType for TreeViewDropPosition {
11792 type Type = Self;
11793}
11794
11795unsafe impl<'a> glib::value::FromValue<'a> for TreeViewDropPosition {
11796 type Checker = glib::value::GenericValueTypeChecker<Self>;
11797
11798 #[inline]
11799 unsafe fn from_value(value: &'a glib::Value) -> Self {
11800 skip_assert_initialized!();
11801 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
11802 }
11803}
11804
11805impl ToValue for TreeViewDropPosition {
11806 #[inline]
11807 fn to_value(&self) -> glib::Value {
11808 let mut value = glib::Value::for_value_type::<Self>();
11809 unsafe {
11810 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
11811 }
11812 value
11813 }
11814
11815 #[inline]
11816 fn value_type(&self) -> glib::Type {
11817 Self::static_type()
11818 }
11819}
11820
11821impl From<TreeViewDropPosition> for glib::Value {
11822 #[inline]
11823 fn from(v: TreeViewDropPosition) -> Self {
11824 skip_assert_initialized!();
11825 ToValue::to_value(&v)
11826 }
11827}
11828
11829#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
11830#[non_exhaustive]
11831#[doc(alias = "GtkTreeViewGridLines")]
11832pub enum TreeViewGridLines {
11833 #[doc(alias = "GTK_TREE_VIEW_GRID_LINES_NONE")]
11834 None,
11835 #[doc(alias = "GTK_TREE_VIEW_GRID_LINES_HORIZONTAL")]
11836 Horizontal,
11837 #[doc(alias = "GTK_TREE_VIEW_GRID_LINES_VERTICAL")]
11838 Vertical,
11839 #[doc(alias = "GTK_TREE_VIEW_GRID_LINES_BOTH")]
11840 Both,
11841 #[doc(hidden)]
11842 __Unknown(i32),
11843}
11844
11845#[doc(hidden)]
11846impl IntoGlib for TreeViewGridLines {
11847 type GlibType = ffi::GtkTreeViewGridLines;
11848
11849 #[inline]
11850 fn into_glib(self) -> ffi::GtkTreeViewGridLines {
11851 match self {
11852 Self::None => ffi::GTK_TREE_VIEW_GRID_LINES_NONE,
11853 Self::Horizontal => ffi::GTK_TREE_VIEW_GRID_LINES_HORIZONTAL,
11854 Self::Vertical => ffi::GTK_TREE_VIEW_GRID_LINES_VERTICAL,
11855 Self::Both => ffi::GTK_TREE_VIEW_GRID_LINES_BOTH,
11856 Self::__Unknown(value) => value,
11857 }
11858 }
11859}
11860
11861#[doc(hidden)]
11862impl FromGlib<ffi::GtkTreeViewGridLines> for TreeViewGridLines {
11863 #[inline]
11864 unsafe fn from_glib(value: ffi::GtkTreeViewGridLines) -> Self {
11865 skip_assert_initialized!();
11866
11867 match value {
11868 ffi::GTK_TREE_VIEW_GRID_LINES_NONE => Self::None,
11869 ffi::GTK_TREE_VIEW_GRID_LINES_HORIZONTAL => Self::Horizontal,
11870 ffi::GTK_TREE_VIEW_GRID_LINES_VERTICAL => Self::Vertical,
11871 ffi::GTK_TREE_VIEW_GRID_LINES_BOTH => Self::Both,
11872 value => Self::__Unknown(value),
11873 }
11874 }
11875}
11876
11877impl StaticType for TreeViewGridLines {
11878 #[inline]
11879 #[doc(alias = "gtk_tree_view_grid_lines_get_type")]
11880 fn static_type() -> glib::Type {
11881 unsafe { from_glib(ffi::gtk_tree_view_grid_lines_get_type()) }
11882 }
11883}
11884
11885impl glib::HasParamSpec for TreeViewGridLines {
11886 type ParamSpec = glib::ParamSpecEnum;
11887 type SetValue = Self;
11888 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
11889
11890 fn param_spec_builder() -> Self::BuilderFn {
11891 Self::ParamSpec::builder_with_default
11892 }
11893}
11894
11895impl glib::value::ValueType for TreeViewGridLines {
11896 type Type = Self;
11897}
11898
11899unsafe impl<'a> glib::value::FromValue<'a> for TreeViewGridLines {
11900 type Checker = glib::value::GenericValueTypeChecker<Self>;
11901
11902 #[inline]
11903 unsafe fn from_value(value: &'a glib::Value) -> Self {
11904 skip_assert_initialized!();
11905 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
11906 }
11907}
11908
11909impl ToValue for TreeViewGridLines {
11910 #[inline]
11911 fn to_value(&self) -> glib::Value {
11912 let mut value = glib::Value::for_value_type::<Self>();
11913 unsafe {
11914 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
11915 }
11916 value
11917 }
11918
11919 #[inline]
11920 fn value_type(&self) -> glib::Type {
11921 Self::static_type()
11922 }
11923}
11924
11925impl From<TreeViewGridLines> for glib::Value {
11926 #[inline]
11927 fn from(v: TreeViewGridLines) -> Self {
11928 skip_assert_initialized!();
11929 ToValue::to_value(&v)
11930 }
11931}
11932
11933#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
11934#[non_exhaustive]
11935#[doc(alias = "GtkUnit")]
11936pub enum Unit {
11937 #[doc(alias = "GTK_UNIT_NONE")]
11938 None,
11939 #[doc(alias = "GTK_UNIT_POINTS")]
11940 Points,
11941 #[doc(alias = "GTK_UNIT_INCH")]
11942 Inch,
11943 #[doc(alias = "GTK_UNIT_MM")]
11944 Mm,
11945 #[doc(hidden)]
11946 __Unknown(i32),
11947}
11948
11949#[doc(hidden)]
11950impl IntoGlib for Unit {
11951 type GlibType = ffi::GtkUnit;
11952
11953 #[inline]
11954 fn into_glib(self) -> ffi::GtkUnit {
11955 match self {
11956 Self::None => ffi::GTK_UNIT_NONE,
11957 Self::Points => ffi::GTK_UNIT_POINTS,
11958 Self::Inch => ffi::GTK_UNIT_INCH,
11959 Self::Mm => ffi::GTK_UNIT_MM,
11960 Self::__Unknown(value) => value,
11961 }
11962 }
11963}
11964
11965#[doc(hidden)]
11966impl FromGlib<ffi::GtkUnit> for Unit {
11967 #[inline]
11968 unsafe fn from_glib(value: ffi::GtkUnit) -> Self {
11969 skip_assert_initialized!();
11970
11971 match value {
11972 ffi::GTK_UNIT_NONE => Self::None,
11973 ffi::GTK_UNIT_POINTS => Self::Points,
11974 ffi::GTK_UNIT_INCH => Self::Inch,
11975 ffi::GTK_UNIT_MM => Self::Mm,
11976 value => Self::__Unknown(value),
11977 }
11978 }
11979}
11980
11981impl StaticType for Unit {
11982 #[inline]
11983 #[doc(alias = "gtk_unit_get_type")]
11984 fn static_type() -> glib::Type {
11985 unsafe { from_glib(ffi::gtk_unit_get_type()) }
11986 }
11987}
11988
11989impl glib::HasParamSpec for Unit {
11990 type ParamSpec = glib::ParamSpecEnum;
11991 type SetValue = Self;
11992 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
11993
11994 fn param_spec_builder() -> Self::BuilderFn {
11995 Self::ParamSpec::builder_with_default
11996 }
11997}
11998
11999impl glib::value::ValueType for Unit {
12000 type Type = Self;
12001}
12002
12003unsafe impl<'a> glib::value::FromValue<'a> for Unit {
12004 type Checker = glib::value::GenericValueTypeChecker<Self>;
12005
12006 #[inline]
12007 unsafe fn from_value(value: &'a glib::Value) -> Self {
12008 skip_assert_initialized!();
12009 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
12010 }
12011}
12012
12013impl ToValue for Unit {
12014 #[inline]
12015 fn to_value(&self) -> glib::Value {
12016 let mut value = glib::Value::for_value_type::<Self>();
12017 unsafe {
12018 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
12019 }
12020 value
12021 }
12022
12023 #[inline]
12024 fn value_type(&self) -> glib::Type {
12025 Self::static_type()
12026 }
12027}
12028
12029impl From<Unit> for glib::Value {
12030 #[inline]
12031 fn from(v: Unit) -> Self {
12032 skip_assert_initialized!();
12033 ToValue::to_value(&v)
12034 }
12035}
12036
12037#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
12038#[non_exhaustive]
12039#[doc(alias = "GtkWrapMode")]
12040pub enum WrapMode {
12041 #[doc(alias = "GTK_WRAP_NONE")]
12042 None,
12043 #[doc(alias = "GTK_WRAP_CHAR")]
12044 Char,
12045 #[doc(alias = "GTK_WRAP_WORD")]
12046 Word,
12047 #[doc(alias = "GTK_WRAP_WORD_CHAR")]
12048 WordChar,
12049 #[doc(hidden)]
12050 __Unknown(i32),
12051}
12052
12053#[doc(hidden)]
12054impl IntoGlib for WrapMode {
12055 type GlibType = ffi::GtkWrapMode;
12056
12057 #[inline]
12058 fn into_glib(self) -> ffi::GtkWrapMode {
12059 match self {
12060 Self::None => ffi::GTK_WRAP_NONE,
12061 Self::Char => ffi::GTK_WRAP_CHAR,
12062 Self::Word => ffi::GTK_WRAP_WORD,
12063 Self::WordChar => ffi::GTK_WRAP_WORD_CHAR,
12064 Self::__Unknown(value) => value,
12065 }
12066 }
12067}
12068
12069#[doc(hidden)]
12070impl FromGlib<ffi::GtkWrapMode> for WrapMode {
12071 #[inline]
12072 unsafe fn from_glib(value: ffi::GtkWrapMode) -> Self {
12073 skip_assert_initialized!();
12074
12075 match value {
12076 ffi::GTK_WRAP_NONE => Self::None,
12077 ffi::GTK_WRAP_CHAR => Self::Char,
12078 ffi::GTK_WRAP_WORD => Self::Word,
12079 ffi::GTK_WRAP_WORD_CHAR => Self::WordChar,
12080 value => Self::__Unknown(value),
12081 }
12082 }
12083}
12084
12085impl StaticType for WrapMode {
12086 #[inline]
12087 #[doc(alias = "gtk_wrap_mode_get_type")]
12088 fn static_type() -> glib::Type {
12089 unsafe { from_glib(ffi::gtk_wrap_mode_get_type()) }
12090 }
12091}
12092
12093impl glib::HasParamSpec for WrapMode {
12094 type ParamSpec = glib::ParamSpecEnum;
12095 type SetValue = Self;
12096 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
12097
12098 fn param_spec_builder() -> Self::BuilderFn {
12099 Self::ParamSpec::builder_with_default
12100 }
12101}
12102
12103impl glib::value::ValueType for WrapMode {
12104 type Type = Self;
12105}
12106
12107unsafe impl<'a> glib::value::FromValue<'a> for WrapMode {
12108 type Checker = glib::value::GenericValueTypeChecker<Self>;
12109
12110 #[inline]
12111 unsafe fn from_value(value: &'a glib::Value) -> Self {
12112 skip_assert_initialized!();
12113 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
12114 }
12115}
12116
12117impl ToValue for WrapMode {
12118 #[inline]
12119 fn to_value(&self) -> glib::Value {
12120 let mut value = glib::Value::for_value_type::<Self>();
12121 unsafe {
12122 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
12123 }
12124 value
12125 }
12126
12127 #[inline]
12128 fn value_type(&self) -> glib::Type {
12129 Self::static_type()
12130 }
12131}
12132
12133impl From<WrapMode> for glib::Value {
12134 #[inline]
12135 fn from(v: WrapMode) -> Self {
12136 skip_assert_initialized!();
12137 ToValue::to_value(&v)
12138 }
12139}