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#[cfg_attr(feature = "v4_10", deprecated = "Since 4.10")]
1993#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1994#[non_exhaustive]
1995#[doc(alias = "GtkAssistantPageType")]
1996pub enum AssistantPageType {
1997 #[doc(alias = "GTK_ASSISTANT_PAGE_CONTENT")]
1998 Content,
1999 #[doc(alias = "GTK_ASSISTANT_PAGE_INTRO")]
2000 Intro,
2001 #[doc(alias = "GTK_ASSISTANT_PAGE_CONFIRM")]
2002 Confirm,
2003 #[doc(alias = "GTK_ASSISTANT_PAGE_SUMMARY")]
2004 Summary,
2005 #[doc(alias = "GTK_ASSISTANT_PAGE_PROGRESS")]
2006 Progress,
2007 #[doc(alias = "GTK_ASSISTANT_PAGE_CUSTOM")]
2008 Custom,
2009 #[doc(hidden)]
2010 __Unknown(i32),
2011}
2012
2013#[allow(deprecated)]
2014#[doc(hidden)]
2015impl IntoGlib for AssistantPageType {
2016 type GlibType = ffi::GtkAssistantPageType;
2017
2018 #[inline]
2019 fn into_glib(self) -> ffi::GtkAssistantPageType {
2020 match self {
2021 Self::Content => ffi::GTK_ASSISTANT_PAGE_CONTENT,
2022 Self::Intro => ffi::GTK_ASSISTANT_PAGE_INTRO,
2023 Self::Confirm => ffi::GTK_ASSISTANT_PAGE_CONFIRM,
2024 Self::Summary => ffi::GTK_ASSISTANT_PAGE_SUMMARY,
2025 Self::Progress => ffi::GTK_ASSISTANT_PAGE_PROGRESS,
2026 Self::Custom => ffi::GTK_ASSISTANT_PAGE_CUSTOM,
2027 Self::__Unknown(value) => value,
2028 }
2029 }
2030}
2031
2032#[allow(deprecated)]
2033#[doc(hidden)]
2034impl FromGlib<ffi::GtkAssistantPageType> for AssistantPageType {
2035 #[inline]
2036 unsafe fn from_glib(value: ffi::GtkAssistantPageType) -> Self {
2037 skip_assert_initialized!();
2038
2039 match value {
2040 ffi::GTK_ASSISTANT_PAGE_CONTENT => Self::Content,
2041 ffi::GTK_ASSISTANT_PAGE_INTRO => Self::Intro,
2042 ffi::GTK_ASSISTANT_PAGE_CONFIRM => Self::Confirm,
2043 ffi::GTK_ASSISTANT_PAGE_SUMMARY => Self::Summary,
2044 ffi::GTK_ASSISTANT_PAGE_PROGRESS => Self::Progress,
2045 ffi::GTK_ASSISTANT_PAGE_CUSTOM => Self::Custom,
2046 value => Self::__Unknown(value),
2047 }
2048 }
2049}
2050
2051#[allow(deprecated)]
2052impl StaticType for AssistantPageType {
2053 #[inline]
2054 #[doc(alias = "gtk_assistant_page_type_get_type")]
2055 fn static_type() -> glib::Type {
2056 unsafe { from_glib(ffi::gtk_assistant_page_type_get_type()) }
2057 }
2058}
2059
2060#[allow(deprecated)]
2061impl glib::HasParamSpec for AssistantPageType {
2062 type ParamSpec = glib::ParamSpecEnum;
2063 type SetValue = Self;
2064 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2065
2066 fn param_spec_builder() -> Self::BuilderFn {
2067 Self::ParamSpec::builder_with_default
2068 }
2069}
2070
2071#[allow(deprecated)]
2072impl glib::value::ValueType for AssistantPageType {
2073 type Type = Self;
2074}
2075
2076#[allow(deprecated)]
2077unsafe impl<'a> glib::value::FromValue<'a> for AssistantPageType {
2078 type Checker = glib::value::GenericValueTypeChecker<Self>;
2079
2080 #[inline]
2081 unsafe fn from_value(value: &'a glib::Value) -> Self {
2082 skip_assert_initialized!();
2083 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
2084 }
2085}
2086
2087#[allow(deprecated)]
2088impl ToValue for AssistantPageType {
2089 #[inline]
2090 fn to_value(&self) -> glib::Value {
2091 let mut value = glib::Value::for_value_type::<Self>();
2092 unsafe {
2093 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2094 }
2095 value
2096 }
2097
2098 #[inline]
2099 fn value_type(&self) -> glib::Type {
2100 Self::static_type()
2101 }
2102}
2103
2104#[allow(deprecated)]
2105impl From<AssistantPageType> for glib::Value {
2106 #[inline]
2107 fn from(v: AssistantPageType) -> Self {
2108 skip_assert_initialized!();
2109 ToValue::to_value(&v)
2110 }
2111}
2112
2113#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2114#[non_exhaustive]
2115#[doc(alias = "GtkBaselinePosition")]
2116pub enum BaselinePosition {
2117 #[doc(alias = "GTK_BASELINE_POSITION_TOP")]
2118 Top,
2119 #[doc(alias = "GTK_BASELINE_POSITION_CENTER")]
2120 Center,
2121 #[doc(alias = "GTK_BASELINE_POSITION_BOTTOM")]
2122 Bottom,
2123 #[doc(hidden)]
2124 __Unknown(i32),
2125}
2126
2127#[doc(hidden)]
2128impl IntoGlib for BaselinePosition {
2129 type GlibType = ffi::GtkBaselinePosition;
2130
2131 #[inline]
2132 fn into_glib(self) -> ffi::GtkBaselinePosition {
2133 match self {
2134 Self::Top => ffi::GTK_BASELINE_POSITION_TOP,
2135 Self::Center => ffi::GTK_BASELINE_POSITION_CENTER,
2136 Self::Bottom => ffi::GTK_BASELINE_POSITION_BOTTOM,
2137 Self::__Unknown(value) => value,
2138 }
2139 }
2140}
2141
2142#[doc(hidden)]
2143impl FromGlib<ffi::GtkBaselinePosition> for BaselinePosition {
2144 #[inline]
2145 unsafe fn from_glib(value: ffi::GtkBaselinePosition) -> Self {
2146 skip_assert_initialized!();
2147
2148 match value {
2149 ffi::GTK_BASELINE_POSITION_TOP => Self::Top,
2150 ffi::GTK_BASELINE_POSITION_CENTER => Self::Center,
2151 ffi::GTK_BASELINE_POSITION_BOTTOM => Self::Bottom,
2152 value => Self::__Unknown(value),
2153 }
2154 }
2155}
2156
2157impl StaticType for BaselinePosition {
2158 #[inline]
2159 #[doc(alias = "gtk_baseline_position_get_type")]
2160 fn static_type() -> glib::Type {
2161 unsafe { from_glib(ffi::gtk_baseline_position_get_type()) }
2162 }
2163}
2164
2165impl glib::HasParamSpec for BaselinePosition {
2166 type ParamSpec = glib::ParamSpecEnum;
2167 type SetValue = Self;
2168 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2169
2170 fn param_spec_builder() -> Self::BuilderFn {
2171 Self::ParamSpec::builder_with_default
2172 }
2173}
2174
2175impl glib::value::ValueType for BaselinePosition {
2176 type Type = Self;
2177}
2178
2179unsafe impl<'a> glib::value::FromValue<'a> for BaselinePosition {
2180 type Checker = glib::value::GenericValueTypeChecker<Self>;
2181
2182 #[inline]
2183 unsafe fn from_value(value: &'a glib::Value) -> Self {
2184 skip_assert_initialized!();
2185 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
2186 }
2187}
2188
2189impl ToValue for BaselinePosition {
2190 #[inline]
2191 fn to_value(&self) -> glib::Value {
2192 let mut value = glib::Value::for_value_type::<Self>();
2193 unsafe {
2194 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2195 }
2196 value
2197 }
2198
2199 #[inline]
2200 fn value_type(&self) -> glib::Type {
2201 Self::static_type()
2202 }
2203}
2204
2205impl From<BaselinePosition> for glib::Value {
2206 #[inline]
2207 fn from(v: BaselinePosition) -> Self {
2208 skip_assert_initialized!();
2209 ToValue::to_value(&v)
2210 }
2211}
2212
2213#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2214#[non_exhaustive]
2215#[doc(alias = "GtkBorderStyle")]
2216pub enum BorderStyle {
2217 #[doc(alias = "GTK_BORDER_STYLE_NONE")]
2218 None,
2219 #[doc(alias = "GTK_BORDER_STYLE_HIDDEN")]
2220 Hidden,
2221 #[doc(alias = "GTK_BORDER_STYLE_SOLID")]
2222 Solid,
2223 #[doc(alias = "GTK_BORDER_STYLE_INSET")]
2224 Inset,
2225 #[doc(alias = "GTK_BORDER_STYLE_OUTSET")]
2226 Outset,
2227 #[doc(alias = "GTK_BORDER_STYLE_DOTTED")]
2228 Dotted,
2229 #[doc(alias = "GTK_BORDER_STYLE_DASHED")]
2230 Dashed,
2231 #[doc(alias = "GTK_BORDER_STYLE_DOUBLE")]
2232 Double,
2233 #[doc(alias = "GTK_BORDER_STYLE_GROOVE")]
2234 Groove,
2235 #[doc(alias = "GTK_BORDER_STYLE_RIDGE")]
2236 Ridge,
2237 #[doc(hidden)]
2238 __Unknown(i32),
2239}
2240
2241#[doc(hidden)]
2242impl IntoGlib for BorderStyle {
2243 type GlibType = ffi::GtkBorderStyle;
2244
2245 #[inline]
2246 fn into_glib(self) -> ffi::GtkBorderStyle {
2247 match self {
2248 Self::None => ffi::GTK_BORDER_STYLE_NONE,
2249 Self::Hidden => ffi::GTK_BORDER_STYLE_HIDDEN,
2250 Self::Solid => ffi::GTK_BORDER_STYLE_SOLID,
2251 Self::Inset => ffi::GTK_BORDER_STYLE_INSET,
2252 Self::Outset => ffi::GTK_BORDER_STYLE_OUTSET,
2253 Self::Dotted => ffi::GTK_BORDER_STYLE_DOTTED,
2254 Self::Dashed => ffi::GTK_BORDER_STYLE_DASHED,
2255 Self::Double => ffi::GTK_BORDER_STYLE_DOUBLE,
2256 Self::Groove => ffi::GTK_BORDER_STYLE_GROOVE,
2257 Self::Ridge => ffi::GTK_BORDER_STYLE_RIDGE,
2258 Self::__Unknown(value) => value,
2259 }
2260 }
2261}
2262
2263#[doc(hidden)]
2264impl FromGlib<ffi::GtkBorderStyle> for BorderStyle {
2265 #[inline]
2266 unsafe fn from_glib(value: ffi::GtkBorderStyle) -> Self {
2267 skip_assert_initialized!();
2268
2269 match value {
2270 ffi::GTK_BORDER_STYLE_NONE => Self::None,
2271 ffi::GTK_BORDER_STYLE_HIDDEN => Self::Hidden,
2272 ffi::GTK_BORDER_STYLE_SOLID => Self::Solid,
2273 ffi::GTK_BORDER_STYLE_INSET => Self::Inset,
2274 ffi::GTK_BORDER_STYLE_OUTSET => Self::Outset,
2275 ffi::GTK_BORDER_STYLE_DOTTED => Self::Dotted,
2276 ffi::GTK_BORDER_STYLE_DASHED => Self::Dashed,
2277 ffi::GTK_BORDER_STYLE_DOUBLE => Self::Double,
2278 ffi::GTK_BORDER_STYLE_GROOVE => Self::Groove,
2279 ffi::GTK_BORDER_STYLE_RIDGE => Self::Ridge,
2280 value => Self::__Unknown(value),
2281 }
2282 }
2283}
2284
2285impl StaticType for BorderStyle {
2286 #[inline]
2287 #[doc(alias = "gtk_border_style_get_type")]
2288 fn static_type() -> glib::Type {
2289 unsafe { from_glib(ffi::gtk_border_style_get_type()) }
2290 }
2291}
2292
2293impl glib::HasParamSpec for BorderStyle {
2294 type ParamSpec = glib::ParamSpecEnum;
2295 type SetValue = Self;
2296 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2297
2298 fn param_spec_builder() -> Self::BuilderFn {
2299 Self::ParamSpec::builder_with_default
2300 }
2301}
2302
2303impl glib::value::ValueType for BorderStyle {
2304 type Type = Self;
2305}
2306
2307unsafe impl<'a> glib::value::FromValue<'a> for BorderStyle {
2308 type Checker = glib::value::GenericValueTypeChecker<Self>;
2309
2310 #[inline]
2311 unsafe fn from_value(value: &'a glib::Value) -> Self {
2312 skip_assert_initialized!();
2313 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
2314 }
2315}
2316
2317impl ToValue for BorderStyle {
2318 #[inline]
2319 fn to_value(&self) -> glib::Value {
2320 let mut value = glib::Value::for_value_type::<Self>();
2321 unsafe {
2322 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2323 }
2324 value
2325 }
2326
2327 #[inline]
2328 fn value_type(&self) -> glib::Type {
2329 Self::static_type()
2330 }
2331}
2332
2333impl From<BorderStyle> for glib::Value {
2334 #[inline]
2335 fn from(v: BorderStyle) -> Self {
2336 skip_assert_initialized!();
2337 ToValue::to_value(&v)
2338 }
2339}
2340
2341#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2342#[non_exhaustive]
2343#[doc(alias = "GtkBuilderError")]
2344pub enum BuilderError {
2345 #[doc(alias = "GTK_BUILDER_ERROR_INVALID_TYPE_FUNCTION")]
2346 InvalidTypeFunction,
2347 #[doc(alias = "GTK_BUILDER_ERROR_UNHANDLED_TAG")]
2348 UnhandledTag,
2349 #[doc(alias = "GTK_BUILDER_ERROR_MISSING_ATTRIBUTE")]
2350 MissingAttribute,
2351 #[doc(alias = "GTK_BUILDER_ERROR_INVALID_ATTRIBUTE")]
2352 InvalidAttribute,
2353 #[doc(alias = "GTK_BUILDER_ERROR_INVALID_TAG")]
2354 InvalidTag,
2355 #[doc(alias = "GTK_BUILDER_ERROR_MISSING_PROPERTY_VALUE")]
2356 MissingPropertyValue,
2357 #[doc(alias = "GTK_BUILDER_ERROR_INVALID_VALUE")]
2358 InvalidValue,
2359 #[doc(alias = "GTK_BUILDER_ERROR_VERSION_MISMATCH")]
2360 VersionMismatch,
2361 #[doc(alias = "GTK_BUILDER_ERROR_DUPLICATE_ID")]
2362 DuplicateId,
2363 #[doc(alias = "GTK_BUILDER_ERROR_OBJECT_TYPE_REFUSED")]
2364 ObjectTypeRefused,
2365 #[doc(alias = "GTK_BUILDER_ERROR_TEMPLATE_MISMATCH")]
2366 TemplateMismatch,
2367 #[doc(alias = "GTK_BUILDER_ERROR_INVALID_PROPERTY")]
2368 InvalidProperty,
2369 #[doc(alias = "GTK_BUILDER_ERROR_INVALID_SIGNAL")]
2370 InvalidSignal,
2371 #[doc(alias = "GTK_BUILDER_ERROR_INVALID_ID")]
2372 InvalidId,
2373 #[doc(alias = "GTK_BUILDER_ERROR_INVALID_FUNCTION")]
2374 InvalidFunction,
2375 #[doc(hidden)]
2376 __Unknown(i32),
2377}
2378
2379#[doc(hidden)]
2380impl IntoGlib for BuilderError {
2381 type GlibType = ffi::GtkBuilderError;
2382
2383 fn into_glib(self) -> ffi::GtkBuilderError {
2384 match self {
2385 Self::InvalidTypeFunction => ffi::GTK_BUILDER_ERROR_INVALID_TYPE_FUNCTION,
2386 Self::UnhandledTag => ffi::GTK_BUILDER_ERROR_UNHANDLED_TAG,
2387 Self::MissingAttribute => ffi::GTK_BUILDER_ERROR_MISSING_ATTRIBUTE,
2388 Self::InvalidAttribute => ffi::GTK_BUILDER_ERROR_INVALID_ATTRIBUTE,
2389 Self::InvalidTag => ffi::GTK_BUILDER_ERROR_INVALID_TAG,
2390 Self::MissingPropertyValue => ffi::GTK_BUILDER_ERROR_MISSING_PROPERTY_VALUE,
2391 Self::InvalidValue => ffi::GTK_BUILDER_ERROR_INVALID_VALUE,
2392 Self::VersionMismatch => ffi::GTK_BUILDER_ERROR_VERSION_MISMATCH,
2393 Self::DuplicateId => ffi::GTK_BUILDER_ERROR_DUPLICATE_ID,
2394 Self::ObjectTypeRefused => ffi::GTK_BUILDER_ERROR_OBJECT_TYPE_REFUSED,
2395 Self::TemplateMismatch => ffi::GTK_BUILDER_ERROR_TEMPLATE_MISMATCH,
2396 Self::InvalidProperty => ffi::GTK_BUILDER_ERROR_INVALID_PROPERTY,
2397 Self::InvalidSignal => ffi::GTK_BUILDER_ERROR_INVALID_SIGNAL,
2398 Self::InvalidId => ffi::GTK_BUILDER_ERROR_INVALID_ID,
2399 Self::InvalidFunction => ffi::GTK_BUILDER_ERROR_INVALID_FUNCTION,
2400 Self::__Unknown(value) => value,
2401 }
2402 }
2403}
2404
2405#[doc(hidden)]
2406impl FromGlib<ffi::GtkBuilderError> for BuilderError {
2407 unsafe fn from_glib(value: ffi::GtkBuilderError) -> Self {
2408 skip_assert_initialized!();
2409
2410 match value {
2411 ffi::GTK_BUILDER_ERROR_INVALID_TYPE_FUNCTION => Self::InvalidTypeFunction,
2412 ffi::GTK_BUILDER_ERROR_UNHANDLED_TAG => Self::UnhandledTag,
2413 ffi::GTK_BUILDER_ERROR_MISSING_ATTRIBUTE => Self::MissingAttribute,
2414 ffi::GTK_BUILDER_ERROR_INVALID_ATTRIBUTE => Self::InvalidAttribute,
2415 ffi::GTK_BUILDER_ERROR_INVALID_TAG => Self::InvalidTag,
2416 ffi::GTK_BUILDER_ERROR_MISSING_PROPERTY_VALUE => Self::MissingPropertyValue,
2417 ffi::GTK_BUILDER_ERROR_INVALID_VALUE => Self::InvalidValue,
2418 ffi::GTK_BUILDER_ERROR_VERSION_MISMATCH => Self::VersionMismatch,
2419 ffi::GTK_BUILDER_ERROR_DUPLICATE_ID => Self::DuplicateId,
2420 ffi::GTK_BUILDER_ERROR_OBJECT_TYPE_REFUSED => Self::ObjectTypeRefused,
2421 ffi::GTK_BUILDER_ERROR_TEMPLATE_MISMATCH => Self::TemplateMismatch,
2422 ffi::GTK_BUILDER_ERROR_INVALID_PROPERTY => Self::InvalidProperty,
2423 ffi::GTK_BUILDER_ERROR_INVALID_SIGNAL => Self::InvalidSignal,
2424 ffi::GTK_BUILDER_ERROR_INVALID_ID => Self::InvalidId,
2425 ffi::GTK_BUILDER_ERROR_INVALID_FUNCTION => Self::InvalidFunction,
2426 value => Self::__Unknown(value),
2427 }
2428 }
2429}
2430
2431impl glib::error::ErrorDomain for BuilderError {
2432 #[inline]
2433 fn domain() -> glib::Quark {
2434 skip_assert_initialized!();
2435
2436 unsafe { from_glib(ffi::gtk_builder_error_quark()) }
2437 }
2438
2439 #[inline]
2440 fn code(self) -> i32 {
2441 self.into_glib()
2442 }
2443
2444 #[inline]
2445 #[allow(clippy::match_single_binding)]
2446 fn from(code: i32) -> Option<Self> {
2447 skip_assert_initialized!();
2448 match unsafe { from_glib(code) } {
2449 value => Some(value),
2450 }
2451 }
2452}
2453
2454impl StaticType for BuilderError {
2455 #[inline]
2456 #[doc(alias = "gtk_builder_error_get_type")]
2457 fn static_type() -> glib::Type {
2458 unsafe { from_glib(ffi::gtk_builder_error_get_type()) }
2459 }
2460}
2461
2462impl glib::HasParamSpec for BuilderError {
2463 type ParamSpec = glib::ParamSpecEnum;
2464 type SetValue = Self;
2465 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2466
2467 fn param_spec_builder() -> Self::BuilderFn {
2468 Self::ParamSpec::builder_with_default
2469 }
2470}
2471
2472impl glib::value::ValueType for BuilderError {
2473 type Type = Self;
2474}
2475
2476unsafe impl<'a> glib::value::FromValue<'a> for BuilderError {
2477 type Checker = glib::value::GenericValueTypeChecker<Self>;
2478
2479 #[inline]
2480 unsafe fn from_value(value: &'a glib::Value) -> Self {
2481 skip_assert_initialized!();
2482 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
2483 }
2484}
2485
2486impl ToValue for BuilderError {
2487 #[inline]
2488 fn to_value(&self) -> glib::Value {
2489 let mut value = glib::Value::for_value_type::<Self>();
2490 unsafe {
2491 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2492 }
2493 value
2494 }
2495
2496 #[inline]
2497 fn value_type(&self) -> glib::Type {
2498 Self::static_type()
2499 }
2500}
2501
2502impl From<BuilderError> for glib::Value {
2503 #[inline]
2504 fn from(v: BuilderError) -> Self {
2505 skip_assert_initialized!();
2506 ToValue::to_value(&v)
2507 }
2508}
2509
2510#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2511#[non_exhaustive]
2512#[doc(alias = "GtkButtonsType")]
2513pub enum ButtonsType {
2514 #[doc(alias = "GTK_BUTTONS_NONE")]
2515 None,
2516 #[doc(alias = "GTK_BUTTONS_OK")]
2517 Ok,
2518 #[doc(alias = "GTK_BUTTONS_CLOSE")]
2519 Close,
2520 #[doc(alias = "GTK_BUTTONS_CANCEL")]
2521 Cancel,
2522 #[doc(alias = "GTK_BUTTONS_YES_NO")]
2523 YesNo,
2524 #[doc(alias = "GTK_BUTTONS_OK_CANCEL")]
2525 OkCancel,
2526 #[doc(hidden)]
2527 __Unknown(i32),
2528}
2529
2530#[doc(hidden)]
2531impl IntoGlib for ButtonsType {
2532 type GlibType = ffi::GtkButtonsType;
2533
2534 #[inline]
2535 fn into_glib(self) -> ffi::GtkButtonsType {
2536 match self {
2537 Self::None => ffi::GTK_BUTTONS_NONE,
2538 Self::Ok => ffi::GTK_BUTTONS_OK,
2539 Self::Close => ffi::GTK_BUTTONS_CLOSE,
2540 Self::Cancel => ffi::GTK_BUTTONS_CANCEL,
2541 Self::YesNo => ffi::GTK_BUTTONS_YES_NO,
2542 Self::OkCancel => ffi::GTK_BUTTONS_OK_CANCEL,
2543 Self::__Unknown(value) => value,
2544 }
2545 }
2546}
2547
2548#[doc(hidden)]
2549impl FromGlib<ffi::GtkButtonsType> for ButtonsType {
2550 #[inline]
2551 unsafe fn from_glib(value: ffi::GtkButtonsType) -> Self {
2552 skip_assert_initialized!();
2553
2554 match value {
2555 ffi::GTK_BUTTONS_NONE => Self::None,
2556 ffi::GTK_BUTTONS_OK => Self::Ok,
2557 ffi::GTK_BUTTONS_CLOSE => Self::Close,
2558 ffi::GTK_BUTTONS_CANCEL => Self::Cancel,
2559 ffi::GTK_BUTTONS_YES_NO => Self::YesNo,
2560 ffi::GTK_BUTTONS_OK_CANCEL => Self::OkCancel,
2561 value => Self::__Unknown(value),
2562 }
2563 }
2564}
2565
2566impl StaticType for ButtonsType {
2567 #[inline]
2568 #[doc(alias = "gtk_buttons_type_get_type")]
2569 fn static_type() -> glib::Type {
2570 unsafe { from_glib(ffi::gtk_buttons_type_get_type()) }
2571 }
2572}
2573
2574impl glib::HasParamSpec for ButtonsType {
2575 type ParamSpec = glib::ParamSpecEnum;
2576 type SetValue = Self;
2577 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2578
2579 fn param_spec_builder() -> Self::BuilderFn {
2580 Self::ParamSpec::builder_with_default
2581 }
2582}
2583
2584impl glib::value::ValueType for ButtonsType {
2585 type Type = Self;
2586}
2587
2588unsafe impl<'a> glib::value::FromValue<'a> for ButtonsType {
2589 type Checker = glib::value::GenericValueTypeChecker<Self>;
2590
2591 #[inline]
2592 unsafe fn from_value(value: &'a glib::Value) -> Self {
2593 skip_assert_initialized!();
2594 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
2595 }
2596}
2597
2598impl ToValue for ButtonsType {
2599 #[inline]
2600 fn to_value(&self) -> glib::Value {
2601 let mut value = glib::Value::for_value_type::<Self>();
2602 unsafe {
2603 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2604 }
2605 value
2606 }
2607
2608 #[inline]
2609 fn value_type(&self) -> glib::Type {
2610 Self::static_type()
2611 }
2612}
2613
2614impl From<ButtonsType> for glib::Value {
2615 #[inline]
2616 fn from(v: ButtonsType) -> Self {
2617 skip_assert_initialized!();
2618 ToValue::to_value(&v)
2619 }
2620}
2621
2622#[cfg_attr(feature = "v4_20", deprecated = "Since 4.20")]
2623#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2624#[non_exhaustive]
2625#[doc(alias = "GtkCellRendererAccelMode")]
2626pub enum CellRendererAccelMode {
2627 #[doc(alias = "GTK_CELL_RENDERER_ACCEL_MODE_GTK")]
2628 Gtk,
2629 #[doc(alias = "GTK_CELL_RENDERER_ACCEL_MODE_OTHER")]
2630 Other,
2631 #[doc(hidden)]
2632 __Unknown(i32),
2633}
2634
2635#[allow(deprecated)]
2636#[doc(hidden)]
2637impl IntoGlib for CellRendererAccelMode {
2638 type GlibType = ffi::GtkCellRendererAccelMode;
2639
2640 #[inline]
2641 fn into_glib(self) -> ffi::GtkCellRendererAccelMode {
2642 match self {
2643 Self::Gtk => ffi::GTK_CELL_RENDERER_ACCEL_MODE_GTK,
2644 Self::Other => ffi::GTK_CELL_RENDERER_ACCEL_MODE_OTHER,
2645 Self::__Unknown(value) => value,
2646 }
2647 }
2648}
2649
2650#[allow(deprecated)]
2651#[doc(hidden)]
2652impl FromGlib<ffi::GtkCellRendererAccelMode> for CellRendererAccelMode {
2653 #[inline]
2654 unsafe fn from_glib(value: ffi::GtkCellRendererAccelMode) -> Self {
2655 skip_assert_initialized!();
2656
2657 match value {
2658 ffi::GTK_CELL_RENDERER_ACCEL_MODE_GTK => Self::Gtk,
2659 ffi::GTK_CELL_RENDERER_ACCEL_MODE_OTHER => Self::Other,
2660 value => Self::__Unknown(value),
2661 }
2662 }
2663}
2664
2665#[allow(deprecated)]
2666impl StaticType for CellRendererAccelMode {
2667 #[inline]
2668 #[doc(alias = "gtk_cell_renderer_accel_mode_get_type")]
2669 fn static_type() -> glib::Type {
2670 unsafe { from_glib(ffi::gtk_cell_renderer_accel_mode_get_type()) }
2671 }
2672}
2673
2674#[allow(deprecated)]
2675impl glib::HasParamSpec for CellRendererAccelMode {
2676 type ParamSpec = glib::ParamSpecEnum;
2677 type SetValue = Self;
2678 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2679
2680 fn param_spec_builder() -> Self::BuilderFn {
2681 Self::ParamSpec::builder_with_default
2682 }
2683}
2684
2685#[allow(deprecated)]
2686impl glib::value::ValueType for CellRendererAccelMode {
2687 type Type = Self;
2688}
2689
2690#[allow(deprecated)]
2691unsafe impl<'a> glib::value::FromValue<'a> for CellRendererAccelMode {
2692 type Checker = glib::value::GenericValueTypeChecker<Self>;
2693
2694 #[inline]
2695 unsafe fn from_value(value: &'a glib::Value) -> Self {
2696 skip_assert_initialized!();
2697 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
2698 }
2699}
2700
2701#[allow(deprecated)]
2702impl ToValue for CellRendererAccelMode {
2703 #[inline]
2704 fn to_value(&self) -> glib::Value {
2705 let mut value = glib::Value::for_value_type::<Self>();
2706 unsafe {
2707 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2708 }
2709 value
2710 }
2711
2712 #[inline]
2713 fn value_type(&self) -> glib::Type {
2714 Self::static_type()
2715 }
2716}
2717
2718#[allow(deprecated)]
2719impl From<CellRendererAccelMode> for glib::Value {
2720 #[inline]
2721 fn from(v: CellRendererAccelMode) -> Self {
2722 skip_assert_initialized!();
2723 ToValue::to_value(&v)
2724 }
2725}
2726
2727#[cfg_attr(feature = "v4_20", deprecated = "Since 4.20")]
2728#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2729#[non_exhaustive]
2730#[doc(alias = "GtkCellRendererMode")]
2731pub enum CellRendererMode {
2732 #[doc(alias = "GTK_CELL_RENDERER_MODE_INERT")]
2733 Inert,
2734 #[doc(alias = "GTK_CELL_RENDERER_MODE_ACTIVATABLE")]
2735 Activatable,
2736 #[doc(alias = "GTK_CELL_RENDERER_MODE_EDITABLE")]
2737 Editable,
2738 #[doc(hidden)]
2739 __Unknown(i32),
2740}
2741
2742#[allow(deprecated)]
2743#[doc(hidden)]
2744impl IntoGlib for CellRendererMode {
2745 type GlibType = ffi::GtkCellRendererMode;
2746
2747 #[inline]
2748 fn into_glib(self) -> ffi::GtkCellRendererMode {
2749 match self {
2750 Self::Inert => ffi::GTK_CELL_RENDERER_MODE_INERT,
2751 Self::Activatable => ffi::GTK_CELL_RENDERER_MODE_ACTIVATABLE,
2752 Self::Editable => ffi::GTK_CELL_RENDERER_MODE_EDITABLE,
2753 Self::__Unknown(value) => value,
2754 }
2755 }
2756}
2757
2758#[allow(deprecated)]
2759#[doc(hidden)]
2760impl FromGlib<ffi::GtkCellRendererMode> for CellRendererMode {
2761 #[inline]
2762 unsafe fn from_glib(value: ffi::GtkCellRendererMode) -> Self {
2763 skip_assert_initialized!();
2764
2765 match value {
2766 ffi::GTK_CELL_RENDERER_MODE_INERT => Self::Inert,
2767 ffi::GTK_CELL_RENDERER_MODE_ACTIVATABLE => Self::Activatable,
2768 ffi::GTK_CELL_RENDERER_MODE_EDITABLE => Self::Editable,
2769 value => Self::__Unknown(value),
2770 }
2771 }
2772}
2773
2774#[allow(deprecated)]
2775impl StaticType for CellRendererMode {
2776 #[inline]
2777 #[doc(alias = "gtk_cell_renderer_mode_get_type")]
2778 fn static_type() -> glib::Type {
2779 unsafe { from_glib(ffi::gtk_cell_renderer_mode_get_type()) }
2780 }
2781}
2782
2783#[allow(deprecated)]
2784impl glib::HasParamSpec for CellRendererMode {
2785 type ParamSpec = glib::ParamSpecEnum;
2786 type SetValue = Self;
2787 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2788
2789 fn param_spec_builder() -> Self::BuilderFn {
2790 Self::ParamSpec::builder_with_default
2791 }
2792}
2793
2794#[allow(deprecated)]
2795impl glib::value::ValueType for CellRendererMode {
2796 type Type = Self;
2797}
2798
2799#[allow(deprecated)]
2800unsafe impl<'a> glib::value::FromValue<'a> for CellRendererMode {
2801 type Checker = glib::value::GenericValueTypeChecker<Self>;
2802
2803 #[inline]
2804 unsafe fn from_value(value: &'a glib::Value) -> Self {
2805 skip_assert_initialized!();
2806 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
2807 }
2808}
2809
2810#[allow(deprecated)]
2811impl ToValue for CellRendererMode {
2812 #[inline]
2813 fn to_value(&self) -> glib::Value {
2814 let mut value = glib::Value::for_value_type::<Self>();
2815 unsafe {
2816 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2817 }
2818 value
2819 }
2820
2821 #[inline]
2822 fn value_type(&self) -> glib::Type {
2823 Self::static_type()
2824 }
2825}
2826
2827#[allow(deprecated)]
2828impl From<CellRendererMode> for glib::Value {
2829 #[inline]
2830 fn from(v: CellRendererMode) -> Self {
2831 skip_assert_initialized!();
2832 ToValue::to_value(&v)
2833 }
2834}
2835
2836#[cfg(feature = "v4_10")]
2837#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
2838#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2839#[non_exhaustive]
2840#[doc(alias = "GtkCollation")]
2841pub enum Collation {
2842 #[doc(alias = "GTK_COLLATION_NONE")]
2843 None,
2844 #[doc(alias = "GTK_COLLATION_UNICODE")]
2845 Unicode,
2846 #[doc(alias = "GTK_COLLATION_FILENAME")]
2847 Filename,
2848 #[doc(hidden)]
2849 __Unknown(i32),
2850}
2851
2852#[cfg(feature = "v4_10")]
2853#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
2854#[doc(hidden)]
2855impl IntoGlib for Collation {
2856 type GlibType = ffi::GtkCollation;
2857
2858 #[inline]
2859 fn into_glib(self) -> ffi::GtkCollation {
2860 match self {
2861 Self::None => ffi::GTK_COLLATION_NONE,
2862 Self::Unicode => ffi::GTK_COLLATION_UNICODE,
2863 Self::Filename => ffi::GTK_COLLATION_FILENAME,
2864 Self::__Unknown(value) => value,
2865 }
2866 }
2867}
2868
2869#[cfg(feature = "v4_10")]
2870#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
2871#[doc(hidden)]
2872impl FromGlib<ffi::GtkCollation> for Collation {
2873 #[inline]
2874 unsafe fn from_glib(value: ffi::GtkCollation) -> Self {
2875 skip_assert_initialized!();
2876
2877 match value {
2878 ffi::GTK_COLLATION_NONE => Self::None,
2879 ffi::GTK_COLLATION_UNICODE => Self::Unicode,
2880 ffi::GTK_COLLATION_FILENAME => Self::Filename,
2881 value => Self::__Unknown(value),
2882 }
2883 }
2884}
2885
2886#[cfg(feature = "v4_10")]
2887#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
2888impl StaticType for Collation {
2889 #[inline]
2890 #[doc(alias = "gtk_collation_get_type")]
2891 fn static_type() -> glib::Type {
2892 unsafe { from_glib(ffi::gtk_collation_get_type()) }
2893 }
2894}
2895
2896#[cfg(feature = "v4_10")]
2897#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
2898impl glib::HasParamSpec for Collation {
2899 type ParamSpec = glib::ParamSpecEnum;
2900 type SetValue = Self;
2901 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2902
2903 fn param_spec_builder() -> Self::BuilderFn {
2904 Self::ParamSpec::builder_with_default
2905 }
2906}
2907
2908#[cfg(feature = "v4_10")]
2909#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
2910impl glib::value::ValueType for Collation {
2911 type Type = Self;
2912}
2913
2914#[cfg(feature = "v4_10")]
2915#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
2916unsafe impl<'a> glib::value::FromValue<'a> for Collation {
2917 type Checker = glib::value::GenericValueTypeChecker<Self>;
2918
2919 #[inline]
2920 unsafe fn from_value(value: &'a glib::Value) -> Self {
2921 skip_assert_initialized!();
2922 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
2923 }
2924}
2925
2926#[cfg(feature = "v4_10")]
2927#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
2928impl ToValue for Collation {
2929 #[inline]
2930 fn to_value(&self) -> glib::Value {
2931 let mut value = glib::Value::for_value_type::<Self>();
2932 unsafe {
2933 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2934 }
2935 value
2936 }
2937
2938 #[inline]
2939 fn value_type(&self) -> glib::Type {
2940 Self::static_type()
2941 }
2942}
2943
2944#[cfg(feature = "v4_10")]
2945#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
2946impl From<Collation> for glib::Value {
2947 #[inline]
2948 fn from(v: Collation) -> Self {
2949 skip_assert_initialized!();
2950 ToValue::to_value(&v)
2951 }
2952}
2953
2954#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2955#[non_exhaustive]
2956#[doc(alias = "GtkConstraintAttribute")]
2957pub enum ConstraintAttribute {
2958 #[doc(alias = "GTK_CONSTRAINT_ATTRIBUTE_NONE")]
2959 None,
2960 #[doc(alias = "GTK_CONSTRAINT_ATTRIBUTE_LEFT")]
2961 Left,
2962 #[doc(alias = "GTK_CONSTRAINT_ATTRIBUTE_RIGHT")]
2963 Right,
2964 #[doc(alias = "GTK_CONSTRAINT_ATTRIBUTE_TOP")]
2965 Top,
2966 #[doc(alias = "GTK_CONSTRAINT_ATTRIBUTE_BOTTOM")]
2967 Bottom,
2968 #[doc(alias = "GTK_CONSTRAINT_ATTRIBUTE_START")]
2969 Start,
2970 #[doc(alias = "GTK_CONSTRAINT_ATTRIBUTE_END")]
2971 End,
2972 #[doc(alias = "GTK_CONSTRAINT_ATTRIBUTE_WIDTH")]
2973 Width,
2974 #[doc(alias = "GTK_CONSTRAINT_ATTRIBUTE_HEIGHT")]
2975 Height,
2976 #[doc(alias = "GTK_CONSTRAINT_ATTRIBUTE_CENTER_X")]
2977 CenterX,
2978 #[doc(alias = "GTK_CONSTRAINT_ATTRIBUTE_CENTER_Y")]
2979 CenterY,
2980 #[doc(alias = "GTK_CONSTRAINT_ATTRIBUTE_BASELINE")]
2981 Baseline,
2982 #[doc(hidden)]
2983 __Unknown(i32),
2984}
2985
2986#[doc(hidden)]
2987impl IntoGlib for ConstraintAttribute {
2988 type GlibType = ffi::GtkConstraintAttribute;
2989
2990 #[inline]
2991 fn into_glib(self) -> ffi::GtkConstraintAttribute {
2992 match self {
2993 Self::None => ffi::GTK_CONSTRAINT_ATTRIBUTE_NONE,
2994 Self::Left => ffi::GTK_CONSTRAINT_ATTRIBUTE_LEFT,
2995 Self::Right => ffi::GTK_CONSTRAINT_ATTRIBUTE_RIGHT,
2996 Self::Top => ffi::GTK_CONSTRAINT_ATTRIBUTE_TOP,
2997 Self::Bottom => ffi::GTK_CONSTRAINT_ATTRIBUTE_BOTTOM,
2998 Self::Start => ffi::GTK_CONSTRAINT_ATTRIBUTE_START,
2999 Self::End => ffi::GTK_CONSTRAINT_ATTRIBUTE_END,
3000 Self::Width => ffi::GTK_CONSTRAINT_ATTRIBUTE_WIDTH,
3001 Self::Height => ffi::GTK_CONSTRAINT_ATTRIBUTE_HEIGHT,
3002 Self::CenterX => ffi::GTK_CONSTRAINT_ATTRIBUTE_CENTER_X,
3003 Self::CenterY => ffi::GTK_CONSTRAINT_ATTRIBUTE_CENTER_Y,
3004 Self::Baseline => ffi::GTK_CONSTRAINT_ATTRIBUTE_BASELINE,
3005 Self::__Unknown(value) => value,
3006 }
3007 }
3008}
3009
3010#[doc(hidden)]
3011impl FromGlib<ffi::GtkConstraintAttribute> for ConstraintAttribute {
3012 #[inline]
3013 unsafe fn from_glib(value: ffi::GtkConstraintAttribute) -> Self {
3014 skip_assert_initialized!();
3015
3016 match value {
3017 ffi::GTK_CONSTRAINT_ATTRIBUTE_NONE => Self::None,
3018 ffi::GTK_CONSTRAINT_ATTRIBUTE_LEFT => Self::Left,
3019 ffi::GTK_CONSTRAINT_ATTRIBUTE_RIGHT => Self::Right,
3020 ffi::GTK_CONSTRAINT_ATTRIBUTE_TOP => Self::Top,
3021 ffi::GTK_CONSTRAINT_ATTRIBUTE_BOTTOM => Self::Bottom,
3022 ffi::GTK_CONSTRAINT_ATTRIBUTE_START => Self::Start,
3023 ffi::GTK_CONSTRAINT_ATTRIBUTE_END => Self::End,
3024 ffi::GTK_CONSTRAINT_ATTRIBUTE_WIDTH => Self::Width,
3025 ffi::GTK_CONSTRAINT_ATTRIBUTE_HEIGHT => Self::Height,
3026 ffi::GTK_CONSTRAINT_ATTRIBUTE_CENTER_X => Self::CenterX,
3027 ffi::GTK_CONSTRAINT_ATTRIBUTE_CENTER_Y => Self::CenterY,
3028 ffi::GTK_CONSTRAINT_ATTRIBUTE_BASELINE => Self::Baseline,
3029 value => Self::__Unknown(value),
3030 }
3031 }
3032}
3033
3034impl StaticType for ConstraintAttribute {
3035 #[inline]
3036 #[doc(alias = "gtk_constraint_attribute_get_type")]
3037 fn static_type() -> glib::Type {
3038 unsafe { from_glib(ffi::gtk_constraint_attribute_get_type()) }
3039 }
3040}
3041
3042impl glib::HasParamSpec for ConstraintAttribute {
3043 type ParamSpec = glib::ParamSpecEnum;
3044 type SetValue = Self;
3045 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
3046
3047 fn param_spec_builder() -> Self::BuilderFn {
3048 Self::ParamSpec::builder_with_default
3049 }
3050}
3051
3052impl glib::value::ValueType for ConstraintAttribute {
3053 type Type = Self;
3054}
3055
3056unsafe impl<'a> glib::value::FromValue<'a> for ConstraintAttribute {
3057 type Checker = glib::value::GenericValueTypeChecker<Self>;
3058
3059 #[inline]
3060 unsafe fn from_value(value: &'a glib::Value) -> Self {
3061 skip_assert_initialized!();
3062 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
3063 }
3064}
3065
3066impl ToValue for ConstraintAttribute {
3067 #[inline]
3068 fn to_value(&self) -> glib::Value {
3069 let mut value = glib::Value::for_value_type::<Self>();
3070 unsafe {
3071 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
3072 }
3073 value
3074 }
3075
3076 #[inline]
3077 fn value_type(&self) -> glib::Type {
3078 Self::static_type()
3079 }
3080}
3081
3082impl From<ConstraintAttribute> for glib::Value {
3083 #[inline]
3084 fn from(v: ConstraintAttribute) -> Self {
3085 skip_assert_initialized!();
3086 ToValue::to_value(&v)
3087 }
3088}
3089
3090#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3091#[non_exhaustive]
3092#[doc(alias = "GtkConstraintRelation")]
3093pub enum ConstraintRelation {
3094 #[doc(alias = "GTK_CONSTRAINT_RELATION_LE")]
3095 Le,
3096 #[doc(alias = "GTK_CONSTRAINT_RELATION_EQ")]
3097 Eq,
3098 #[doc(alias = "GTK_CONSTRAINT_RELATION_GE")]
3099 Ge,
3100 #[doc(hidden)]
3101 __Unknown(i32),
3102}
3103
3104#[doc(hidden)]
3105impl IntoGlib for ConstraintRelation {
3106 type GlibType = ffi::GtkConstraintRelation;
3107
3108 #[inline]
3109 fn into_glib(self) -> ffi::GtkConstraintRelation {
3110 match self {
3111 Self::Le => ffi::GTK_CONSTRAINT_RELATION_LE,
3112 Self::Eq => ffi::GTK_CONSTRAINT_RELATION_EQ,
3113 Self::Ge => ffi::GTK_CONSTRAINT_RELATION_GE,
3114 Self::__Unknown(value) => value,
3115 }
3116 }
3117}
3118
3119#[doc(hidden)]
3120impl FromGlib<ffi::GtkConstraintRelation> for ConstraintRelation {
3121 #[inline]
3122 unsafe fn from_glib(value: ffi::GtkConstraintRelation) -> Self {
3123 skip_assert_initialized!();
3124
3125 match value {
3126 ffi::GTK_CONSTRAINT_RELATION_LE => Self::Le,
3127 ffi::GTK_CONSTRAINT_RELATION_EQ => Self::Eq,
3128 ffi::GTK_CONSTRAINT_RELATION_GE => Self::Ge,
3129 value => Self::__Unknown(value),
3130 }
3131 }
3132}
3133
3134impl StaticType for ConstraintRelation {
3135 #[inline]
3136 #[doc(alias = "gtk_constraint_relation_get_type")]
3137 fn static_type() -> glib::Type {
3138 unsafe { from_glib(ffi::gtk_constraint_relation_get_type()) }
3139 }
3140}
3141
3142impl glib::HasParamSpec for ConstraintRelation {
3143 type ParamSpec = glib::ParamSpecEnum;
3144 type SetValue = Self;
3145 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
3146
3147 fn param_spec_builder() -> Self::BuilderFn {
3148 Self::ParamSpec::builder_with_default
3149 }
3150}
3151
3152impl glib::value::ValueType for ConstraintRelation {
3153 type Type = Self;
3154}
3155
3156unsafe impl<'a> glib::value::FromValue<'a> for ConstraintRelation {
3157 type Checker = glib::value::GenericValueTypeChecker<Self>;
3158
3159 #[inline]
3160 unsafe fn from_value(value: &'a glib::Value) -> Self {
3161 skip_assert_initialized!();
3162 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
3163 }
3164}
3165
3166impl ToValue for ConstraintRelation {
3167 #[inline]
3168 fn to_value(&self) -> glib::Value {
3169 let mut value = glib::Value::for_value_type::<Self>();
3170 unsafe {
3171 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
3172 }
3173 value
3174 }
3175
3176 #[inline]
3177 fn value_type(&self) -> glib::Type {
3178 Self::static_type()
3179 }
3180}
3181
3182impl From<ConstraintRelation> for glib::Value {
3183 #[inline]
3184 fn from(v: ConstraintRelation) -> Self {
3185 skip_assert_initialized!();
3186 ToValue::to_value(&v)
3187 }
3188}
3189
3190#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3191#[non_exhaustive]
3192#[doc(alias = "GtkConstraintStrength")]
3193pub enum ConstraintStrength {
3194 #[doc(alias = "GTK_CONSTRAINT_STRENGTH_REQUIRED")]
3195 Required,
3196 #[doc(alias = "GTK_CONSTRAINT_STRENGTH_STRONG")]
3197 Strong,
3198 #[doc(alias = "GTK_CONSTRAINT_STRENGTH_MEDIUM")]
3199 Medium,
3200 #[doc(alias = "GTK_CONSTRAINT_STRENGTH_WEAK")]
3201 Weak,
3202 #[doc(hidden)]
3203 __Unknown(i32),
3204}
3205
3206#[doc(hidden)]
3207impl IntoGlib for ConstraintStrength {
3208 type GlibType = ffi::GtkConstraintStrength;
3209
3210 #[inline]
3211 fn into_glib(self) -> ffi::GtkConstraintStrength {
3212 match self {
3213 Self::Required => ffi::GTK_CONSTRAINT_STRENGTH_REQUIRED,
3214 Self::Strong => ffi::GTK_CONSTRAINT_STRENGTH_STRONG,
3215 Self::Medium => ffi::GTK_CONSTRAINT_STRENGTH_MEDIUM,
3216 Self::Weak => ffi::GTK_CONSTRAINT_STRENGTH_WEAK,
3217 Self::__Unknown(value) => value,
3218 }
3219 }
3220}
3221
3222#[doc(hidden)]
3223impl FromGlib<ffi::GtkConstraintStrength> for ConstraintStrength {
3224 #[inline]
3225 unsafe fn from_glib(value: ffi::GtkConstraintStrength) -> Self {
3226 skip_assert_initialized!();
3227
3228 match value {
3229 ffi::GTK_CONSTRAINT_STRENGTH_REQUIRED => Self::Required,
3230 ffi::GTK_CONSTRAINT_STRENGTH_STRONG => Self::Strong,
3231 ffi::GTK_CONSTRAINT_STRENGTH_MEDIUM => Self::Medium,
3232 ffi::GTK_CONSTRAINT_STRENGTH_WEAK => Self::Weak,
3233 value => Self::__Unknown(value),
3234 }
3235 }
3236}
3237
3238impl StaticType for ConstraintStrength {
3239 #[inline]
3240 #[doc(alias = "gtk_constraint_strength_get_type")]
3241 fn static_type() -> glib::Type {
3242 unsafe { from_glib(ffi::gtk_constraint_strength_get_type()) }
3243 }
3244}
3245
3246impl glib::HasParamSpec for ConstraintStrength {
3247 type ParamSpec = glib::ParamSpecEnum;
3248 type SetValue = Self;
3249 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
3250
3251 fn param_spec_builder() -> Self::BuilderFn {
3252 Self::ParamSpec::builder_with_default
3253 }
3254}
3255
3256impl glib::value::ValueType for ConstraintStrength {
3257 type Type = Self;
3258}
3259
3260unsafe impl<'a> glib::value::FromValue<'a> for ConstraintStrength {
3261 type Checker = glib::value::GenericValueTypeChecker<Self>;
3262
3263 #[inline]
3264 unsafe fn from_value(value: &'a glib::Value) -> Self {
3265 skip_assert_initialized!();
3266 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
3267 }
3268}
3269
3270impl ToValue for ConstraintStrength {
3271 #[inline]
3272 fn to_value(&self) -> glib::Value {
3273 let mut value = glib::Value::for_value_type::<Self>();
3274 unsafe {
3275 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
3276 }
3277 value
3278 }
3279
3280 #[inline]
3281 fn value_type(&self) -> glib::Type {
3282 Self::static_type()
3283 }
3284}
3285
3286impl From<ConstraintStrength> for glib::Value {
3287 #[inline]
3288 fn from(v: ConstraintStrength) -> Self {
3289 skip_assert_initialized!();
3290 ToValue::to_value(&v)
3291 }
3292}
3293
3294#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3295#[non_exhaustive]
3296#[doc(alias = "GtkConstraintVflParserError")]
3297pub enum ConstraintVflParserError {
3298 #[doc(alias = "GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_SYMBOL")]
3299 InvalidSymbol,
3300 #[doc(alias = "GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_ATTRIBUTE")]
3301 InvalidAttribute,
3302 #[doc(alias = "GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_VIEW")]
3303 InvalidView,
3304 #[doc(alias = "GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_METRIC")]
3305 InvalidMetric,
3306 #[doc(alias = "GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_PRIORITY")]
3307 InvalidPriority,
3308 #[doc(alias = "GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_RELATION")]
3309 InvalidRelation,
3310 #[doc(hidden)]
3311 __Unknown(i32),
3312}
3313
3314#[doc(hidden)]
3315impl IntoGlib for ConstraintVflParserError {
3316 type GlibType = ffi::GtkConstraintVflParserError;
3317
3318 #[inline]
3319 fn into_glib(self) -> ffi::GtkConstraintVflParserError {
3320 match self {
3321 Self::InvalidSymbol => ffi::GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_SYMBOL,
3322 Self::InvalidAttribute => ffi::GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_ATTRIBUTE,
3323 Self::InvalidView => ffi::GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_VIEW,
3324 Self::InvalidMetric => ffi::GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_METRIC,
3325 Self::InvalidPriority => ffi::GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_PRIORITY,
3326 Self::InvalidRelation => ffi::GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_RELATION,
3327 Self::__Unknown(value) => value,
3328 }
3329 }
3330}
3331
3332#[doc(hidden)]
3333impl FromGlib<ffi::GtkConstraintVflParserError> for ConstraintVflParserError {
3334 #[inline]
3335 unsafe fn from_glib(value: ffi::GtkConstraintVflParserError) -> Self {
3336 skip_assert_initialized!();
3337
3338 match value {
3339 ffi::GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_SYMBOL => Self::InvalidSymbol,
3340 ffi::GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_ATTRIBUTE => Self::InvalidAttribute,
3341 ffi::GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_VIEW => Self::InvalidView,
3342 ffi::GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_METRIC => Self::InvalidMetric,
3343 ffi::GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_PRIORITY => Self::InvalidPriority,
3344 ffi::GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_RELATION => Self::InvalidRelation,
3345 value => Self::__Unknown(value),
3346 }
3347 }
3348}
3349
3350impl glib::error::ErrorDomain for ConstraintVflParserError {
3351 #[inline]
3352 fn domain() -> glib::Quark {
3353 skip_assert_initialized!();
3354
3355 unsafe { from_glib(ffi::gtk_constraint_vfl_parser_error_quark()) }
3356 }
3357
3358 #[inline]
3359 fn code(self) -> i32 {
3360 self.into_glib()
3361 }
3362
3363 #[inline]
3364 #[allow(clippy::match_single_binding)]
3365 fn from(code: i32) -> Option<Self> {
3366 skip_assert_initialized!();
3367 match unsafe { from_glib(code) } {
3368 value => Some(value),
3369 }
3370 }
3371}
3372
3373impl StaticType for ConstraintVflParserError {
3374 #[inline]
3375 #[doc(alias = "gtk_constraint_vfl_parser_error_get_type")]
3376 fn static_type() -> glib::Type {
3377 unsafe { from_glib(ffi::gtk_constraint_vfl_parser_error_get_type()) }
3378 }
3379}
3380
3381impl glib::HasParamSpec for ConstraintVflParserError {
3382 type ParamSpec = glib::ParamSpecEnum;
3383 type SetValue = Self;
3384 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
3385
3386 fn param_spec_builder() -> Self::BuilderFn {
3387 Self::ParamSpec::builder_with_default
3388 }
3389}
3390
3391impl glib::value::ValueType for ConstraintVflParserError {
3392 type Type = Self;
3393}
3394
3395unsafe impl<'a> glib::value::FromValue<'a> for ConstraintVflParserError {
3396 type Checker = glib::value::GenericValueTypeChecker<Self>;
3397
3398 #[inline]
3399 unsafe fn from_value(value: &'a glib::Value) -> Self {
3400 skip_assert_initialized!();
3401 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
3402 }
3403}
3404
3405impl ToValue for ConstraintVflParserError {
3406 #[inline]
3407 fn to_value(&self) -> glib::Value {
3408 let mut value = glib::Value::for_value_type::<Self>();
3409 unsafe {
3410 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
3411 }
3412 value
3413 }
3414
3415 #[inline]
3416 fn value_type(&self) -> glib::Type {
3417 Self::static_type()
3418 }
3419}
3420
3421impl From<ConstraintVflParserError> for glib::Value {
3422 #[inline]
3423 fn from(v: ConstraintVflParserError) -> Self {
3424 skip_assert_initialized!();
3425 ToValue::to_value(&v)
3426 }
3427}
3428
3429#[cfg(feature = "v4_8")]
3430#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
3431#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3432#[non_exhaustive]
3433#[doc(alias = "GtkContentFit")]
3434pub enum ContentFit {
3435 #[doc(alias = "GTK_CONTENT_FIT_FILL")]
3436 Fill,
3437 #[doc(alias = "GTK_CONTENT_FIT_CONTAIN")]
3438 Contain,
3439 #[doc(alias = "GTK_CONTENT_FIT_COVER")]
3440 Cover,
3441 #[doc(alias = "GTK_CONTENT_FIT_SCALE_DOWN")]
3442 ScaleDown,
3443 #[doc(hidden)]
3444 __Unknown(i32),
3445}
3446
3447#[cfg(feature = "v4_8")]
3448#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
3449#[doc(hidden)]
3450impl IntoGlib for ContentFit {
3451 type GlibType = ffi::GtkContentFit;
3452
3453 #[inline]
3454 fn into_glib(self) -> ffi::GtkContentFit {
3455 match self {
3456 Self::Fill => ffi::GTK_CONTENT_FIT_FILL,
3457 Self::Contain => ffi::GTK_CONTENT_FIT_CONTAIN,
3458 Self::Cover => ffi::GTK_CONTENT_FIT_COVER,
3459 Self::ScaleDown => ffi::GTK_CONTENT_FIT_SCALE_DOWN,
3460 Self::__Unknown(value) => value,
3461 }
3462 }
3463}
3464
3465#[cfg(feature = "v4_8")]
3466#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
3467#[doc(hidden)]
3468impl FromGlib<ffi::GtkContentFit> for ContentFit {
3469 #[inline]
3470 unsafe fn from_glib(value: ffi::GtkContentFit) -> Self {
3471 skip_assert_initialized!();
3472
3473 match value {
3474 ffi::GTK_CONTENT_FIT_FILL => Self::Fill,
3475 ffi::GTK_CONTENT_FIT_CONTAIN => Self::Contain,
3476 ffi::GTK_CONTENT_FIT_COVER => Self::Cover,
3477 ffi::GTK_CONTENT_FIT_SCALE_DOWN => Self::ScaleDown,
3478 value => Self::__Unknown(value),
3479 }
3480 }
3481}
3482
3483#[cfg(feature = "v4_8")]
3484#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
3485impl StaticType for ContentFit {
3486 #[inline]
3487 #[doc(alias = "gtk_content_fit_get_type")]
3488 fn static_type() -> glib::Type {
3489 unsafe { from_glib(ffi::gtk_content_fit_get_type()) }
3490 }
3491}
3492
3493#[cfg(feature = "v4_8")]
3494#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
3495impl glib::HasParamSpec for ContentFit {
3496 type ParamSpec = glib::ParamSpecEnum;
3497 type SetValue = Self;
3498 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
3499
3500 fn param_spec_builder() -> Self::BuilderFn {
3501 Self::ParamSpec::builder_with_default
3502 }
3503}
3504
3505#[cfg(feature = "v4_8")]
3506#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
3507impl glib::value::ValueType for ContentFit {
3508 type Type = Self;
3509}
3510
3511#[cfg(feature = "v4_8")]
3512#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
3513unsafe impl<'a> glib::value::FromValue<'a> for ContentFit {
3514 type Checker = glib::value::GenericValueTypeChecker<Self>;
3515
3516 #[inline]
3517 unsafe fn from_value(value: &'a glib::Value) -> Self {
3518 skip_assert_initialized!();
3519 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
3520 }
3521}
3522
3523#[cfg(feature = "v4_8")]
3524#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
3525impl ToValue for ContentFit {
3526 #[inline]
3527 fn to_value(&self) -> glib::Value {
3528 let mut value = glib::Value::for_value_type::<Self>();
3529 unsafe {
3530 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
3531 }
3532 value
3533 }
3534
3535 #[inline]
3536 fn value_type(&self) -> glib::Type {
3537 Self::static_type()
3538 }
3539}
3540
3541#[cfg(feature = "v4_8")]
3542#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
3543impl From<ContentFit> for glib::Value {
3544 #[inline]
3545 fn from(v: ContentFit) -> Self {
3546 skip_assert_initialized!();
3547 ToValue::to_value(&v)
3548 }
3549}
3550
3551#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3552#[non_exhaustive]
3553#[doc(alias = "GtkCornerType")]
3554pub enum CornerType {
3555 #[doc(alias = "GTK_CORNER_TOP_LEFT")]
3556 TopLeft,
3557 #[doc(alias = "GTK_CORNER_BOTTOM_LEFT")]
3558 BottomLeft,
3559 #[doc(alias = "GTK_CORNER_TOP_RIGHT")]
3560 TopRight,
3561 #[doc(alias = "GTK_CORNER_BOTTOM_RIGHT")]
3562 BottomRight,
3563 #[doc(hidden)]
3564 __Unknown(i32),
3565}
3566
3567#[doc(hidden)]
3568impl IntoGlib for CornerType {
3569 type GlibType = ffi::GtkCornerType;
3570
3571 #[inline]
3572 fn into_glib(self) -> ffi::GtkCornerType {
3573 match self {
3574 Self::TopLeft => ffi::GTK_CORNER_TOP_LEFT,
3575 Self::BottomLeft => ffi::GTK_CORNER_BOTTOM_LEFT,
3576 Self::TopRight => ffi::GTK_CORNER_TOP_RIGHT,
3577 Self::BottomRight => ffi::GTK_CORNER_BOTTOM_RIGHT,
3578 Self::__Unknown(value) => value,
3579 }
3580 }
3581}
3582
3583#[doc(hidden)]
3584impl FromGlib<ffi::GtkCornerType> for CornerType {
3585 #[inline]
3586 unsafe fn from_glib(value: ffi::GtkCornerType) -> Self {
3587 skip_assert_initialized!();
3588
3589 match value {
3590 ffi::GTK_CORNER_TOP_LEFT => Self::TopLeft,
3591 ffi::GTK_CORNER_BOTTOM_LEFT => Self::BottomLeft,
3592 ffi::GTK_CORNER_TOP_RIGHT => Self::TopRight,
3593 ffi::GTK_CORNER_BOTTOM_RIGHT => Self::BottomRight,
3594 value => Self::__Unknown(value),
3595 }
3596 }
3597}
3598
3599impl StaticType for CornerType {
3600 #[inline]
3601 #[doc(alias = "gtk_corner_type_get_type")]
3602 fn static_type() -> glib::Type {
3603 unsafe { from_glib(ffi::gtk_corner_type_get_type()) }
3604 }
3605}
3606
3607impl glib::HasParamSpec for CornerType {
3608 type ParamSpec = glib::ParamSpecEnum;
3609 type SetValue = Self;
3610 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
3611
3612 fn param_spec_builder() -> Self::BuilderFn {
3613 Self::ParamSpec::builder_with_default
3614 }
3615}
3616
3617impl glib::value::ValueType for CornerType {
3618 type Type = Self;
3619}
3620
3621unsafe impl<'a> glib::value::FromValue<'a> for CornerType {
3622 type Checker = glib::value::GenericValueTypeChecker<Self>;
3623
3624 #[inline]
3625 unsafe fn from_value(value: &'a glib::Value) -> Self {
3626 skip_assert_initialized!();
3627 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
3628 }
3629}
3630
3631impl ToValue for CornerType {
3632 #[inline]
3633 fn to_value(&self) -> glib::Value {
3634 let mut value = glib::Value::for_value_type::<Self>();
3635 unsafe {
3636 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
3637 }
3638 value
3639 }
3640
3641 #[inline]
3642 fn value_type(&self) -> glib::Type {
3643 Self::static_type()
3644 }
3645}
3646
3647impl From<CornerType> for glib::Value {
3648 #[inline]
3649 fn from(v: CornerType) -> Self {
3650 skip_assert_initialized!();
3651 ToValue::to_value(&v)
3652 }
3653}
3654
3655#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3656#[non_exhaustive]
3657#[doc(alias = "GtkCssParserError")]
3658pub enum CssParserError {
3659 #[doc(alias = "GTK_CSS_PARSER_ERROR_FAILED")]
3660 Failed,
3661 #[doc(alias = "GTK_CSS_PARSER_ERROR_SYNTAX")]
3662 Syntax,
3663 #[doc(alias = "GTK_CSS_PARSER_ERROR_IMPORT")]
3664 Import,
3665 #[doc(alias = "GTK_CSS_PARSER_ERROR_NAME")]
3666 Name,
3667 #[doc(alias = "GTK_CSS_PARSER_ERROR_UNKNOWN_VALUE")]
3668 UnknownValue,
3669 #[doc(hidden)]
3670 __Unknown(i32),
3671}
3672
3673#[doc(hidden)]
3674impl IntoGlib for CssParserError {
3675 type GlibType = ffi::GtkCssParserError;
3676
3677 #[inline]
3678 fn into_glib(self) -> ffi::GtkCssParserError {
3679 match self {
3680 Self::Failed => ffi::GTK_CSS_PARSER_ERROR_FAILED,
3681 Self::Syntax => ffi::GTK_CSS_PARSER_ERROR_SYNTAX,
3682 Self::Import => ffi::GTK_CSS_PARSER_ERROR_IMPORT,
3683 Self::Name => ffi::GTK_CSS_PARSER_ERROR_NAME,
3684 Self::UnknownValue => ffi::GTK_CSS_PARSER_ERROR_UNKNOWN_VALUE,
3685 Self::__Unknown(value) => value,
3686 }
3687 }
3688}
3689
3690#[doc(hidden)]
3691impl FromGlib<ffi::GtkCssParserError> for CssParserError {
3692 #[inline]
3693 unsafe fn from_glib(value: ffi::GtkCssParserError) -> Self {
3694 skip_assert_initialized!();
3695
3696 match value {
3697 ffi::GTK_CSS_PARSER_ERROR_FAILED => Self::Failed,
3698 ffi::GTK_CSS_PARSER_ERROR_SYNTAX => Self::Syntax,
3699 ffi::GTK_CSS_PARSER_ERROR_IMPORT => Self::Import,
3700 ffi::GTK_CSS_PARSER_ERROR_NAME => Self::Name,
3701 ffi::GTK_CSS_PARSER_ERROR_UNKNOWN_VALUE => Self::UnknownValue,
3702 value => Self::__Unknown(value),
3703 }
3704 }
3705}
3706
3707impl glib::error::ErrorDomain for CssParserError {
3708 #[inline]
3709 fn domain() -> glib::Quark {
3710 skip_assert_initialized!();
3711
3712 unsafe { from_glib(ffi::gtk_css_parser_error_quark()) }
3713 }
3714
3715 #[inline]
3716 fn code(self) -> i32 {
3717 self.into_glib()
3718 }
3719
3720 #[inline]
3721 #[allow(clippy::match_single_binding)]
3722 fn from(code: i32) -> Option<Self> {
3723 skip_assert_initialized!();
3724 match unsafe { from_glib(code) } {
3725 Self::__Unknown(_) => Some(Self::Failed),
3726 value => Some(value),
3727 }
3728 }
3729}
3730
3731#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3732#[non_exhaustive]
3733#[doc(alias = "GtkCssParserWarning")]
3734pub enum CssParserWarning {
3735 #[doc(alias = "GTK_CSS_PARSER_WARNING_DEPRECATED")]
3736 Deprecated,
3737 #[doc(alias = "GTK_CSS_PARSER_WARNING_SYNTAX")]
3738 Syntax,
3739 #[doc(alias = "GTK_CSS_PARSER_WARNING_UNIMPLEMENTED")]
3740 Unimplemented,
3741 #[doc(hidden)]
3742 __Unknown(i32),
3743}
3744
3745#[doc(hidden)]
3746impl IntoGlib for CssParserWarning {
3747 type GlibType = ffi::GtkCssParserWarning;
3748
3749 #[inline]
3750 fn into_glib(self) -> ffi::GtkCssParserWarning {
3751 match self {
3752 Self::Deprecated => ffi::GTK_CSS_PARSER_WARNING_DEPRECATED,
3753 Self::Syntax => ffi::GTK_CSS_PARSER_WARNING_SYNTAX,
3754 Self::Unimplemented => ffi::GTK_CSS_PARSER_WARNING_UNIMPLEMENTED,
3755 Self::__Unknown(value) => value,
3756 }
3757 }
3758}
3759
3760#[doc(hidden)]
3761impl FromGlib<ffi::GtkCssParserWarning> for CssParserWarning {
3762 #[inline]
3763 unsafe fn from_glib(value: ffi::GtkCssParserWarning) -> Self {
3764 skip_assert_initialized!();
3765
3766 match value {
3767 ffi::GTK_CSS_PARSER_WARNING_DEPRECATED => Self::Deprecated,
3768 ffi::GTK_CSS_PARSER_WARNING_SYNTAX => Self::Syntax,
3769 ffi::GTK_CSS_PARSER_WARNING_UNIMPLEMENTED => Self::Unimplemented,
3770 value => Self::__Unknown(value),
3771 }
3772 }
3773}
3774
3775#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3776#[non_exhaustive]
3777#[doc(alias = "GtkDeleteType")]
3778pub enum DeleteType {
3779 #[doc(alias = "GTK_DELETE_CHARS")]
3780 Chars,
3781 #[doc(alias = "GTK_DELETE_WORD_ENDS")]
3782 WordEnds,
3783 #[doc(alias = "GTK_DELETE_WORDS")]
3784 Words,
3785 #[doc(alias = "GTK_DELETE_DISPLAY_LINES")]
3786 DisplayLines,
3787 #[doc(alias = "GTK_DELETE_DISPLAY_LINE_ENDS")]
3788 DisplayLineEnds,
3789 #[doc(alias = "GTK_DELETE_PARAGRAPH_ENDS")]
3790 ParagraphEnds,
3791 #[doc(alias = "GTK_DELETE_PARAGRAPHS")]
3792 Paragraphs,
3793 #[doc(alias = "GTK_DELETE_WHITESPACE")]
3794 Whitespace,
3795 #[doc(hidden)]
3796 __Unknown(i32),
3797}
3798
3799#[doc(hidden)]
3800impl IntoGlib for DeleteType {
3801 type GlibType = ffi::GtkDeleteType;
3802
3803 #[inline]
3804 fn into_glib(self) -> ffi::GtkDeleteType {
3805 match self {
3806 Self::Chars => ffi::GTK_DELETE_CHARS,
3807 Self::WordEnds => ffi::GTK_DELETE_WORD_ENDS,
3808 Self::Words => ffi::GTK_DELETE_WORDS,
3809 Self::DisplayLines => ffi::GTK_DELETE_DISPLAY_LINES,
3810 Self::DisplayLineEnds => ffi::GTK_DELETE_DISPLAY_LINE_ENDS,
3811 Self::ParagraphEnds => ffi::GTK_DELETE_PARAGRAPH_ENDS,
3812 Self::Paragraphs => ffi::GTK_DELETE_PARAGRAPHS,
3813 Self::Whitespace => ffi::GTK_DELETE_WHITESPACE,
3814 Self::__Unknown(value) => value,
3815 }
3816 }
3817}
3818
3819#[doc(hidden)]
3820impl FromGlib<ffi::GtkDeleteType> for DeleteType {
3821 #[inline]
3822 unsafe fn from_glib(value: ffi::GtkDeleteType) -> Self {
3823 skip_assert_initialized!();
3824
3825 match value {
3826 ffi::GTK_DELETE_CHARS => Self::Chars,
3827 ffi::GTK_DELETE_WORD_ENDS => Self::WordEnds,
3828 ffi::GTK_DELETE_WORDS => Self::Words,
3829 ffi::GTK_DELETE_DISPLAY_LINES => Self::DisplayLines,
3830 ffi::GTK_DELETE_DISPLAY_LINE_ENDS => Self::DisplayLineEnds,
3831 ffi::GTK_DELETE_PARAGRAPH_ENDS => Self::ParagraphEnds,
3832 ffi::GTK_DELETE_PARAGRAPHS => Self::Paragraphs,
3833 ffi::GTK_DELETE_WHITESPACE => Self::Whitespace,
3834 value => Self::__Unknown(value),
3835 }
3836 }
3837}
3838
3839impl StaticType for DeleteType {
3840 #[inline]
3841 #[doc(alias = "gtk_delete_type_get_type")]
3842 fn static_type() -> glib::Type {
3843 unsafe { from_glib(ffi::gtk_delete_type_get_type()) }
3844 }
3845}
3846
3847impl glib::HasParamSpec for DeleteType {
3848 type ParamSpec = glib::ParamSpecEnum;
3849 type SetValue = Self;
3850 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
3851
3852 fn param_spec_builder() -> Self::BuilderFn {
3853 Self::ParamSpec::builder_with_default
3854 }
3855}
3856
3857impl glib::value::ValueType for DeleteType {
3858 type Type = Self;
3859}
3860
3861unsafe impl<'a> glib::value::FromValue<'a> for DeleteType {
3862 type Checker = glib::value::GenericValueTypeChecker<Self>;
3863
3864 #[inline]
3865 unsafe fn from_value(value: &'a glib::Value) -> Self {
3866 skip_assert_initialized!();
3867 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
3868 }
3869}
3870
3871impl ToValue for DeleteType {
3872 #[inline]
3873 fn to_value(&self) -> glib::Value {
3874 let mut value = glib::Value::for_value_type::<Self>();
3875 unsafe {
3876 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
3877 }
3878 value
3879 }
3880
3881 #[inline]
3882 fn value_type(&self) -> glib::Type {
3883 Self::static_type()
3884 }
3885}
3886
3887impl From<DeleteType> for glib::Value {
3888 #[inline]
3889 fn from(v: DeleteType) -> Self {
3890 skip_assert_initialized!();
3891 ToValue::to_value(&v)
3892 }
3893}
3894
3895#[cfg(feature = "v4_10")]
3896#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
3897#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3898#[non_exhaustive]
3899#[doc(alias = "GtkDialogError")]
3900pub enum DialogError {
3901 #[doc(alias = "GTK_DIALOG_ERROR_FAILED")]
3902 Failed,
3903 #[doc(alias = "GTK_DIALOG_ERROR_CANCELLED")]
3904 Cancelled,
3905 #[doc(alias = "GTK_DIALOG_ERROR_DISMISSED")]
3906 Dismissed,
3907 #[doc(hidden)]
3908 __Unknown(i32),
3909}
3910
3911#[cfg(feature = "v4_10")]
3912#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
3913#[doc(hidden)]
3914impl IntoGlib for DialogError {
3915 type GlibType = ffi::GtkDialogError;
3916
3917 #[inline]
3918 fn into_glib(self) -> ffi::GtkDialogError {
3919 match self {
3920 Self::Failed => ffi::GTK_DIALOG_ERROR_FAILED,
3921 Self::Cancelled => ffi::GTK_DIALOG_ERROR_CANCELLED,
3922 Self::Dismissed => ffi::GTK_DIALOG_ERROR_DISMISSED,
3923 Self::__Unknown(value) => value,
3924 }
3925 }
3926}
3927
3928#[cfg(feature = "v4_10")]
3929#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
3930#[doc(hidden)]
3931impl FromGlib<ffi::GtkDialogError> for DialogError {
3932 #[inline]
3933 unsafe fn from_glib(value: ffi::GtkDialogError) -> Self {
3934 skip_assert_initialized!();
3935
3936 match value {
3937 ffi::GTK_DIALOG_ERROR_FAILED => Self::Failed,
3938 ffi::GTK_DIALOG_ERROR_CANCELLED => Self::Cancelled,
3939 ffi::GTK_DIALOG_ERROR_DISMISSED => Self::Dismissed,
3940 value => Self::__Unknown(value),
3941 }
3942 }
3943}
3944
3945#[cfg(feature = "v4_10")]
3946#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
3947impl glib::error::ErrorDomain for DialogError {
3948 #[inline]
3949 fn domain() -> glib::Quark {
3950 skip_assert_initialized!();
3951
3952 unsafe { from_glib(ffi::gtk_dialog_error_quark()) }
3953 }
3954
3955 #[inline]
3956 fn code(self) -> i32 {
3957 self.into_glib()
3958 }
3959
3960 #[inline]
3961 #[allow(clippy::match_single_binding)]
3962 fn from(code: i32) -> Option<Self> {
3963 skip_assert_initialized!();
3964 match unsafe { from_glib(code) } {
3965 Self::__Unknown(_) => Some(Self::Failed),
3966 value => Some(value),
3967 }
3968 }
3969}
3970
3971#[cfg(feature = "v4_10")]
3972#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
3973impl StaticType for DialogError {
3974 #[inline]
3975 #[doc(alias = "gtk_dialog_error_get_type")]
3976 fn static_type() -> glib::Type {
3977 unsafe { from_glib(ffi::gtk_dialog_error_get_type()) }
3978 }
3979}
3980
3981#[cfg(feature = "v4_10")]
3982#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
3983impl glib::HasParamSpec for DialogError {
3984 type ParamSpec = glib::ParamSpecEnum;
3985 type SetValue = Self;
3986 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
3987
3988 fn param_spec_builder() -> Self::BuilderFn {
3989 Self::ParamSpec::builder_with_default
3990 }
3991}
3992
3993#[cfg(feature = "v4_10")]
3994#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
3995impl glib::value::ValueType for DialogError {
3996 type Type = Self;
3997}
3998
3999#[cfg(feature = "v4_10")]
4000#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
4001unsafe impl<'a> glib::value::FromValue<'a> for DialogError {
4002 type Checker = glib::value::GenericValueTypeChecker<Self>;
4003
4004 #[inline]
4005 unsafe fn from_value(value: &'a glib::Value) -> Self {
4006 skip_assert_initialized!();
4007 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
4008 }
4009}
4010
4011#[cfg(feature = "v4_10")]
4012#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
4013impl ToValue for DialogError {
4014 #[inline]
4015 fn to_value(&self) -> glib::Value {
4016 let mut value = glib::Value::for_value_type::<Self>();
4017 unsafe {
4018 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
4019 }
4020 value
4021 }
4022
4023 #[inline]
4024 fn value_type(&self) -> glib::Type {
4025 Self::static_type()
4026 }
4027}
4028
4029#[cfg(feature = "v4_10")]
4030#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
4031impl From<DialogError> for glib::Value {
4032 #[inline]
4033 fn from(v: DialogError) -> Self {
4034 skip_assert_initialized!();
4035 ToValue::to_value(&v)
4036 }
4037}
4038
4039#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
4040#[non_exhaustive]
4041#[doc(alias = "GtkDirectionType")]
4042pub enum DirectionType {
4043 #[doc(alias = "GTK_DIR_TAB_FORWARD")]
4044 TabForward,
4045 #[doc(alias = "GTK_DIR_TAB_BACKWARD")]
4046 TabBackward,
4047 #[doc(alias = "GTK_DIR_UP")]
4048 Up,
4049 #[doc(alias = "GTK_DIR_DOWN")]
4050 Down,
4051 #[doc(alias = "GTK_DIR_LEFT")]
4052 Left,
4053 #[doc(alias = "GTK_DIR_RIGHT")]
4054 Right,
4055 #[doc(hidden)]
4056 __Unknown(i32),
4057}
4058
4059#[doc(hidden)]
4060impl IntoGlib for DirectionType {
4061 type GlibType = ffi::GtkDirectionType;
4062
4063 #[inline]
4064 fn into_glib(self) -> ffi::GtkDirectionType {
4065 match self {
4066 Self::TabForward => ffi::GTK_DIR_TAB_FORWARD,
4067 Self::TabBackward => ffi::GTK_DIR_TAB_BACKWARD,
4068 Self::Up => ffi::GTK_DIR_UP,
4069 Self::Down => ffi::GTK_DIR_DOWN,
4070 Self::Left => ffi::GTK_DIR_LEFT,
4071 Self::Right => ffi::GTK_DIR_RIGHT,
4072 Self::__Unknown(value) => value,
4073 }
4074 }
4075}
4076
4077#[doc(hidden)]
4078impl FromGlib<ffi::GtkDirectionType> for DirectionType {
4079 #[inline]
4080 unsafe fn from_glib(value: ffi::GtkDirectionType) -> Self {
4081 skip_assert_initialized!();
4082
4083 match value {
4084 ffi::GTK_DIR_TAB_FORWARD => Self::TabForward,
4085 ffi::GTK_DIR_TAB_BACKWARD => Self::TabBackward,
4086 ffi::GTK_DIR_UP => Self::Up,
4087 ffi::GTK_DIR_DOWN => Self::Down,
4088 ffi::GTK_DIR_LEFT => Self::Left,
4089 ffi::GTK_DIR_RIGHT => Self::Right,
4090 value => Self::__Unknown(value),
4091 }
4092 }
4093}
4094
4095impl StaticType for DirectionType {
4096 #[inline]
4097 #[doc(alias = "gtk_direction_type_get_type")]
4098 fn static_type() -> glib::Type {
4099 unsafe { from_glib(ffi::gtk_direction_type_get_type()) }
4100 }
4101}
4102
4103impl glib::HasParamSpec for DirectionType {
4104 type ParamSpec = glib::ParamSpecEnum;
4105 type SetValue = Self;
4106 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
4107
4108 fn param_spec_builder() -> Self::BuilderFn {
4109 Self::ParamSpec::builder_with_default
4110 }
4111}
4112
4113impl glib::value::ValueType for DirectionType {
4114 type Type = Self;
4115}
4116
4117unsafe impl<'a> glib::value::FromValue<'a> for DirectionType {
4118 type Checker = glib::value::GenericValueTypeChecker<Self>;
4119
4120 #[inline]
4121 unsafe fn from_value(value: &'a glib::Value) -> Self {
4122 skip_assert_initialized!();
4123 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
4124 }
4125}
4126
4127impl ToValue for DirectionType {
4128 #[inline]
4129 fn to_value(&self) -> glib::Value {
4130 let mut value = glib::Value::for_value_type::<Self>();
4131 unsafe {
4132 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
4133 }
4134 value
4135 }
4136
4137 #[inline]
4138 fn value_type(&self) -> glib::Type {
4139 Self::static_type()
4140 }
4141}
4142
4143impl From<DirectionType> for glib::Value {
4144 #[inline]
4145 fn from(v: DirectionType) -> Self {
4146 skip_assert_initialized!();
4147 ToValue::to_value(&v)
4148 }
4149}
4150
4151#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
4152#[non_exhaustive]
4153#[doc(alias = "GtkEditableProperties")]
4154pub enum EditableProperties {
4155 #[doc(alias = "GTK_EDITABLE_PROP_TEXT")]
4156 PropText,
4157 #[doc(alias = "GTK_EDITABLE_PROP_CURSOR_POSITION")]
4158 PropCursorPosition,
4159 #[doc(alias = "GTK_EDITABLE_PROP_SELECTION_BOUND")]
4160 PropSelectionBound,
4161 #[doc(alias = "GTK_EDITABLE_PROP_EDITABLE")]
4162 PropEditable,
4163 #[doc(alias = "GTK_EDITABLE_PROP_WIDTH_CHARS")]
4164 PropWidthChars,
4165 #[doc(alias = "GTK_EDITABLE_PROP_MAX_WIDTH_CHARS")]
4166 PropMaxWidthChars,
4167 #[doc(alias = "GTK_EDITABLE_PROP_XALIGN")]
4168 PropXalign,
4169 #[doc(alias = "GTK_EDITABLE_PROP_ENABLE_UNDO")]
4170 PropEnableUndo,
4171 #[doc(alias = "GTK_EDITABLE_NUM_PROPERTIES")]
4172 NumProperties,
4173 #[doc(hidden)]
4174 __Unknown(i32),
4175}
4176
4177#[doc(hidden)]
4178impl IntoGlib for EditableProperties {
4179 type GlibType = ffi::GtkEditableProperties;
4180
4181 #[inline]
4182 fn into_glib(self) -> ffi::GtkEditableProperties {
4183 match self {
4184 Self::PropText => ffi::GTK_EDITABLE_PROP_TEXT,
4185 Self::PropCursorPosition => ffi::GTK_EDITABLE_PROP_CURSOR_POSITION,
4186 Self::PropSelectionBound => ffi::GTK_EDITABLE_PROP_SELECTION_BOUND,
4187 Self::PropEditable => ffi::GTK_EDITABLE_PROP_EDITABLE,
4188 Self::PropWidthChars => ffi::GTK_EDITABLE_PROP_WIDTH_CHARS,
4189 Self::PropMaxWidthChars => ffi::GTK_EDITABLE_PROP_MAX_WIDTH_CHARS,
4190 Self::PropXalign => ffi::GTK_EDITABLE_PROP_XALIGN,
4191 Self::PropEnableUndo => ffi::GTK_EDITABLE_PROP_ENABLE_UNDO,
4192 Self::NumProperties => ffi::GTK_EDITABLE_NUM_PROPERTIES,
4193 Self::__Unknown(value) => value,
4194 }
4195 }
4196}
4197
4198#[doc(hidden)]
4199impl FromGlib<ffi::GtkEditableProperties> for EditableProperties {
4200 #[inline]
4201 unsafe fn from_glib(value: ffi::GtkEditableProperties) -> Self {
4202 skip_assert_initialized!();
4203
4204 match value {
4205 ffi::GTK_EDITABLE_PROP_TEXT => Self::PropText,
4206 ffi::GTK_EDITABLE_PROP_CURSOR_POSITION => Self::PropCursorPosition,
4207 ffi::GTK_EDITABLE_PROP_SELECTION_BOUND => Self::PropSelectionBound,
4208 ffi::GTK_EDITABLE_PROP_EDITABLE => Self::PropEditable,
4209 ffi::GTK_EDITABLE_PROP_WIDTH_CHARS => Self::PropWidthChars,
4210 ffi::GTK_EDITABLE_PROP_MAX_WIDTH_CHARS => Self::PropMaxWidthChars,
4211 ffi::GTK_EDITABLE_PROP_XALIGN => Self::PropXalign,
4212 ffi::GTK_EDITABLE_PROP_ENABLE_UNDO => Self::PropEnableUndo,
4213 ffi::GTK_EDITABLE_NUM_PROPERTIES => Self::NumProperties,
4214 value => Self::__Unknown(value),
4215 }
4216 }
4217}
4218
4219impl StaticType for EditableProperties {
4220 #[inline]
4221 #[doc(alias = "gtk_editable_properties_get_type")]
4222 fn static_type() -> glib::Type {
4223 unsafe { from_glib(ffi::gtk_editable_properties_get_type()) }
4224 }
4225}
4226
4227impl glib::HasParamSpec for EditableProperties {
4228 type ParamSpec = glib::ParamSpecEnum;
4229 type SetValue = Self;
4230 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
4231
4232 fn param_spec_builder() -> Self::BuilderFn {
4233 Self::ParamSpec::builder_with_default
4234 }
4235}
4236
4237impl glib::value::ValueType for EditableProperties {
4238 type Type = Self;
4239}
4240
4241unsafe impl<'a> glib::value::FromValue<'a> for EditableProperties {
4242 type Checker = glib::value::GenericValueTypeChecker<Self>;
4243
4244 #[inline]
4245 unsafe fn from_value(value: &'a glib::Value) -> Self {
4246 skip_assert_initialized!();
4247 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
4248 }
4249}
4250
4251impl ToValue for EditableProperties {
4252 #[inline]
4253 fn to_value(&self) -> glib::Value {
4254 let mut value = glib::Value::for_value_type::<Self>();
4255 unsafe {
4256 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
4257 }
4258 value
4259 }
4260
4261 #[inline]
4262 fn value_type(&self) -> glib::Type {
4263 Self::static_type()
4264 }
4265}
4266
4267impl From<EditableProperties> for glib::Value {
4268 #[inline]
4269 fn from(v: EditableProperties) -> Self {
4270 skip_assert_initialized!();
4271 ToValue::to_value(&v)
4272 }
4273}
4274
4275#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
4276#[non_exhaustive]
4277#[doc(alias = "GtkEntryIconPosition")]
4278pub enum EntryIconPosition {
4279 #[doc(alias = "GTK_ENTRY_ICON_PRIMARY")]
4280 Primary,
4281 #[doc(alias = "GTK_ENTRY_ICON_SECONDARY")]
4282 Secondary,
4283 #[doc(hidden)]
4284 __Unknown(i32),
4285}
4286
4287#[doc(hidden)]
4288impl IntoGlib for EntryIconPosition {
4289 type GlibType = ffi::GtkEntryIconPosition;
4290
4291 #[inline]
4292 fn into_glib(self) -> ffi::GtkEntryIconPosition {
4293 match self {
4294 Self::Primary => ffi::GTK_ENTRY_ICON_PRIMARY,
4295 Self::Secondary => ffi::GTK_ENTRY_ICON_SECONDARY,
4296 Self::__Unknown(value) => value,
4297 }
4298 }
4299}
4300
4301#[doc(hidden)]
4302impl FromGlib<ffi::GtkEntryIconPosition> for EntryIconPosition {
4303 #[inline]
4304 unsafe fn from_glib(value: ffi::GtkEntryIconPosition) -> Self {
4305 skip_assert_initialized!();
4306
4307 match value {
4308 ffi::GTK_ENTRY_ICON_PRIMARY => Self::Primary,
4309 ffi::GTK_ENTRY_ICON_SECONDARY => Self::Secondary,
4310 value => Self::__Unknown(value),
4311 }
4312 }
4313}
4314
4315impl StaticType for EntryIconPosition {
4316 #[inline]
4317 #[doc(alias = "gtk_entry_icon_position_get_type")]
4318 fn static_type() -> glib::Type {
4319 unsafe { from_glib(ffi::gtk_entry_icon_position_get_type()) }
4320 }
4321}
4322
4323impl glib::HasParamSpec for EntryIconPosition {
4324 type ParamSpec = glib::ParamSpecEnum;
4325 type SetValue = Self;
4326 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
4327
4328 fn param_spec_builder() -> Self::BuilderFn {
4329 Self::ParamSpec::builder_with_default
4330 }
4331}
4332
4333impl glib::value::ValueType for EntryIconPosition {
4334 type Type = Self;
4335}
4336
4337unsafe impl<'a> glib::value::FromValue<'a> for EntryIconPosition {
4338 type Checker = glib::value::GenericValueTypeChecker<Self>;
4339
4340 #[inline]
4341 unsafe fn from_value(value: &'a glib::Value) -> Self {
4342 skip_assert_initialized!();
4343 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
4344 }
4345}
4346
4347impl ToValue for EntryIconPosition {
4348 #[inline]
4349 fn to_value(&self) -> glib::Value {
4350 let mut value = glib::Value::for_value_type::<Self>();
4351 unsafe {
4352 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
4353 }
4354 value
4355 }
4356
4357 #[inline]
4358 fn value_type(&self) -> glib::Type {
4359 Self::static_type()
4360 }
4361}
4362
4363impl From<EntryIconPosition> for glib::Value {
4364 #[inline]
4365 fn from(v: EntryIconPosition) -> Self {
4366 skip_assert_initialized!();
4367 ToValue::to_value(&v)
4368 }
4369}
4370
4371#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
4372#[non_exhaustive]
4373#[doc(alias = "GtkEventSequenceState")]
4374pub enum EventSequenceState {
4375 #[doc(alias = "GTK_EVENT_SEQUENCE_NONE")]
4376 None,
4377 #[doc(alias = "GTK_EVENT_SEQUENCE_CLAIMED")]
4378 Claimed,
4379 #[doc(alias = "GTK_EVENT_SEQUENCE_DENIED")]
4380 Denied,
4381 #[doc(hidden)]
4382 __Unknown(i32),
4383}
4384
4385#[doc(hidden)]
4386impl IntoGlib for EventSequenceState {
4387 type GlibType = ffi::GtkEventSequenceState;
4388
4389 #[inline]
4390 fn into_glib(self) -> ffi::GtkEventSequenceState {
4391 match self {
4392 Self::None => ffi::GTK_EVENT_SEQUENCE_NONE,
4393 Self::Claimed => ffi::GTK_EVENT_SEQUENCE_CLAIMED,
4394 Self::Denied => ffi::GTK_EVENT_SEQUENCE_DENIED,
4395 Self::__Unknown(value) => value,
4396 }
4397 }
4398}
4399
4400#[doc(hidden)]
4401impl FromGlib<ffi::GtkEventSequenceState> for EventSequenceState {
4402 #[inline]
4403 unsafe fn from_glib(value: ffi::GtkEventSequenceState) -> Self {
4404 skip_assert_initialized!();
4405
4406 match value {
4407 ffi::GTK_EVENT_SEQUENCE_NONE => Self::None,
4408 ffi::GTK_EVENT_SEQUENCE_CLAIMED => Self::Claimed,
4409 ffi::GTK_EVENT_SEQUENCE_DENIED => Self::Denied,
4410 value => Self::__Unknown(value),
4411 }
4412 }
4413}
4414
4415impl StaticType for EventSequenceState {
4416 #[inline]
4417 #[doc(alias = "gtk_event_sequence_state_get_type")]
4418 fn static_type() -> glib::Type {
4419 unsafe { from_glib(ffi::gtk_event_sequence_state_get_type()) }
4420 }
4421}
4422
4423impl glib::HasParamSpec for EventSequenceState {
4424 type ParamSpec = glib::ParamSpecEnum;
4425 type SetValue = Self;
4426 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
4427
4428 fn param_spec_builder() -> Self::BuilderFn {
4429 Self::ParamSpec::builder_with_default
4430 }
4431}
4432
4433impl glib::value::ValueType for EventSequenceState {
4434 type Type = Self;
4435}
4436
4437unsafe impl<'a> glib::value::FromValue<'a> for EventSequenceState {
4438 type Checker = glib::value::GenericValueTypeChecker<Self>;
4439
4440 #[inline]
4441 unsafe fn from_value(value: &'a glib::Value) -> Self {
4442 skip_assert_initialized!();
4443 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
4444 }
4445}
4446
4447impl ToValue for EventSequenceState {
4448 #[inline]
4449 fn to_value(&self) -> glib::Value {
4450 let mut value = glib::Value::for_value_type::<Self>();
4451 unsafe {
4452 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
4453 }
4454 value
4455 }
4456
4457 #[inline]
4458 fn value_type(&self) -> glib::Type {
4459 Self::static_type()
4460 }
4461}
4462
4463impl From<EventSequenceState> for glib::Value {
4464 #[inline]
4465 fn from(v: EventSequenceState) -> Self {
4466 skip_assert_initialized!();
4467 ToValue::to_value(&v)
4468 }
4469}
4470
4471#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
4472#[non_exhaustive]
4473#[doc(alias = "GtkFileChooserAction")]
4474pub enum FileChooserAction {
4475 #[doc(alias = "GTK_FILE_CHOOSER_ACTION_OPEN")]
4476 Open,
4477 #[doc(alias = "GTK_FILE_CHOOSER_ACTION_SAVE")]
4478 Save,
4479 #[doc(alias = "GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER")]
4480 SelectFolder,
4481 #[doc(hidden)]
4482 __Unknown(i32),
4483}
4484
4485#[doc(hidden)]
4486impl IntoGlib for FileChooserAction {
4487 type GlibType = ffi::GtkFileChooserAction;
4488
4489 #[inline]
4490 fn into_glib(self) -> ffi::GtkFileChooserAction {
4491 match self {
4492 Self::Open => ffi::GTK_FILE_CHOOSER_ACTION_OPEN,
4493 Self::Save => ffi::GTK_FILE_CHOOSER_ACTION_SAVE,
4494 Self::SelectFolder => ffi::GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER,
4495 Self::__Unknown(value) => value,
4496 }
4497 }
4498}
4499
4500#[doc(hidden)]
4501impl FromGlib<ffi::GtkFileChooserAction> for FileChooserAction {
4502 #[inline]
4503 unsafe fn from_glib(value: ffi::GtkFileChooserAction) -> Self {
4504 skip_assert_initialized!();
4505
4506 match value {
4507 ffi::GTK_FILE_CHOOSER_ACTION_OPEN => Self::Open,
4508 ffi::GTK_FILE_CHOOSER_ACTION_SAVE => Self::Save,
4509 ffi::GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER => Self::SelectFolder,
4510 value => Self::__Unknown(value),
4511 }
4512 }
4513}
4514
4515impl StaticType for FileChooserAction {
4516 #[inline]
4517 #[doc(alias = "gtk_file_chooser_action_get_type")]
4518 fn static_type() -> glib::Type {
4519 unsafe { from_glib(ffi::gtk_file_chooser_action_get_type()) }
4520 }
4521}
4522
4523impl glib::HasParamSpec for FileChooserAction {
4524 type ParamSpec = glib::ParamSpecEnum;
4525 type SetValue = Self;
4526 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
4527
4528 fn param_spec_builder() -> Self::BuilderFn {
4529 Self::ParamSpec::builder_with_default
4530 }
4531}
4532
4533impl glib::value::ValueType for FileChooserAction {
4534 type Type = Self;
4535}
4536
4537unsafe impl<'a> glib::value::FromValue<'a> for FileChooserAction {
4538 type Checker = glib::value::GenericValueTypeChecker<Self>;
4539
4540 #[inline]
4541 unsafe fn from_value(value: &'a glib::Value) -> Self {
4542 skip_assert_initialized!();
4543 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
4544 }
4545}
4546
4547impl ToValue for FileChooserAction {
4548 #[inline]
4549 fn to_value(&self) -> glib::Value {
4550 let mut value = glib::Value::for_value_type::<Self>();
4551 unsafe {
4552 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
4553 }
4554 value
4555 }
4556
4557 #[inline]
4558 fn value_type(&self) -> glib::Type {
4559 Self::static_type()
4560 }
4561}
4562
4563impl From<FileChooserAction> for glib::Value {
4564 #[inline]
4565 fn from(v: FileChooserAction) -> Self {
4566 skip_assert_initialized!();
4567 ToValue::to_value(&v)
4568 }
4569}
4570
4571#[cfg_attr(feature = "v4_20", deprecated = "Since 4.20")]
4572#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
4573#[non_exhaustive]
4574#[doc(alias = "GtkFileChooserError")]
4575pub enum FileChooserError {
4576 #[doc(alias = "GTK_FILE_CHOOSER_ERROR_NONEXISTENT")]
4577 Nonexistent,
4578 #[doc(alias = "GTK_FILE_CHOOSER_ERROR_BAD_FILENAME")]
4579 BadFilename,
4580 #[doc(alias = "GTK_FILE_CHOOSER_ERROR_ALREADY_EXISTS")]
4581 AlreadyExists,
4582 #[doc(alias = "GTK_FILE_CHOOSER_ERROR_INCOMPLETE_HOSTNAME")]
4583 IncompleteHostname,
4584 #[doc(hidden)]
4585 __Unknown(i32),
4586}
4587
4588#[allow(deprecated)]
4589#[doc(hidden)]
4590impl IntoGlib for FileChooserError {
4591 type GlibType = ffi::GtkFileChooserError;
4592
4593 #[inline]
4594 fn into_glib(self) -> ffi::GtkFileChooserError {
4595 match self {
4596 Self::Nonexistent => ffi::GTK_FILE_CHOOSER_ERROR_NONEXISTENT,
4597 Self::BadFilename => ffi::GTK_FILE_CHOOSER_ERROR_BAD_FILENAME,
4598 Self::AlreadyExists => ffi::GTK_FILE_CHOOSER_ERROR_ALREADY_EXISTS,
4599 Self::IncompleteHostname => ffi::GTK_FILE_CHOOSER_ERROR_INCOMPLETE_HOSTNAME,
4600 Self::__Unknown(value) => value,
4601 }
4602 }
4603}
4604
4605#[allow(deprecated)]
4606#[doc(hidden)]
4607impl FromGlib<ffi::GtkFileChooserError> for FileChooserError {
4608 #[inline]
4609 unsafe fn from_glib(value: ffi::GtkFileChooserError) -> Self {
4610 skip_assert_initialized!();
4611
4612 match value {
4613 ffi::GTK_FILE_CHOOSER_ERROR_NONEXISTENT => Self::Nonexistent,
4614 ffi::GTK_FILE_CHOOSER_ERROR_BAD_FILENAME => Self::BadFilename,
4615 ffi::GTK_FILE_CHOOSER_ERROR_ALREADY_EXISTS => Self::AlreadyExists,
4616 ffi::GTK_FILE_CHOOSER_ERROR_INCOMPLETE_HOSTNAME => Self::IncompleteHostname,
4617 value => Self::__Unknown(value),
4618 }
4619 }
4620}
4621
4622#[allow(deprecated)]
4623impl glib::error::ErrorDomain for FileChooserError {
4624 #[inline]
4625 fn domain() -> glib::Quark {
4626 skip_assert_initialized!();
4627
4628 unsafe { from_glib(ffi::gtk_file_chooser_error_quark()) }
4629 }
4630
4631 #[inline]
4632 fn code(self) -> i32 {
4633 self.into_glib()
4634 }
4635
4636 #[inline]
4637 #[allow(clippy::match_single_binding)]
4638 fn from(code: i32) -> Option<Self> {
4639 skip_assert_initialized!();
4640 match unsafe { from_glib(code) } {
4641 value => Some(value),
4642 }
4643 }
4644}
4645
4646#[allow(deprecated)]
4647impl StaticType for FileChooserError {
4648 #[inline]
4649 #[doc(alias = "gtk_file_chooser_error_get_type")]
4650 fn static_type() -> glib::Type {
4651 unsafe { from_glib(ffi::gtk_file_chooser_error_get_type()) }
4652 }
4653}
4654
4655#[allow(deprecated)]
4656impl glib::HasParamSpec for FileChooserError {
4657 type ParamSpec = glib::ParamSpecEnum;
4658 type SetValue = Self;
4659 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
4660
4661 fn param_spec_builder() -> Self::BuilderFn {
4662 Self::ParamSpec::builder_with_default
4663 }
4664}
4665
4666#[allow(deprecated)]
4667impl glib::value::ValueType for FileChooserError {
4668 type Type = Self;
4669}
4670
4671#[allow(deprecated)]
4672unsafe impl<'a> glib::value::FromValue<'a> for FileChooserError {
4673 type Checker = glib::value::GenericValueTypeChecker<Self>;
4674
4675 #[inline]
4676 unsafe fn from_value(value: &'a glib::Value) -> Self {
4677 skip_assert_initialized!();
4678 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
4679 }
4680}
4681
4682#[allow(deprecated)]
4683impl ToValue for FileChooserError {
4684 #[inline]
4685 fn to_value(&self) -> glib::Value {
4686 let mut value = glib::Value::for_value_type::<Self>();
4687 unsafe {
4688 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
4689 }
4690 value
4691 }
4692
4693 #[inline]
4694 fn value_type(&self) -> glib::Type {
4695 Self::static_type()
4696 }
4697}
4698
4699#[allow(deprecated)]
4700impl From<FileChooserError> for glib::Value {
4701 #[inline]
4702 fn from(v: FileChooserError) -> Self {
4703 skip_assert_initialized!();
4704 ToValue::to_value(&v)
4705 }
4706}
4707
4708#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
4709#[non_exhaustive]
4710#[doc(alias = "GtkFilterChange")]
4711pub enum FilterChange {
4712 #[doc(alias = "GTK_FILTER_CHANGE_DIFFERENT")]
4713 Different,
4714 #[doc(alias = "GTK_FILTER_CHANGE_LESS_STRICT")]
4715 LessStrict,
4716 #[doc(alias = "GTK_FILTER_CHANGE_MORE_STRICT")]
4717 MoreStrict,
4718 #[cfg(feature = "v4_20")]
4719 #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
4720 #[doc(alias = "GTK_FILTER_CHANGE_DIFFERENT_REWATCH")]
4721 DifferentRewatch,
4722 #[cfg(feature = "v4_20")]
4723 #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
4724 #[doc(alias = "GTK_FILTER_CHANGE_LESS_STRICT_REWATCH")]
4725 LessStrictRewatch,
4726 #[cfg(feature = "v4_20")]
4727 #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
4728 #[doc(alias = "GTK_FILTER_CHANGE_MORE_STRICT_REWATCH")]
4729 MoreStrictRewatch,
4730 #[doc(hidden)]
4731 __Unknown(i32),
4732}
4733
4734#[doc(hidden)]
4735impl IntoGlib for FilterChange {
4736 type GlibType = ffi::GtkFilterChange;
4737
4738 #[inline]
4739 fn into_glib(self) -> ffi::GtkFilterChange {
4740 match self {
4741 Self::Different => ffi::GTK_FILTER_CHANGE_DIFFERENT,
4742 Self::LessStrict => ffi::GTK_FILTER_CHANGE_LESS_STRICT,
4743 Self::MoreStrict => ffi::GTK_FILTER_CHANGE_MORE_STRICT,
4744 #[cfg(feature = "v4_20")]
4745 Self::DifferentRewatch => ffi::GTK_FILTER_CHANGE_DIFFERENT_REWATCH,
4746 #[cfg(feature = "v4_20")]
4747 Self::LessStrictRewatch => ffi::GTK_FILTER_CHANGE_LESS_STRICT_REWATCH,
4748 #[cfg(feature = "v4_20")]
4749 Self::MoreStrictRewatch => ffi::GTK_FILTER_CHANGE_MORE_STRICT_REWATCH,
4750 Self::__Unknown(value) => value,
4751 }
4752 }
4753}
4754
4755#[doc(hidden)]
4756impl FromGlib<ffi::GtkFilterChange> for FilterChange {
4757 #[inline]
4758 unsafe fn from_glib(value: ffi::GtkFilterChange) -> Self {
4759 skip_assert_initialized!();
4760
4761 match value {
4762 ffi::GTK_FILTER_CHANGE_DIFFERENT => Self::Different,
4763 ffi::GTK_FILTER_CHANGE_LESS_STRICT => Self::LessStrict,
4764 ffi::GTK_FILTER_CHANGE_MORE_STRICT => Self::MoreStrict,
4765 #[cfg(feature = "v4_20")]
4766 ffi::GTK_FILTER_CHANGE_DIFFERENT_REWATCH => Self::DifferentRewatch,
4767 #[cfg(feature = "v4_20")]
4768 ffi::GTK_FILTER_CHANGE_LESS_STRICT_REWATCH => Self::LessStrictRewatch,
4769 #[cfg(feature = "v4_20")]
4770 ffi::GTK_FILTER_CHANGE_MORE_STRICT_REWATCH => Self::MoreStrictRewatch,
4771 value => Self::__Unknown(value),
4772 }
4773 }
4774}
4775
4776impl StaticType for FilterChange {
4777 #[inline]
4778 #[doc(alias = "gtk_filter_change_get_type")]
4779 fn static_type() -> glib::Type {
4780 unsafe { from_glib(ffi::gtk_filter_change_get_type()) }
4781 }
4782}
4783
4784impl glib::HasParamSpec for FilterChange {
4785 type ParamSpec = glib::ParamSpecEnum;
4786 type SetValue = Self;
4787 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
4788
4789 fn param_spec_builder() -> Self::BuilderFn {
4790 Self::ParamSpec::builder_with_default
4791 }
4792}
4793
4794impl glib::value::ValueType for FilterChange {
4795 type Type = Self;
4796}
4797
4798unsafe impl<'a> glib::value::FromValue<'a> for FilterChange {
4799 type Checker = glib::value::GenericValueTypeChecker<Self>;
4800
4801 #[inline]
4802 unsafe fn from_value(value: &'a glib::Value) -> Self {
4803 skip_assert_initialized!();
4804 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
4805 }
4806}
4807
4808impl ToValue for FilterChange {
4809 #[inline]
4810 fn to_value(&self) -> glib::Value {
4811 let mut value = glib::Value::for_value_type::<Self>();
4812 unsafe {
4813 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
4814 }
4815 value
4816 }
4817
4818 #[inline]
4819 fn value_type(&self) -> glib::Type {
4820 Self::static_type()
4821 }
4822}
4823
4824impl From<FilterChange> for glib::Value {
4825 #[inline]
4826 fn from(v: FilterChange) -> Self {
4827 skip_assert_initialized!();
4828 ToValue::to_value(&v)
4829 }
4830}
4831
4832#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
4833#[non_exhaustive]
4834#[doc(alias = "GtkFilterMatch")]
4835pub enum FilterMatch {
4836 #[doc(alias = "GTK_FILTER_MATCH_SOME")]
4837 Some,
4838 #[doc(alias = "GTK_FILTER_MATCH_NONE")]
4839 None,
4840 #[doc(alias = "GTK_FILTER_MATCH_ALL")]
4841 All,
4842 #[doc(hidden)]
4843 __Unknown(i32),
4844}
4845
4846#[doc(hidden)]
4847impl IntoGlib for FilterMatch {
4848 type GlibType = ffi::GtkFilterMatch;
4849
4850 #[inline]
4851 fn into_glib(self) -> ffi::GtkFilterMatch {
4852 match self {
4853 Self::Some => ffi::GTK_FILTER_MATCH_SOME,
4854 Self::None => ffi::GTK_FILTER_MATCH_NONE,
4855 Self::All => ffi::GTK_FILTER_MATCH_ALL,
4856 Self::__Unknown(value) => value,
4857 }
4858 }
4859}
4860
4861#[doc(hidden)]
4862impl FromGlib<ffi::GtkFilterMatch> for FilterMatch {
4863 #[inline]
4864 unsafe fn from_glib(value: ffi::GtkFilterMatch) -> Self {
4865 skip_assert_initialized!();
4866
4867 match value {
4868 ffi::GTK_FILTER_MATCH_SOME => Self::Some,
4869 ffi::GTK_FILTER_MATCH_NONE => Self::None,
4870 ffi::GTK_FILTER_MATCH_ALL => Self::All,
4871 value => Self::__Unknown(value),
4872 }
4873 }
4874}
4875
4876impl StaticType for FilterMatch {
4877 #[inline]
4878 #[doc(alias = "gtk_filter_match_get_type")]
4879 fn static_type() -> glib::Type {
4880 unsafe { from_glib(ffi::gtk_filter_match_get_type()) }
4881 }
4882}
4883
4884impl glib::HasParamSpec for FilterMatch {
4885 type ParamSpec = glib::ParamSpecEnum;
4886 type SetValue = Self;
4887 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
4888
4889 fn param_spec_builder() -> Self::BuilderFn {
4890 Self::ParamSpec::builder_with_default
4891 }
4892}
4893
4894impl glib::value::ValueType for FilterMatch {
4895 type Type = Self;
4896}
4897
4898unsafe impl<'a> glib::value::FromValue<'a> for FilterMatch {
4899 type Checker = glib::value::GenericValueTypeChecker<Self>;
4900
4901 #[inline]
4902 unsafe fn from_value(value: &'a glib::Value) -> Self {
4903 skip_assert_initialized!();
4904 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
4905 }
4906}
4907
4908impl ToValue for FilterMatch {
4909 #[inline]
4910 fn to_value(&self) -> glib::Value {
4911 let mut value = glib::Value::for_value_type::<Self>();
4912 unsafe {
4913 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
4914 }
4915 value
4916 }
4917
4918 #[inline]
4919 fn value_type(&self) -> glib::Type {
4920 Self::static_type()
4921 }
4922}
4923
4924impl From<FilterMatch> for glib::Value {
4925 #[inline]
4926 fn from(v: FilterMatch) -> Self {
4927 skip_assert_initialized!();
4928 ToValue::to_value(&v)
4929 }
4930}
4931
4932#[cfg(feature = "v4_10")]
4933#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
4934#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
4935#[non_exhaustive]
4936#[doc(alias = "GtkFontLevel")]
4937pub enum FontLevel {
4938 #[doc(alias = "GTK_FONT_LEVEL_FAMILY")]
4939 Family,
4940 #[doc(alias = "GTK_FONT_LEVEL_FACE")]
4941 Face,
4942 #[doc(alias = "GTK_FONT_LEVEL_FONT")]
4943 Font,
4944 #[doc(alias = "GTK_FONT_LEVEL_FEATURES")]
4945 Features,
4946 #[doc(hidden)]
4947 __Unknown(i32),
4948}
4949
4950#[cfg(feature = "v4_10")]
4951#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
4952#[doc(hidden)]
4953impl IntoGlib for FontLevel {
4954 type GlibType = ffi::GtkFontLevel;
4955
4956 #[inline]
4957 fn into_glib(self) -> ffi::GtkFontLevel {
4958 match self {
4959 Self::Family => ffi::GTK_FONT_LEVEL_FAMILY,
4960 Self::Face => ffi::GTK_FONT_LEVEL_FACE,
4961 Self::Font => ffi::GTK_FONT_LEVEL_FONT,
4962 Self::Features => ffi::GTK_FONT_LEVEL_FEATURES,
4963 Self::__Unknown(value) => value,
4964 }
4965 }
4966}
4967
4968#[cfg(feature = "v4_10")]
4969#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
4970#[doc(hidden)]
4971impl FromGlib<ffi::GtkFontLevel> for FontLevel {
4972 #[inline]
4973 unsafe fn from_glib(value: ffi::GtkFontLevel) -> Self {
4974 skip_assert_initialized!();
4975
4976 match value {
4977 ffi::GTK_FONT_LEVEL_FAMILY => Self::Family,
4978 ffi::GTK_FONT_LEVEL_FACE => Self::Face,
4979 ffi::GTK_FONT_LEVEL_FONT => Self::Font,
4980 ffi::GTK_FONT_LEVEL_FEATURES => Self::Features,
4981 value => Self::__Unknown(value),
4982 }
4983 }
4984}
4985
4986#[cfg(feature = "v4_10")]
4987#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
4988impl StaticType for FontLevel {
4989 #[inline]
4990 #[doc(alias = "gtk_font_level_get_type")]
4991 fn static_type() -> glib::Type {
4992 unsafe { from_glib(ffi::gtk_font_level_get_type()) }
4993 }
4994}
4995
4996#[cfg(feature = "v4_10")]
4997#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
4998impl glib::HasParamSpec for FontLevel {
4999 type ParamSpec = glib::ParamSpecEnum;
5000 type SetValue = Self;
5001 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
5002
5003 fn param_spec_builder() -> Self::BuilderFn {
5004 Self::ParamSpec::builder_with_default
5005 }
5006}
5007
5008#[cfg(feature = "v4_10")]
5009#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
5010impl glib::value::ValueType for FontLevel {
5011 type Type = Self;
5012}
5013
5014#[cfg(feature = "v4_10")]
5015#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
5016unsafe impl<'a> glib::value::FromValue<'a> for FontLevel {
5017 type Checker = glib::value::GenericValueTypeChecker<Self>;
5018
5019 #[inline]
5020 unsafe fn from_value(value: &'a glib::Value) -> Self {
5021 skip_assert_initialized!();
5022 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
5023 }
5024}
5025
5026#[cfg(feature = "v4_10")]
5027#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
5028impl ToValue for FontLevel {
5029 #[inline]
5030 fn to_value(&self) -> glib::Value {
5031 let mut value = glib::Value::for_value_type::<Self>();
5032 unsafe {
5033 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
5034 }
5035 value
5036 }
5037
5038 #[inline]
5039 fn value_type(&self) -> glib::Type {
5040 Self::static_type()
5041 }
5042}
5043
5044#[cfg(feature = "v4_10")]
5045#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
5046impl From<FontLevel> for glib::Value {
5047 #[inline]
5048 fn from(v: FontLevel) -> Self {
5049 skip_assert_initialized!();
5050 ToValue::to_value(&v)
5051 }
5052}
5053
5054#[cfg(feature = "v4_16")]
5055#[cfg_attr(docsrs, doc(cfg(feature = "v4_16")))]
5056#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
5057#[non_exhaustive]
5058#[doc(alias = "GtkFontRendering")]
5059pub enum FontRendering {
5060 #[doc(alias = "GTK_FONT_RENDERING_AUTOMATIC")]
5061 Automatic,
5062 #[doc(alias = "GTK_FONT_RENDERING_MANUAL")]
5063 Manual,
5064 #[doc(hidden)]
5065 __Unknown(i32),
5066}
5067
5068#[cfg(feature = "v4_16")]
5069#[cfg_attr(docsrs, doc(cfg(feature = "v4_16")))]
5070#[doc(hidden)]
5071impl IntoGlib for FontRendering {
5072 type GlibType = ffi::GtkFontRendering;
5073
5074 #[inline]
5075 fn into_glib(self) -> ffi::GtkFontRendering {
5076 match self {
5077 Self::Automatic => ffi::GTK_FONT_RENDERING_AUTOMATIC,
5078 Self::Manual => ffi::GTK_FONT_RENDERING_MANUAL,
5079 Self::__Unknown(value) => value,
5080 }
5081 }
5082}
5083
5084#[cfg(feature = "v4_16")]
5085#[cfg_attr(docsrs, doc(cfg(feature = "v4_16")))]
5086#[doc(hidden)]
5087impl FromGlib<ffi::GtkFontRendering> for FontRendering {
5088 #[inline]
5089 unsafe fn from_glib(value: ffi::GtkFontRendering) -> Self {
5090 skip_assert_initialized!();
5091
5092 match value {
5093 ffi::GTK_FONT_RENDERING_AUTOMATIC => Self::Automatic,
5094 ffi::GTK_FONT_RENDERING_MANUAL => Self::Manual,
5095 value => Self::__Unknown(value),
5096 }
5097 }
5098}
5099
5100#[cfg(feature = "v4_16")]
5101#[cfg_attr(docsrs, doc(cfg(feature = "v4_16")))]
5102impl StaticType for FontRendering {
5103 #[inline]
5104 #[doc(alias = "gtk_font_rendering_get_type")]
5105 fn static_type() -> glib::Type {
5106 unsafe { from_glib(ffi::gtk_font_rendering_get_type()) }
5107 }
5108}
5109
5110#[cfg(feature = "v4_16")]
5111#[cfg_attr(docsrs, doc(cfg(feature = "v4_16")))]
5112impl glib::HasParamSpec for FontRendering {
5113 type ParamSpec = glib::ParamSpecEnum;
5114 type SetValue = Self;
5115 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
5116
5117 fn param_spec_builder() -> Self::BuilderFn {
5118 Self::ParamSpec::builder_with_default
5119 }
5120}
5121
5122#[cfg(feature = "v4_16")]
5123#[cfg_attr(docsrs, doc(cfg(feature = "v4_16")))]
5124impl glib::value::ValueType for FontRendering {
5125 type Type = Self;
5126}
5127
5128#[cfg(feature = "v4_16")]
5129#[cfg_attr(docsrs, doc(cfg(feature = "v4_16")))]
5130unsafe impl<'a> glib::value::FromValue<'a> for FontRendering {
5131 type Checker = glib::value::GenericValueTypeChecker<Self>;
5132
5133 #[inline]
5134 unsafe fn from_value(value: &'a glib::Value) -> Self {
5135 skip_assert_initialized!();
5136 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
5137 }
5138}
5139
5140#[cfg(feature = "v4_16")]
5141#[cfg_attr(docsrs, doc(cfg(feature = "v4_16")))]
5142impl ToValue for FontRendering {
5143 #[inline]
5144 fn to_value(&self) -> glib::Value {
5145 let mut value = glib::Value::for_value_type::<Self>();
5146 unsafe {
5147 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
5148 }
5149 value
5150 }
5151
5152 #[inline]
5153 fn value_type(&self) -> glib::Type {
5154 Self::static_type()
5155 }
5156}
5157
5158#[cfg(feature = "v4_16")]
5159#[cfg_attr(docsrs, doc(cfg(feature = "v4_16")))]
5160impl From<FontRendering> for glib::Value {
5161 #[inline]
5162 fn from(v: FontRendering) -> Self {
5163 skip_assert_initialized!();
5164 ToValue::to_value(&v)
5165 }
5166}
5167
5168#[cfg(feature = "v4_14")]
5169#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
5170#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
5171#[non_exhaustive]
5172#[doc(alias = "GtkGraphicsOffloadEnabled")]
5173pub enum GraphicsOffloadEnabled {
5174 #[doc(alias = "GTK_GRAPHICS_OFFLOAD_ENABLED")]
5175 Enabled,
5176 #[doc(alias = "GTK_GRAPHICS_OFFLOAD_DISABLED")]
5177 Disabled,
5178 #[doc(hidden)]
5179 __Unknown(i32),
5180}
5181
5182#[cfg(feature = "v4_14")]
5183#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
5184#[doc(hidden)]
5185impl IntoGlib for GraphicsOffloadEnabled {
5186 type GlibType = ffi::GtkGraphicsOffloadEnabled;
5187
5188 #[inline]
5189 fn into_glib(self) -> ffi::GtkGraphicsOffloadEnabled {
5190 match self {
5191 Self::Enabled => ffi::GTK_GRAPHICS_OFFLOAD_ENABLED,
5192 Self::Disabled => ffi::GTK_GRAPHICS_OFFLOAD_DISABLED,
5193 Self::__Unknown(value) => value,
5194 }
5195 }
5196}
5197
5198#[cfg(feature = "v4_14")]
5199#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
5200#[doc(hidden)]
5201impl FromGlib<ffi::GtkGraphicsOffloadEnabled> for GraphicsOffloadEnabled {
5202 #[inline]
5203 unsafe fn from_glib(value: ffi::GtkGraphicsOffloadEnabled) -> Self {
5204 skip_assert_initialized!();
5205
5206 match value {
5207 ffi::GTK_GRAPHICS_OFFLOAD_ENABLED => Self::Enabled,
5208 ffi::GTK_GRAPHICS_OFFLOAD_DISABLED => Self::Disabled,
5209 value => Self::__Unknown(value),
5210 }
5211 }
5212}
5213
5214#[cfg(feature = "v4_14")]
5215#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
5216impl StaticType for GraphicsOffloadEnabled {
5217 #[inline]
5218 #[doc(alias = "gtk_graphics_offload_enabled_get_type")]
5219 fn static_type() -> glib::Type {
5220 unsafe { from_glib(ffi::gtk_graphics_offload_enabled_get_type()) }
5221 }
5222}
5223
5224#[cfg(feature = "v4_14")]
5225#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
5226impl glib::HasParamSpec for GraphicsOffloadEnabled {
5227 type ParamSpec = glib::ParamSpecEnum;
5228 type SetValue = Self;
5229 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
5230
5231 fn param_spec_builder() -> Self::BuilderFn {
5232 Self::ParamSpec::builder_with_default
5233 }
5234}
5235
5236#[cfg(feature = "v4_14")]
5237#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
5238impl glib::value::ValueType for GraphicsOffloadEnabled {
5239 type Type = Self;
5240}
5241
5242#[cfg(feature = "v4_14")]
5243#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
5244unsafe impl<'a> glib::value::FromValue<'a> for GraphicsOffloadEnabled {
5245 type Checker = glib::value::GenericValueTypeChecker<Self>;
5246
5247 #[inline]
5248 unsafe fn from_value(value: &'a glib::Value) -> Self {
5249 skip_assert_initialized!();
5250 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
5251 }
5252}
5253
5254#[cfg(feature = "v4_14")]
5255#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
5256impl ToValue for GraphicsOffloadEnabled {
5257 #[inline]
5258 fn to_value(&self) -> glib::Value {
5259 let mut value = glib::Value::for_value_type::<Self>();
5260 unsafe {
5261 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
5262 }
5263 value
5264 }
5265
5266 #[inline]
5267 fn value_type(&self) -> glib::Type {
5268 Self::static_type()
5269 }
5270}
5271
5272#[cfg(feature = "v4_14")]
5273#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
5274impl From<GraphicsOffloadEnabled> for glib::Value {
5275 #[inline]
5276 fn from(v: GraphicsOffloadEnabled) -> Self {
5277 skip_assert_initialized!();
5278 ToValue::to_value(&v)
5279 }
5280}
5281
5282#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
5283#[non_exhaustive]
5284#[doc(alias = "GtkIconSize")]
5285pub enum IconSize {
5286 #[doc(alias = "GTK_ICON_SIZE_INHERIT")]
5287 Inherit,
5288 #[doc(alias = "GTK_ICON_SIZE_NORMAL")]
5289 Normal,
5290 #[doc(alias = "GTK_ICON_SIZE_LARGE")]
5291 Large,
5292 #[doc(hidden)]
5293 __Unknown(i32),
5294}
5295
5296#[doc(hidden)]
5297impl IntoGlib for IconSize {
5298 type GlibType = ffi::GtkIconSize;
5299
5300 #[inline]
5301 fn into_glib(self) -> ffi::GtkIconSize {
5302 match self {
5303 Self::Inherit => ffi::GTK_ICON_SIZE_INHERIT,
5304 Self::Normal => ffi::GTK_ICON_SIZE_NORMAL,
5305 Self::Large => ffi::GTK_ICON_SIZE_LARGE,
5306 Self::__Unknown(value) => value,
5307 }
5308 }
5309}
5310
5311#[doc(hidden)]
5312impl FromGlib<ffi::GtkIconSize> for IconSize {
5313 #[inline]
5314 unsafe fn from_glib(value: ffi::GtkIconSize) -> Self {
5315 skip_assert_initialized!();
5316
5317 match value {
5318 ffi::GTK_ICON_SIZE_INHERIT => Self::Inherit,
5319 ffi::GTK_ICON_SIZE_NORMAL => Self::Normal,
5320 ffi::GTK_ICON_SIZE_LARGE => Self::Large,
5321 value => Self::__Unknown(value),
5322 }
5323 }
5324}
5325
5326impl StaticType for IconSize {
5327 #[inline]
5328 #[doc(alias = "gtk_icon_size_get_type")]
5329 fn static_type() -> glib::Type {
5330 unsafe { from_glib(ffi::gtk_icon_size_get_type()) }
5331 }
5332}
5333
5334impl glib::HasParamSpec for IconSize {
5335 type ParamSpec = glib::ParamSpecEnum;
5336 type SetValue = Self;
5337 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
5338
5339 fn param_spec_builder() -> Self::BuilderFn {
5340 Self::ParamSpec::builder_with_default
5341 }
5342}
5343
5344impl glib::value::ValueType for IconSize {
5345 type Type = Self;
5346}
5347
5348unsafe impl<'a> glib::value::FromValue<'a> for IconSize {
5349 type Checker = glib::value::GenericValueTypeChecker<Self>;
5350
5351 #[inline]
5352 unsafe fn from_value(value: &'a glib::Value) -> Self {
5353 skip_assert_initialized!();
5354 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
5355 }
5356}
5357
5358impl ToValue for IconSize {
5359 #[inline]
5360 fn to_value(&self) -> glib::Value {
5361 let mut value = glib::Value::for_value_type::<Self>();
5362 unsafe {
5363 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
5364 }
5365 value
5366 }
5367
5368 #[inline]
5369 fn value_type(&self) -> glib::Type {
5370 Self::static_type()
5371 }
5372}
5373
5374impl From<IconSize> for glib::Value {
5375 #[inline]
5376 fn from(v: IconSize) -> Self {
5377 skip_assert_initialized!();
5378 ToValue::to_value(&v)
5379 }
5380}
5381
5382#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
5383#[non_exhaustive]
5384#[doc(alias = "GtkIconThemeError")]
5385pub enum IconThemeError {
5386 #[doc(alias = "GTK_ICON_THEME_NOT_FOUND")]
5387 NotFound,
5388 #[doc(alias = "GTK_ICON_THEME_FAILED")]
5389 Failed,
5390 #[doc(hidden)]
5391 __Unknown(i32),
5392}
5393
5394#[doc(hidden)]
5395impl IntoGlib for IconThemeError {
5396 type GlibType = ffi::GtkIconThemeError;
5397
5398 #[inline]
5399 fn into_glib(self) -> ffi::GtkIconThemeError {
5400 match self {
5401 Self::NotFound => ffi::GTK_ICON_THEME_NOT_FOUND,
5402 Self::Failed => ffi::GTK_ICON_THEME_FAILED,
5403 Self::__Unknown(value) => value,
5404 }
5405 }
5406}
5407
5408#[doc(hidden)]
5409impl FromGlib<ffi::GtkIconThemeError> for IconThemeError {
5410 #[inline]
5411 unsafe fn from_glib(value: ffi::GtkIconThemeError) -> Self {
5412 skip_assert_initialized!();
5413
5414 match value {
5415 ffi::GTK_ICON_THEME_NOT_FOUND => Self::NotFound,
5416 ffi::GTK_ICON_THEME_FAILED => Self::Failed,
5417 value => Self::__Unknown(value),
5418 }
5419 }
5420}
5421
5422impl glib::error::ErrorDomain for IconThemeError {
5423 #[inline]
5424 fn domain() -> glib::Quark {
5425 skip_assert_initialized!();
5426
5427 unsafe { from_glib(ffi::gtk_icon_theme_error_quark()) }
5428 }
5429
5430 #[inline]
5431 fn code(self) -> i32 {
5432 self.into_glib()
5433 }
5434
5435 #[inline]
5436 #[allow(clippy::match_single_binding)]
5437 fn from(code: i32) -> Option<Self> {
5438 skip_assert_initialized!();
5439 match unsafe { from_glib(code) } {
5440 Self::__Unknown(_) => Some(Self::Failed),
5441 value => Some(value),
5442 }
5443 }
5444}
5445
5446impl StaticType for IconThemeError {
5447 #[inline]
5448 #[doc(alias = "gtk_icon_theme_error_get_type")]
5449 fn static_type() -> glib::Type {
5450 unsafe { from_glib(ffi::gtk_icon_theme_error_get_type()) }
5451 }
5452}
5453
5454impl glib::HasParamSpec for IconThemeError {
5455 type ParamSpec = glib::ParamSpecEnum;
5456 type SetValue = Self;
5457 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
5458
5459 fn param_spec_builder() -> Self::BuilderFn {
5460 Self::ParamSpec::builder_with_default
5461 }
5462}
5463
5464impl glib::value::ValueType for IconThemeError {
5465 type Type = Self;
5466}
5467
5468unsafe impl<'a> glib::value::FromValue<'a> for IconThemeError {
5469 type Checker = glib::value::GenericValueTypeChecker<Self>;
5470
5471 #[inline]
5472 unsafe fn from_value(value: &'a glib::Value) -> Self {
5473 skip_assert_initialized!();
5474 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
5475 }
5476}
5477
5478impl ToValue for IconThemeError {
5479 #[inline]
5480 fn to_value(&self) -> glib::Value {
5481 let mut value = glib::Value::for_value_type::<Self>();
5482 unsafe {
5483 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
5484 }
5485 value
5486 }
5487
5488 #[inline]
5489 fn value_type(&self) -> glib::Type {
5490 Self::static_type()
5491 }
5492}
5493
5494impl From<IconThemeError> for glib::Value {
5495 #[inline]
5496 fn from(v: IconThemeError) -> Self {
5497 skip_assert_initialized!();
5498 ToValue::to_value(&v)
5499 }
5500}
5501
5502#[cfg_attr(feature = "v4_20", deprecated = "Since 4.20")]
5503#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
5504#[non_exhaustive]
5505#[doc(alias = "GtkIconViewDropPosition")]
5506pub enum IconViewDropPosition {
5507 #[doc(alias = "GTK_ICON_VIEW_NO_DROP")]
5508 NoDrop,
5509 #[doc(alias = "GTK_ICON_VIEW_DROP_INTO")]
5510 DropInto,
5511 #[doc(alias = "GTK_ICON_VIEW_DROP_LEFT")]
5512 DropLeft,
5513 #[doc(alias = "GTK_ICON_VIEW_DROP_RIGHT")]
5514 DropRight,
5515 #[doc(alias = "GTK_ICON_VIEW_DROP_ABOVE")]
5516 DropAbove,
5517 #[doc(alias = "GTK_ICON_VIEW_DROP_BELOW")]
5518 DropBelow,
5519 #[doc(hidden)]
5520 __Unknown(i32),
5521}
5522
5523#[allow(deprecated)]
5524#[doc(hidden)]
5525impl IntoGlib for IconViewDropPosition {
5526 type GlibType = ffi::GtkIconViewDropPosition;
5527
5528 #[inline]
5529 fn into_glib(self) -> ffi::GtkIconViewDropPosition {
5530 match self {
5531 Self::NoDrop => ffi::GTK_ICON_VIEW_NO_DROP,
5532 Self::DropInto => ffi::GTK_ICON_VIEW_DROP_INTO,
5533 Self::DropLeft => ffi::GTK_ICON_VIEW_DROP_LEFT,
5534 Self::DropRight => ffi::GTK_ICON_VIEW_DROP_RIGHT,
5535 Self::DropAbove => ffi::GTK_ICON_VIEW_DROP_ABOVE,
5536 Self::DropBelow => ffi::GTK_ICON_VIEW_DROP_BELOW,
5537 Self::__Unknown(value) => value,
5538 }
5539 }
5540}
5541
5542#[allow(deprecated)]
5543#[doc(hidden)]
5544impl FromGlib<ffi::GtkIconViewDropPosition> for IconViewDropPosition {
5545 #[inline]
5546 unsafe fn from_glib(value: ffi::GtkIconViewDropPosition) -> Self {
5547 skip_assert_initialized!();
5548
5549 match value {
5550 ffi::GTK_ICON_VIEW_NO_DROP => Self::NoDrop,
5551 ffi::GTK_ICON_VIEW_DROP_INTO => Self::DropInto,
5552 ffi::GTK_ICON_VIEW_DROP_LEFT => Self::DropLeft,
5553 ffi::GTK_ICON_VIEW_DROP_RIGHT => Self::DropRight,
5554 ffi::GTK_ICON_VIEW_DROP_ABOVE => Self::DropAbove,
5555 ffi::GTK_ICON_VIEW_DROP_BELOW => Self::DropBelow,
5556 value => Self::__Unknown(value),
5557 }
5558 }
5559}
5560
5561#[allow(deprecated)]
5562impl StaticType for IconViewDropPosition {
5563 #[inline]
5564 #[doc(alias = "gtk_icon_view_drop_position_get_type")]
5565 fn static_type() -> glib::Type {
5566 unsafe { from_glib(ffi::gtk_icon_view_drop_position_get_type()) }
5567 }
5568}
5569
5570#[allow(deprecated)]
5571impl glib::HasParamSpec for IconViewDropPosition {
5572 type ParamSpec = glib::ParamSpecEnum;
5573 type SetValue = Self;
5574 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
5575
5576 fn param_spec_builder() -> Self::BuilderFn {
5577 Self::ParamSpec::builder_with_default
5578 }
5579}
5580
5581#[allow(deprecated)]
5582impl glib::value::ValueType for IconViewDropPosition {
5583 type Type = Self;
5584}
5585
5586#[allow(deprecated)]
5587unsafe impl<'a> glib::value::FromValue<'a> for IconViewDropPosition {
5588 type Checker = glib::value::GenericValueTypeChecker<Self>;
5589
5590 #[inline]
5591 unsafe fn from_value(value: &'a glib::Value) -> Self {
5592 skip_assert_initialized!();
5593 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
5594 }
5595}
5596
5597#[allow(deprecated)]
5598impl ToValue for IconViewDropPosition {
5599 #[inline]
5600 fn to_value(&self) -> glib::Value {
5601 let mut value = glib::Value::for_value_type::<Self>();
5602 unsafe {
5603 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
5604 }
5605 value
5606 }
5607
5608 #[inline]
5609 fn value_type(&self) -> glib::Type {
5610 Self::static_type()
5611 }
5612}
5613
5614#[allow(deprecated)]
5615impl From<IconViewDropPosition> for glib::Value {
5616 #[inline]
5617 fn from(v: IconViewDropPosition) -> Self {
5618 skip_assert_initialized!();
5619 ToValue::to_value(&v)
5620 }
5621}
5622
5623#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
5624#[non_exhaustive]
5625#[doc(alias = "GtkImageType")]
5626pub enum ImageType {
5627 #[doc(alias = "GTK_IMAGE_EMPTY")]
5628 Empty,
5629 #[doc(alias = "GTK_IMAGE_ICON_NAME")]
5630 IconName,
5631 #[doc(alias = "GTK_IMAGE_GICON")]
5632 Gicon,
5633 #[doc(alias = "GTK_IMAGE_PAINTABLE")]
5634 Paintable,
5635 #[doc(hidden)]
5636 __Unknown(i32),
5637}
5638
5639#[doc(hidden)]
5640impl IntoGlib for ImageType {
5641 type GlibType = ffi::GtkImageType;
5642
5643 #[inline]
5644 fn into_glib(self) -> ffi::GtkImageType {
5645 match self {
5646 Self::Empty => ffi::GTK_IMAGE_EMPTY,
5647 Self::IconName => ffi::GTK_IMAGE_ICON_NAME,
5648 Self::Gicon => ffi::GTK_IMAGE_GICON,
5649 Self::Paintable => ffi::GTK_IMAGE_PAINTABLE,
5650 Self::__Unknown(value) => value,
5651 }
5652 }
5653}
5654
5655#[doc(hidden)]
5656impl FromGlib<ffi::GtkImageType> for ImageType {
5657 #[inline]
5658 unsafe fn from_glib(value: ffi::GtkImageType) -> Self {
5659 skip_assert_initialized!();
5660
5661 match value {
5662 ffi::GTK_IMAGE_EMPTY => Self::Empty,
5663 ffi::GTK_IMAGE_ICON_NAME => Self::IconName,
5664 ffi::GTK_IMAGE_GICON => Self::Gicon,
5665 ffi::GTK_IMAGE_PAINTABLE => Self::Paintable,
5666 value => Self::__Unknown(value),
5667 }
5668 }
5669}
5670
5671impl StaticType for ImageType {
5672 #[inline]
5673 #[doc(alias = "gtk_image_type_get_type")]
5674 fn static_type() -> glib::Type {
5675 unsafe { from_glib(ffi::gtk_image_type_get_type()) }
5676 }
5677}
5678
5679impl glib::HasParamSpec for ImageType {
5680 type ParamSpec = glib::ParamSpecEnum;
5681 type SetValue = Self;
5682 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
5683
5684 fn param_spec_builder() -> Self::BuilderFn {
5685 Self::ParamSpec::builder_with_default
5686 }
5687}
5688
5689impl glib::value::ValueType for ImageType {
5690 type Type = Self;
5691}
5692
5693unsafe impl<'a> glib::value::FromValue<'a> for ImageType {
5694 type Checker = glib::value::GenericValueTypeChecker<Self>;
5695
5696 #[inline]
5697 unsafe fn from_value(value: &'a glib::Value) -> Self {
5698 skip_assert_initialized!();
5699 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
5700 }
5701}
5702
5703impl ToValue for ImageType {
5704 #[inline]
5705 fn to_value(&self) -> glib::Value {
5706 let mut value = glib::Value::for_value_type::<Self>();
5707 unsafe {
5708 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
5709 }
5710 value
5711 }
5712
5713 #[inline]
5714 fn value_type(&self) -> glib::Type {
5715 Self::static_type()
5716 }
5717}
5718
5719impl From<ImageType> for glib::Value {
5720 #[inline]
5721 fn from(v: ImageType) -> Self {
5722 skip_assert_initialized!();
5723 ToValue::to_value(&v)
5724 }
5725}
5726
5727#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
5728#[non_exhaustive]
5729#[doc(alias = "GtkInputPurpose")]
5730pub enum InputPurpose {
5731 #[doc(alias = "GTK_INPUT_PURPOSE_FREE_FORM")]
5732 FreeForm,
5733 #[doc(alias = "GTK_INPUT_PURPOSE_ALPHA")]
5734 Alpha,
5735 #[doc(alias = "GTK_INPUT_PURPOSE_DIGITS")]
5736 Digits,
5737 #[doc(alias = "GTK_INPUT_PURPOSE_NUMBER")]
5738 Number,
5739 #[doc(alias = "GTK_INPUT_PURPOSE_PHONE")]
5740 Phone,
5741 #[doc(alias = "GTK_INPUT_PURPOSE_URL")]
5742 Url,
5743 #[doc(alias = "GTK_INPUT_PURPOSE_EMAIL")]
5744 Email,
5745 #[doc(alias = "GTK_INPUT_PURPOSE_NAME")]
5746 Name,
5747 #[doc(alias = "GTK_INPUT_PURPOSE_PASSWORD")]
5748 Password,
5749 #[doc(alias = "GTK_INPUT_PURPOSE_PIN")]
5750 Pin,
5751 #[doc(alias = "GTK_INPUT_PURPOSE_TERMINAL")]
5752 Terminal,
5753 #[doc(hidden)]
5754 __Unknown(i32),
5755}
5756
5757#[doc(hidden)]
5758impl IntoGlib for InputPurpose {
5759 type GlibType = ffi::GtkInputPurpose;
5760
5761 #[inline]
5762 fn into_glib(self) -> ffi::GtkInputPurpose {
5763 match self {
5764 Self::FreeForm => ffi::GTK_INPUT_PURPOSE_FREE_FORM,
5765 Self::Alpha => ffi::GTK_INPUT_PURPOSE_ALPHA,
5766 Self::Digits => ffi::GTK_INPUT_PURPOSE_DIGITS,
5767 Self::Number => ffi::GTK_INPUT_PURPOSE_NUMBER,
5768 Self::Phone => ffi::GTK_INPUT_PURPOSE_PHONE,
5769 Self::Url => ffi::GTK_INPUT_PURPOSE_URL,
5770 Self::Email => ffi::GTK_INPUT_PURPOSE_EMAIL,
5771 Self::Name => ffi::GTK_INPUT_PURPOSE_NAME,
5772 Self::Password => ffi::GTK_INPUT_PURPOSE_PASSWORD,
5773 Self::Pin => ffi::GTK_INPUT_PURPOSE_PIN,
5774 Self::Terminal => ffi::GTK_INPUT_PURPOSE_TERMINAL,
5775 Self::__Unknown(value) => value,
5776 }
5777 }
5778}
5779
5780#[doc(hidden)]
5781impl FromGlib<ffi::GtkInputPurpose> for InputPurpose {
5782 #[inline]
5783 unsafe fn from_glib(value: ffi::GtkInputPurpose) -> Self {
5784 skip_assert_initialized!();
5785
5786 match value {
5787 ffi::GTK_INPUT_PURPOSE_FREE_FORM => Self::FreeForm,
5788 ffi::GTK_INPUT_PURPOSE_ALPHA => Self::Alpha,
5789 ffi::GTK_INPUT_PURPOSE_DIGITS => Self::Digits,
5790 ffi::GTK_INPUT_PURPOSE_NUMBER => Self::Number,
5791 ffi::GTK_INPUT_PURPOSE_PHONE => Self::Phone,
5792 ffi::GTK_INPUT_PURPOSE_URL => Self::Url,
5793 ffi::GTK_INPUT_PURPOSE_EMAIL => Self::Email,
5794 ffi::GTK_INPUT_PURPOSE_NAME => Self::Name,
5795 ffi::GTK_INPUT_PURPOSE_PASSWORD => Self::Password,
5796 ffi::GTK_INPUT_PURPOSE_PIN => Self::Pin,
5797 ffi::GTK_INPUT_PURPOSE_TERMINAL => Self::Terminal,
5798 value => Self::__Unknown(value),
5799 }
5800 }
5801}
5802
5803impl StaticType for InputPurpose {
5804 #[inline]
5805 #[doc(alias = "gtk_input_purpose_get_type")]
5806 fn static_type() -> glib::Type {
5807 unsafe { from_glib(ffi::gtk_input_purpose_get_type()) }
5808 }
5809}
5810
5811impl glib::HasParamSpec for InputPurpose {
5812 type ParamSpec = glib::ParamSpecEnum;
5813 type SetValue = Self;
5814 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
5815
5816 fn param_spec_builder() -> Self::BuilderFn {
5817 Self::ParamSpec::builder_with_default
5818 }
5819}
5820
5821impl glib::value::ValueType for InputPurpose {
5822 type Type = Self;
5823}
5824
5825unsafe impl<'a> glib::value::FromValue<'a> for InputPurpose {
5826 type Checker = glib::value::GenericValueTypeChecker<Self>;
5827
5828 #[inline]
5829 unsafe fn from_value(value: &'a glib::Value) -> Self {
5830 skip_assert_initialized!();
5831 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
5832 }
5833}
5834
5835impl ToValue for InputPurpose {
5836 #[inline]
5837 fn to_value(&self) -> glib::Value {
5838 let mut value = glib::Value::for_value_type::<Self>();
5839 unsafe {
5840 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
5841 }
5842 value
5843 }
5844
5845 #[inline]
5846 fn value_type(&self) -> glib::Type {
5847 Self::static_type()
5848 }
5849}
5850
5851impl From<InputPurpose> for glib::Value {
5852 #[inline]
5853 fn from(v: InputPurpose) -> Self {
5854 skip_assert_initialized!();
5855 ToValue::to_value(&v)
5856 }
5857}
5858
5859#[cfg(feature = "v4_8")]
5860#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
5861#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
5862#[non_exhaustive]
5863#[doc(alias = "GtkInscriptionOverflow")]
5864pub enum InscriptionOverflow {
5865 #[doc(alias = "GTK_INSCRIPTION_OVERFLOW_CLIP")]
5866 Clip,
5867 #[doc(alias = "GTK_INSCRIPTION_OVERFLOW_ELLIPSIZE_START")]
5868 EllipsizeStart,
5869 #[doc(alias = "GTK_INSCRIPTION_OVERFLOW_ELLIPSIZE_MIDDLE")]
5870 EllipsizeMiddle,
5871 #[doc(alias = "GTK_INSCRIPTION_OVERFLOW_ELLIPSIZE_END")]
5872 EllipsizeEnd,
5873 #[doc(hidden)]
5874 __Unknown(i32),
5875}
5876
5877#[cfg(feature = "v4_8")]
5878#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
5879#[doc(hidden)]
5880impl IntoGlib for InscriptionOverflow {
5881 type GlibType = ffi::GtkInscriptionOverflow;
5882
5883 #[inline]
5884 fn into_glib(self) -> ffi::GtkInscriptionOverflow {
5885 match self {
5886 Self::Clip => ffi::GTK_INSCRIPTION_OVERFLOW_CLIP,
5887 Self::EllipsizeStart => ffi::GTK_INSCRIPTION_OVERFLOW_ELLIPSIZE_START,
5888 Self::EllipsizeMiddle => ffi::GTK_INSCRIPTION_OVERFLOW_ELLIPSIZE_MIDDLE,
5889 Self::EllipsizeEnd => ffi::GTK_INSCRIPTION_OVERFLOW_ELLIPSIZE_END,
5890 Self::__Unknown(value) => value,
5891 }
5892 }
5893}
5894
5895#[cfg(feature = "v4_8")]
5896#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
5897#[doc(hidden)]
5898impl FromGlib<ffi::GtkInscriptionOverflow> for InscriptionOverflow {
5899 #[inline]
5900 unsafe fn from_glib(value: ffi::GtkInscriptionOverflow) -> Self {
5901 skip_assert_initialized!();
5902
5903 match value {
5904 ffi::GTK_INSCRIPTION_OVERFLOW_CLIP => Self::Clip,
5905 ffi::GTK_INSCRIPTION_OVERFLOW_ELLIPSIZE_START => Self::EllipsizeStart,
5906 ffi::GTK_INSCRIPTION_OVERFLOW_ELLIPSIZE_MIDDLE => Self::EllipsizeMiddle,
5907 ffi::GTK_INSCRIPTION_OVERFLOW_ELLIPSIZE_END => Self::EllipsizeEnd,
5908 value => Self::__Unknown(value),
5909 }
5910 }
5911}
5912
5913#[cfg(feature = "v4_8")]
5914#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
5915impl StaticType for InscriptionOverflow {
5916 #[inline]
5917 #[doc(alias = "gtk_inscription_overflow_get_type")]
5918 fn static_type() -> glib::Type {
5919 unsafe { from_glib(ffi::gtk_inscription_overflow_get_type()) }
5920 }
5921}
5922
5923#[cfg(feature = "v4_8")]
5924#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
5925impl glib::HasParamSpec for InscriptionOverflow {
5926 type ParamSpec = glib::ParamSpecEnum;
5927 type SetValue = Self;
5928 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
5929
5930 fn param_spec_builder() -> Self::BuilderFn {
5931 Self::ParamSpec::builder_with_default
5932 }
5933}
5934
5935#[cfg(feature = "v4_8")]
5936#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
5937impl glib::value::ValueType for InscriptionOverflow {
5938 type Type = Self;
5939}
5940
5941#[cfg(feature = "v4_8")]
5942#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
5943unsafe impl<'a> glib::value::FromValue<'a> for InscriptionOverflow {
5944 type Checker = glib::value::GenericValueTypeChecker<Self>;
5945
5946 #[inline]
5947 unsafe fn from_value(value: &'a glib::Value) -> Self {
5948 skip_assert_initialized!();
5949 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
5950 }
5951}
5952
5953#[cfg(feature = "v4_8")]
5954#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
5955impl ToValue for InscriptionOverflow {
5956 #[inline]
5957 fn to_value(&self) -> glib::Value {
5958 let mut value = glib::Value::for_value_type::<Self>();
5959 unsafe {
5960 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
5961 }
5962 value
5963 }
5964
5965 #[inline]
5966 fn value_type(&self) -> glib::Type {
5967 Self::static_type()
5968 }
5969}
5970
5971#[cfg(feature = "v4_8")]
5972#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
5973impl From<InscriptionOverflow> for glib::Value {
5974 #[inline]
5975 fn from(v: InscriptionOverflow) -> Self {
5976 skip_assert_initialized!();
5977 ToValue::to_value(&v)
5978 }
5979}
5980
5981#[cfg(feature = "v4_20")]
5982#[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
5983#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
5984#[non_exhaustive]
5985#[doc(alias = "GtkInterfaceColorScheme")]
5986pub enum InterfaceColorScheme {
5987 #[doc(alias = "GTK_INTERFACE_COLOR_SCHEME_UNSUPPORTED")]
5988 Unsupported,
5989 #[doc(alias = "GTK_INTERFACE_COLOR_SCHEME_DEFAULT")]
5990 Default,
5991 #[doc(alias = "GTK_INTERFACE_COLOR_SCHEME_DARK")]
5992 Dark,
5993 #[doc(alias = "GTK_INTERFACE_COLOR_SCHEME_LIGHT")]
5994 Light,
5995 #[doc(hidden)]
5996 __Unknown(i32),
5997}
5998
5999#[cfg(feature = "v4_20")]
6000#[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
6001#[doc(hidden)]
6002impl IntoGlib for InterfaceColorScheme {
6003 type GlibType = ffi::GtkInterfaceColorScheme;
6004
6005 #[inline]
6006 fn into_glib(self) -> ffi::GtkInterfaceColorScheme {
6007 match self {
6008 Self::Unsupported => ffi::GTK_INTERFACE_COLOR_SCHEME_UNSUPPORTED,
6009 Self::Default => ffi::GTK_INTERFACE_COLOR_SCHEME_DEFAULT,
6010 Self::Dark => ffi::GTK_INTERFACE_COLOR_SCHEME_DARK,
6011 Self::Light => ffi::GTK_INTERFACE_COLOR_SCHEME_LIGHT,
6012 Self::__Unknown(value) => value,
6013 }
6014 }
6015}
6016
6017#[cfg(feature = "v4_20")]
6018#[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
6019#[doc(hidden)]
6020impl FromGlib<ffi::GtkInterfaceColorScheme> for InterfaceColorScheme {
6021 #[inline]
6022 unsafe fn from_glib(value: ffi::GtkInterfaceColorScheme) -> Self {
6023 skip_assert_initialized!();
6024
6025 match value {
6026 ffi::GTK_INTERFACE_COLOR_SCHEME_UNSUPPORTED => Self::Unsupported,
6027 ffi::GTK_INTERFACE_COLOR_SCHEME_DEFAULT => Self::Default,
6028 ffi::GTK_INTERFACE_COLOR_SCHEME_DARK => Self::Dark,
6029 ffi::GTK_INTERFACE_COLOR_SCHEME_LIGHT => Self::Light,
6030 value => Self::__Unknown(value),
6031 }
6032 }
6033}
6034
6035#[cfg(feature = "v4_20")]
6036#[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
6037impl StaticType for InterfaceColorScheme {
6038 #[inline]
6039 #[doc(alias = "gtk_interface_color_scheme_get_type")]
6040 fn static_type() -> glib::Type {
6041 unsafe { from_glib(ffi::gtk_interface_color_scheme_get_type()) }
6042 }
6043}
6044
6045#[cfg(feature = "v4_20")]
6046#[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
6047impl glib::HasParamSpec for InterfaceColorScheme {
6048 type ParamSpec = glib::ParamSpecEnum;
6049 type SetValue = Self;
6050 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
6051
6052 fn param_spec_builder() -> Self::BuilderFn {
6053 Self::ParamSpec::builder_with_default
6054 }
6055}
6056
6057#[cfg(feature = "v4_20")]
6058#[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
6059impl glib::value::ValueType for InterfaceColorScheme {
6060 type Type = Self;
6061}
6062
6063#[cfg(feature = "v4_20")]
6064#[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
6065unsafe impl<'a> glib::value::FromValue<'a> for InterfaceColorScheme {
6066 type Checker = glib::value::GenericValueTypeChecker<Self>;
6067
6068 #[inline]
6069 unsafe fn from_value(value: &'a glib::Value) -> Self {
6070 skip_assert_initialized!();
6071 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
6072 }
6073}
6074
6075#[cfg(feature = "v4_20")]
6076#[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
6077impl ToValue for InterfaceColorScheme {
6078 #[inline]
6079 fn to_value(&self) -> glib::Value {
6080 let mut value = glib::Value::for_value_type::<Self>();
6081 unsafe {
6082 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
6083 }
6084 value
6085 }
6086
6087 #[inline]
6088 fn value_type(&self) -> glib::Type {
6089 Self::static_type()
6090 }
6091}
6092
6093#[cfg(feature = "v4_20")]
6094#[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
6095impl From<InterfaceColorScheme> for glib::Value {
6096 #[inline]
6097 fn from(v: InterfaceColorScheme) -> Self {
6098 skip_assert_initialized!();
6099 ToValue::to_value(&v)
6100 }
6101}
6102
6103#[cfg(feature = "v4_20")]
6104#[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
6105#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
6106#[non_exhaustive]
6107#[doc(alias = "GtkInterfaceContrast")]
6108pub enum InterfaceContrast {
6109 #[doc(alias = "GTK_INTERFACE_CONTRAST_UNSUPPORTED")]
6110 Unsupported,
6111 #[doc(alias = "GTK_INTERFACE_CONTRAST_NO_PREFERENCE")]
6112 NoPreference,
6113 #[doc(alias = "GTK_INTERFACE_CONTRAST_MORE")]
6114 More,
6115 #[doc(alias = "GTK_INTERFACE_CONTRAST_LESS")]
6116 Less,
6117 #[doc(hidden)]
6118 __Unknown(i32),
6119}
6120
6121#[cfg(feature = "v4_20")]
6122#[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
6123#[doc(hidden)]
6124impl IntoGlib for InterfaceContrast {
6125 type GlibType = ffi::GtkInterfaceContrast;
6126
6127 #[inline]
6128 fn into_glib(self) -> ffi::GtkInterfaceContrast {
6129 match self {
6130 Self::Unsupported => ffi::GTK_INTERFACE_CONTRAST_UNSUPPORTED,
6131 Self::NoPreference => ffi::GTK_INTERFACE_CONTRAST_NO_PREFERENCE,
6132 Self::More => ffi::GTK_INTERFACE_CONTRAST_MORE,
6133 Self::Less => ffi::GTK_INTERFACE_CONTRAST_LESS,
6134 Self::__Unknown(value) => value,
6135 }
6136 }
6137}
6138
6139#[cfg(feature = "v4_20")]
6140#[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
6141#[doc(hidden)]
6142impl FromGlib<ffi::GtkInterfaceContrast> for InterfaceContrast {
6143 #[inline]
6144 unsafe fn from_glib(value: ffi::GtkInterfaceContrast) -> Self {
6145 skip_assert_initialized!();
6146
6147 match value {
6148 ffi::GTK_INTERFACE_CONTRAST_UNSUPPORTED => Self::Unsupported,
6149 ffi::GTK_INTERFACE_CONTRAST_NO_PREFERENCE => Self::NoPreference,
6150 ffi::GTK_INTERFACE_CONTRAST_MORE => Self::More,
6151 ffi::GTK_INTERFACE_CONTRAST_LESS => Self::Less,
6152 value => Self::__Unknown(value),
6153 }
6154 }
6155}
6156
6157#[cfg(feature = "v4_20")]
6158#[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
6159impl StaticType for InterfaceContrast {
6160 #[inline]
6161 #[doc(alias = "gtk_interface_contrast_get_type")]
6162 fn static_type() -> glib::Type {
6163 unsafe { from_glib(ffi::gtk_interface_contrast_get_type()) }
6164 }
6165}
6166
6167#[cfg(feature = "v4_20")]
6168#[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
6169impl glib::HasParamSpec for InterfaceContrast {
6170 type ParamSpec = glib::ParamSpecEnum;
6171 type SetValue = Self;
6172 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
6173
6174 fn param_spec_builder() -> Self::BuilderFn {
6175 Self::ParamSpec::builder_with_default
6176 }
6177}
6178
6179#[cfg(feature = "v4_20")]
6180#[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
6181impl glib::value::ValueType for InterfaceContrast {
6182 type Type = Self;
6183}
6184
6185#[cfg(feature = "v4_20")]
6186#[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
6187unsafe impl<'a> glib::value::FromValue<'a> for InterfaceContrast {
6188 type Checker = glib::value::GenericValueTypeChecker<Self>;
6189
6190 #[inline]
6191 unsafe fn from_value(value: &'a glib::Value) -> Self {
6192 skip_assert_initialized!();
6193 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
6194 }
6195}
6196
6197#[cfg(feature = "v4_20")]
6198#[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
6199impl ToValue for InterfaceContrast {
6200 #[inline]
6201 fn to_value(&self) -> glib::Value {
6202 let mut value = glib::Value::for_value_type::<Self>();
6203 unsafe {
6204 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
6205 }
6206 value
6207 }
6208
6209 #[inline]
6210 fn value_type(&self) -> glib::Type {
6211 Self::static_type()
6212 }
6213}
6214
6215#[cfg(feature = "v4_20")]
6216#[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
6217impl From<InterfaceContrast> for glib::Value {
6218 #[inline]
6219 fn from(v: InterfaceContrast) -> Self {
6220 skip_assert_initialized!();
6221 ToValue::to_value(&v)
6222 }
6223}
6224
6225#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
6226#[non_exhaustive]
6227#[doc(alias = "GtkJustification")]
6228pub enum Justification {
6229 #[doc(alias = "GTK_JUSTIFY_LEFT")]
6230 Left,
6231 #[doc(alias = "GTK_JUSTIFY_RIGHT")]
6232 Right,
6233 #[doc(alias = "GTK_JUSTIFY_CENTER")]
6234 Center,
6235 #[doc(alias = "GTK_JUSTIFY_FILL")]
6236 Fill,
6237 #[doc(hidden)]
6238 __Unknown(i32),
6239}
6240
6241#[doc(hidden)]
6242impl IntoGlib for Justification {
6243 type GlibType = ffi::GtkJustification;
6244
6245 #[inline]
6246 fn into_glib(self) -> ffi::GtkJustification {
6247 match self {
6248 Self::Left => ffi::GTK_JUSTIFY_LEFT,
6249 Self::Right => ffi::GTK_JUSTIFY_RIGHT,
6250 Self::Center => ffi::GTK_JUSTIFY_CENTER,
6251 Self::Fill => ffi::GTK_JUSTIFY_FILL,
6252 Self::__Unknown(value) => value,
6253 }
6254 }
6255}
6256
6257#[doc(hidden)]
6258impl FromGlib<ffi::GtkJustification> for Justification {
6259 #[inline]
6260 unsafe fn from_glib(value: ffi::GtkJustification) -> Self {
6261 skip_assert_initialized!();
6262
6263 match value {
6264 ffi::GTK_JUSTIFY_LEFT => Self::Left,
6265 ffi::GTK_JUSTIFY_RIGHT => Self::Right,
6266 ffi::GTK_JUSTIFY_CENTER => Self::Center,
6267 ffi::GTK_JUSTIFY_FILL => Self::Fill,
6268 value => Self::__Unknown(value),
6269 }
6270 }
6271}
6272
6273impl StaticType for Justification {
6274 #[inline]
6275 #[doc(alias = "gtk_justification_get_type")]
6276 fn static_type() -> glib::Type {
6277 unsafe { from_glib(ffi::gtk_justification_get_type()) }
6278 }
6279}
6280
6281impl glib::HasParamSpec for Justification {
6282 type ParamSpec = glib::ParamSpecEnum;
6283 type SetValue = Self;
6284 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
6285
6286 fn param_spec_builder() -> Self::BuilderFn {
6287 Self::ParamSpec::builder_with_default
6288 }
6289}
6290
6291impl glib::value::ValueType for Justification {
6292 type Type = Self;
6293}
6294
6295unsafe impl<'a> glib::value::FromValue<'a> for Justification {
6296 type Checker = glib::value::GenericValueTypeChecker<Self>;
6297
6298 #[inline]
6299 unsafe fn from_value(value: &'a glib::Value) -> Self {
6300 skip_assert_initialized!();
6301 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
6302 }
6303}
6304
6305impl ToValue for Justification {
6306 #[inline]
6307 fn to_value(&self) -> glib::Value {
6308 let mut value = glib::Value::for_value_type::<Self>();
6309 unsafe {
6310 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
6311 }
6312 value
6313 }
6314
6315 #[inline]
6316 fn value_type(&self) -> glib::Type {
6317 Self::static_type()
6318 }
6319}
6320
6321impl From<Justification> for glib::Value {
6322 #[inline]
6323 fn from(v: Justification) -> Self {
6324 skip_assert_initialized!();
6325 ToValue::to_value(&v)
6326 }
6327}
6328
6329#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
6330#[non_exhaustive]
6331#[doc(alias = "GtkLevelBarMode")]
6332pub enum LevelBarMode {
6333 #[doc(alias = "GTK_LEVEL_BAR_MODE_CONTINUOUS")]
6334 Continuous,
6335 #[doc(alias = "GTK_LEVEL_BAR_MODE_DISCRETE")]
6336 Discrete,
6337 #[doc(hidden)]
6338 __Unknown(i32),
6339}
6340
6341#[doc(hidden)]
6342impl IntoGlib for LevelBarMode {
6343 type GlibType = ffi::GtkLevelBarMode;
6344
6345 #[inline]
6346 fn into_glib(self) -> ffi::GtkLevelBarMode {
6347 match self {
6348 Self::Continuous => ffi::GTK_LEVEL_BAR_MODE_CONTINUOUS,
6349 Self::Discrete => ffi::GTK_LEVEL_BAR_MODE_DISCRETE,
6350 Self::__Unknown(value) => value,
6351 }
6352 }
6353}
6354
6355#[doc(hidden)]
6356impl FromGlib<ffi::GtkLevelBarMode> for LevelBarMode {
6357 #[inline]
6358 unsafe fn from_glib(value: ffi::GtkLevelBarMode) -> Self {
6359 skip_assert_initialized!();
6360
6361 match value {
6362 ffi::GTK_LEVEL_BAR_MODE_CONTINUOUS => Self::Continuous,
6363 ffi::GTK_LEVEL_BAR_MODE_DISCRETE => Self::Discrete,
6364 value => Self::__Unknown(value),
6365 }
6366 }
6367}
6368
6369impl StaticType for LevelBarMode {
6370 #[inline]
6371 #[doc(alias = "gtk_level_bar_mode_get_type")]
6372 fn static_type() -> glib::Type {
6373 unsafe { from_glib(ffi::gtk_level_bar_mode_get_type()) }
6374 }
6375}
6376
6377impl glib::HasParamSpec for LevelBarMode {
6378 type ParamSpec = glib::ParamSpecEnum;
6379 type SetValue = Self;
6380 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
6381
6382 fn param_spec_builder() -> Self::BuilderFn {
6383 Self::ParamSpec::builder_with_default
6384 }
6385}
6386
6387impl glib::value::ValueType for LevelBarMode {
6388 type Type = Self;
6389}
6390
6391unsafe impl<'a> glib::value::FromValue<'a> for LevelBarMode {
6392 type Checker = glib::value::GenericValueTypeChecker<Self>;
6393
6394 #[inline]
6395 unsafe fn from_value(value: &'a glib::Value) -> Self {
6396 skip_assert_initialized!();
6397 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
6398 }
6399}
6400
6401impl ToValue for LevelBarMode {
6402 #[inline]
6403 fn to_value(&self) -> glib::Value {
6404 let mut value = glib::Value::for_value_type::<Self>();
6405 unsafe {
6406 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
6407 }
6408 value
6409 }
6410
6411 #[inline]
6412 fn value_type(&self) -> glib::Type {
6413 Self::static_type()
6414 }
6415}
6416
6417impl From<LevelBarMode> for glib::Value {
6418 #[inline]
6419 fn from(v: LevelBarMode) -> Self {
6420 skip_assert_initialized!();
6421 ToValue::to_value(&v)
6422 }
6423}
6424
6425#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
6426#[non_exhaustive]
6427#[doc(alias = "GtkLicense")]
6428pub enum License {
6429 #[doc(alias = "GTK_LICENSE_UNKNOWN")]
6430 Unknown,
6431 #[doc(alias = "GTK_LICENSE_CUSTOM")]
6432 Custom,
6433 #[doc(alias = "GTK_LICENSE_GPL_2_0")]
6434 Gpl20,
6435 #[doc(alias = "GTK_LICENSE_GPL_3_0")]
6436 Gpl30,
6437 #[doc(alias = "GTK_LICENSE_LGPL_2_1")]
6438 Lgpl21,
6439 #[doc(alias = "GTK_LICENSE_LGPL_3_0")]
6440 Lgpl30,
6441 #[doc(alias = "GTK_LICENSE_BSD")]
6442 Bsd,
6443 #[doc(alias = "GTK_LICENSE_MIT_X11")]
6444 MitX11,
6445 #[doc(alias = "GTK_LICENSE_ARTISTIC")]
6446 Artistic,
6447 #[doc(alias = "GTK_LICENSE_GPL_2_0_ONLY")]
6448 Gpl20Only,
6449 #[doc(alias = "GTK_LICENSE_GPL_3_0_ONLY")]
6450 Gpl30Only,
6451 #[doc(alias = "GTK_LICENSE_LGPL_2_1_ONLY")]
6452 Lgpl21Only,
6453 #[doc(alias = "GTK_LICENSE_LGPL_3_0_ONLY")]
6454 Lgpl30Only,
6455 #[doc(alias = "GTK_LICENSE_AGPL_3_0")]
6456 Agpl30,
6457 #[doc(alias = "GTK_LICENSE_AGPL_3_0_ONLY")]
6458 Agpl30Only,
6459 #[doc(alias = "GTK_LICENSE_BSD_3")]
6460 Bsd3,
6461 #[doc(alias = "GTK_LICENSE_APACHE_2_0")]
6462 Apache20,
6463 #[doc(alias = "GTK_LICENSE_MPL_2_0")]
6464 Mpl20,
6465 #[cfg(feature = "v4_14")]
6466 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
6467 #[doc(alias = "GTK_LICENSE_0BSD")]
6468 _0bsd,
6469 #[doc(hidden)]
6470 __Unknown(i32),
6471}
6472
6473#[doc(hidden)]
6474impl IntoGlib for License {
6475 type GlibType = ffi::GtkLicense;
6476
6477 fn into_glib(self) -> ffi::GtkLicense {
6478 match self {
6479 Self::Unknown => ffi::GTK_LICENSE_UNKNOWN,
6480 Self::Custom => ffi::GTK_LICENSE_CUSTOM,
6481 Self::Gpl20 => ffi::GTK_LICENSE_GPL_2_0,
6482 Self::Gpl30 => ffi::GTK_LICENSE_GPL_3_0,
6483 Self::Lgpl21 => ffi::GTK_LICENSE_LGPL_2_1,
6484 Self::Lgpl30 => ffi::GTK_LICENSE_LGPL_3_0,
6485 Self::Bsd => ffi::GTK_LICENSE_BSD,
6486 Self::MitX11 => ffi::GTK_LICENSE_MIT_X11,
6487 Self::Artistic => ffi::GTK_LICENSE_ARTISTIC,
6488 Self::Gpl20Only => ffi::GTK_LICENSE_GPL_2_0_ONLY,
6489 Self::Gpl30Only => ffi::GTK_LICENSE_GPL_3_0_ONLY,
6490 Self::Lgpl21Only => ffi::GTK_LICENSE_LGPL_2_1_ONLY,
6491 Self::Lgpl30Only => ffi::GTK_LICENSE_LGPL_3_0_ONLY,
6492 Self::Agpl30 => ffi::GTK_LICENSE_AGPL_3_0,
6493 Self::Agpl30Only => ffi::GTK_LICENSE_AGPL_3_0_ONLY,
6494 Self::Bsd3 => ffi::GTK_LICENSE_BSD_3,
6495 Self::Apache20 => ffi::GTK_LICENSE_APACHE_2_0,
6496 Self::Mpl20 => ffi::GTK_LICENSE_MPL_2_0,
6497 #[cfg(feature = "v4_14")]
6498 Self::_0bsd => ffi::GTK_LICENSE_0BSD,
6499 Self::__Unknown(value) => value,
6500 }
6501 }
6502}
6503
6504#[doc(hidden)]
6505impl FromGlib<ffi::GtkLicense> for License {
6506 unsafe fn from_glib(value: ffi::GtkLicense) -> Self {
6507 skip_assert_initialized!();
6508
6509 match value {
6510 ffi::GTK_LICENSE_UNKNOWN => Self::Unknown,
6511 ffi::GTK_LICENSE_CUSTOM => Self::Custom,
6512 ffi::GTK_LICENSE_GPL_2_0 => Self::Gpl20,
6513 ffi::GTK_LICENSE_GPL_3_0 => Self::Gpl30,
6514 ffi::GTK_LICENSE_LGPL_2_1 => Self::Lgpl21,
6515 ffi::GTK_LICENSE_LGPL_3_0 => Self::Lgpl30,
6516 ffi::GTK_LICENSE_BSD => Self::Bsd,
6517 ffi::GTK_LICENSE_MIT_X11 => Self::MitX11,
6518 ffi::GTK_LICENSE_ARTISTIC => Self::Artistic,
6519 ffi::GTK_LICENSE_GPL_2_0_ONLY => Self::Gpl20Only,
6520 ffi::GTK_LICENSE_GPL_3_0_ONLY => Self::Gpl30Only,
6521 ffi::GTK_LICENSE_LGPL_2_1_ONLY => Self::Lgpl21Only,
6522 ffi::GTK_LICENSE_LGPL_3_0_ONLY => Self::Lgpl30Only,
6523 ffi::GTK_LICENSE_AGPL_3_0 => Self::Agpl30,
6524 ffi::GTK_LICENSE_AGPL_3_0_ONLY => Self::Agpl30Only,
6525 ffi::GTK_LICENSE_BSD_3 => Self::Bsd3,
6526 ffi::GTK_LICENSE_APACHE_2_0 => Self::Apache20,
6527 ffi::GTK_LICENSE_MPL_2_0 => Self::Mpl20,
6528 #[cfg(feature = "v4_14")]
6529 ffi::GTK_LICENSE_0BSD => Self::_0bsd,
6530 value => Self::__Unknown(value),
6531 }
6532 }
6533}
6534
6535impl StaticType for License {
6536 #[inline]
6537 #[doc(alias = "gtk_license_get_type")]
6538 fn static_type() -> glib::Type {
6539 unsafe { from_glib(ffi::gtk_license_get_type()) }
6540 }
6541}
6542
6543impl glib::HasParamSpec for License {
6544 type ParamSpec = glib::ParamSpecEnum;
6545 type SetValue = Self;
6546 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
6547
6548 fn param_spec_builder() -> Self::BuilderFn {
6549 Self::ParamSpec::builder_with_default
6550 }
6551}
6552
6553impl glib::value::ValueType for License {
6554 type Type = Self;
6555}
6556
6557unsafe impl<'a> glib::value::FromValue<'a> for License {
6558 type Checker = glib::value::GenericValueTypeChecker<Self>;
6559
6560 #[inline]
6561 unsafe fn from_value(value: &'a glib::Value) -> Self {
6562 skip_assert_initialized!();
6563 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
6564 }
6565}
6566
6567impl ToValue for License {
6568 #[inline]
6569 fn to_value(&self) -> glib::Value {
6570 let mut value = glib::Value::for_value_type::<Self>();
6571 unsafe {
6572 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
6573 }
6574 value
6575 }
6576
6577 #[inline]
6578 fn value_type(&self) -> glib::Type {
6579 Self::static_type()
6580 }
6581}
6582
6583impl From<License> for glib::Value {
6584 #[inline]
6585 fn from(v: License) -> Self {
6586 skip_assert_initialized!();
6587 ToValue::to_value(&v)
6588 }
6589}
6590
6591#[cfg(feature = "v4_12")]
6592#[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
6593#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
6594#[non_exhaustive]
6595#[doc(alias = "GtkListTabBehavior")]
6596pub enum ListTabBehavior {
6597 #[doc(alias = "GTK_LIST_TAB_ALL")]
6598 All,
6599 #[doc(alias = "GTK_LIST_TAB_ITEM")]
6600 Item,
6601 #[doc(alias = "GTK_LIST_TAB_CELL")]
6602 Cell,
6603 #[doc(hidden)]
6604 __Unknown(i32),
6605}
6606
6607#[cfg(feature = "v4_12")]
6608#[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
6609#[doc(hidden)]
6610impl IntoGlib for ListTabBehavior {
6611 type GlibType = ffi::GtkListTabBehavior;
6612
6613 #[inline]
6614 fn into_glib(self) -> ffi::GtkListTabBehavior {
6615 match self {
6616 Self::All => ffi::GTK_LIST_TAB_ALL,
6617 Self::Item => ffi::GTK_LIST_TAB_ITEM,
6618 Self::Cell => ffi::GTK_LIST_TAB_CELL,
6619 Self::__Unknown(value) => value,
6620 }
6621 }
6622}
6623
6624#[cfg(feature = "v4_12")]
6625#[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
6626#[doc(hidden)]
6627impl FromGlib<ffi::GtkListTabBehavior> for ListTabBehavior {
6628 #[inline]
6629 unsafe fn from_glib(value: ffi::GtkListTabBehavior) -> Self {
6630 skip_assert_initialized!();
6631
6632 match value {
6633 ffi::GTK_LIST_TAB_ALL => Self::All,
6634 ffi::GTK_LIST_TAB_ITEM => Self::Item,
6635 ffi::GTK_LIST_TAB_CELL => Self::Cell,
6636 value => Self::__Unknown(value),
6637 }
6638 }
6639}
6640
6641#[cfg(feature = "v4_12")]
6642#[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
6643impl StaticType for ListTabBehavior {
6644 #[inline]
6645 #[doc(alias = "gtk_list_tab_behavior_get_type")]
6646 fn static_type() -> glib::Type {
6647 unsafe { from_glib(ffi::gtk_list_tab_behavior_get_type()) }
6648 }
6649}
6650
6651#[cfg(feature = "v4_12")]
6652#[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
6653impl glib::HasParamSpec for ListTabBehavior {
6654 type ParamSpec = glib::ParamSpecEnum;
6655 type SetValue = Self;
6656 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
6657
6658 fn param_spec_builder() -> Self::BuilderFn {
6659 Self::ParamSpec::builder_with_default
6660 }
6661}
6662
6663#[cfg(feature = "v4_12")]
6664#[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
6665impl glib::value::ValueType for ListTabBehavior {
6666 type Type = Self;
6667}
6668
6669#[cfg(feature = "v4_12")]
6670#[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
6671unsafe impl<'a> glib::value::FromValue<'a> for ListTabBehavior {
6672 type Checker = glib::value::GenericValueTypeChecker<Self>;
6673
6674 #[inline]
6675 unsafe fn from_value(value: &'a glib::Value) -> Self {
6676 skip_assert_initialized!();
6677 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
6678 }
6679}
6680
6681#[cfg(feature = "v4_12")]
6682#[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
6683impl ToValue for ListTabBehavior {
6684 #[inline]
6685 fn to_value(&self) -> glib::Value {
6686 let mut value = glib::Value::for_value_type::<Self>();
6687 unsafe {
6688 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
6689 }
6690 value
6691 }
6692
6693 #[inline]
6694 fn value_type(&self) -> glib::Type {
6695 Self::static_type()
6696 }
6697}
6698
6699#[cfg(feature = "v4_12")]
6700#[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
6701impl From<ListTabBehavior> for glib::Value {
6702 #[inline]
6703 fn from(v: ListTabBehavior) -> Self {
6704 skip_assert_initialized!();
6705 ToValue::to_value(&v)
6706 }
6707}
6708
6709#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
6710#[non_exhaustive]
6711#[doc(alias = "GtkMessageType")]
6712pub enum MessageType {
6713 #[doc(alias = "GTK_MESSAGE_INFO")]
6714 Info,
6715 #[doc(alias = "GTK_MESSAGE_WARNING")]
6716 Warning,
6717 #[doc(alias = "GTK_MESSAGE_QUESTION")]
6718 Question,
6719 #[doc(alias = "GTK_MESSAGE_ERROR")]
6720 Error,
6721 #[doc(alias = "GTK_MESSAGE_OTHER")]
6722 Other,
6723 #[doc(hidden)]
6724 __Unknown(i32),
6725}
6726
6727#[doc(hidden)]
6728impl IntoGlib for MessageType {
6729 type GlibType = ffi::GtkMessageType;
6730
6731 #[inline]
6732 fn into_glib(self) -> ffi::GtkMessageType {
6733 match self {
6734 Self::Info => ffi::GTK_MESSAGE_INFO,
6735 Self::Warning => ffi::GTK_MESSAGE_WARNING,
6736 Self::Question => ffi::GTK_MESSAGE_QUESTION,
6737 Self::Error => ffi::GTK_MESSAGE_ERROR,
6738 Self::Other => ffi::GTK_MESSAGE_OTHER,
6739 Self::__Unknown(value) => value,
6740 }
6741 }
6742}
6743
6744#[doc(hidden)]
6745impl FromGlib<ffi::GtkMessageType> for MessageType {
6746 #[inline]
6747 unsafe fn from_glib(value: ffi::GtkMessageType) -> Self {
6748 skip_assert_initialized!();
6749
6750 match value {
6751 ffi::GTK_MESSAGE_INFO => Self::Info,
6752 ffi::GTK_MESSAGE_WARNING => Self::Warning,
6753 ffi::GTK_MESSAGE_QUESTION => Self::Question,
6754 ffi::GTK_MESSAGE_ERROR => Self::Error,
6755 ffi::GTK_MESSAGE_OTHER => Self::Other,
6756 value => Self::__Unknown(value),
6757 }
6758 }
6759}
6760
6761impl StaticType for MessageType {
6762 #[inline]
6763 #[doc(alias = "gtk_message_type_get_type")]
6764 fn static_type() -> glib::Type {
6765 unsafe { from_glib(ffi::gtk_message_type_get_type()) }
6766 }
6767}
6768
6769impl glib::HasParamSpec for MessageType {
6770 type ParamSpec = glib::ParamSpecEnum;
6771 type SetValue = Self;
6772 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
6773
6774 fn param_spec_builder() -> Self::BuilderFn {
6775 Self::ParamSpec::builder_with_default
6776 }
6777}
6778
6779impl glib::value::ValueType for MessageType {
6780 type Type = Self;
6781}
6782
6783unsafe impl<'a> glib::value::FromValue<'a> for MessageType {
6784 type Checker = glib::value::GenericValueTypeChecker<Self>;
6785
6786 #[inline]
6787 unsafe fn from_value(value: &'a glib::Value) -> Self {
6788 skip_assert_initialized!();
6789 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
6790 }
6791}
6792
6793impl ToValue for MessageType {
6794 #[inline]
6795 fn to_value(&self) -> glib::Value {
6796 let mut value = glib::Value::for_value_type::<Self>();
6797 unsafe {
6798 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
6799 }
6800 value
6801 }
6802
6803 #[inline]
6804 fn value_type(&self) -> glib::Type {
6805 Self::static_type()
6806 }
6807}
6808
6809impl From<MessageType> for glib::Value {
6810 #[inline]
6811 fn from(v: MessageType) -> Self {
6812 skip_assert_initialized!();
6813 ToValue::to_value(&v)
6814 }
6815}
6816
6817#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
6818#[non_exhaustive]
6819#[doc(alias = "GtkMovementStep")]
6820pub enum MovementStep {
6821 #[doc(alias = "GTK_MOVEMENT_LOGICAL_POSITIONS")]
6822 LogicalPositions,
6823 #[doc(alias = "GTK_MOVEMENT_VISUAL_POSITIONS")]
6824 VisualPositions,
6825 #[doc(alias = "GTK_MOVEMENT_WORDS")]
6826 Words,
6827 #[doc(alias = "GTK_MOVEMENT_DISPLAY_LINES")]
6828 DisplayLines,
6829 #[doc(alias = "GTK_MOVEMENT_DISPLAY_LINE_ENDS")]
6830 DisplayLineEnds,
6831 #[doc(alias = "GTK_MOVEMENT_PARAGRAPHS")]
6832 Paragraphs,
6833 #[doc(alias = "GTK_MOVEMENT_PARAGRAPH_ENDS")]
6834 ParagraphEnds,
6835 #[doc(alias = "GTK_MOVEMENT_PAGES")]
6836 Pages,
6837 #[doc(alias = "GTK_MOVEMENT_BUFFER_ENDS")]
6838 BufferEnds,
6839 #[doc(alias = "GTK_MOVEMENT_HORIZONTAL_PAGES")]
6840 HorizontalPages,
6841 #[doc(hidden)]
6842 __Unknown(i32),
6843}
6844
6845#[doc(hidden)]
6846impl IntoGlib for MovementStep {
6847 type GlibType = ffi::GtkMovementStep;
6848
6849 #[inline]
6850 fn into_glib(self) -> ffi::GtkMovementStep {
6851 match self {
6852 Self::LogicalPositions => ffi::GTK_MOVEMENT_LOGICAL_POSITIONS,
6853 Self::VisualPositions => ffi::GTK_MOVEMENT_VISUAL_POSITIONS,
6854 Self::Words => ffi::GTK_MOVEMENT_WORDS,
6855 Self::DisplayLines => ffi::GTK_MOVEMENT_DISPLAY_LINES,
6856 Self::DisplayLineEnds => ffi::GTK_MOVEMENT_DISPLAY_LINE_ENDS,
6857 Self::Paragraphs => ffi::GTK_MOVEMENT_PARAGRAPHS,
6858 Self::ParagraphEnds => ffi::GTK_MOVEMENT_PARAGRAPH_ENDS,
6859 Self::Pages => ffi::GTK_MOVEMENT_PAGES,
6860 Self::BufferEnds => ffi::GTK_MOVEMENT_BUFFER_ENDS,
6861 Self::HorizontalPages => ffi::GTK_MOVEMENT_HORIZONTAL_PAGES,
6862 Self::__Unknown(value) => value,
6863 }
6864 }
6865}
6866
6867#[doc(hidden)]
6868impl FromGlib<ffi::GtkMovementStep> for MovementStep {
6869 #[inline]
6870 unsafe fn from_glib(value: ffi::GtkMovementStep) -> Self {
6871 skip_assert_initialized!();
6872
6873 match value {
6874 ffi::GTK_MOVEMENT_LOGICAL_POSITIONS => Self::LogicalPositions,
6875 ffi::GTK_MOVEMENT_VISUAL_POSITIONS => Self::VisualPositions,
6876 ffi::GTK_MOVEMENT_WORDS => Self::Words,
6877 ffi::GTK_MOVEMENT_DISPLAY_LINES => Self::DisplayLines,
6878 ffi::GTK_MOVEMENT_DISPLAY_LINE_ENDS => Self::DisplayLineEnds,
6879 ffi::GTK_MOVEMENT_PARAGRAPHS => Self::Paragraphs,
6880 ffi::GTK_MOVEMENT_PARAGRAPH_ENDS => Self::ParagraphEnds,
6881 ffi::GTK_MOVEMENT_PAGES => Self::Pages,
6882 ffi::GTK_MOVEMENT_BUFFER_ENDS => Self::BufferEnds,
6883 ffi::GTK_MOVEMENT_HORIZONTAL_PAGES => Self::HorizontalPages,
6884 value => Self::__Unknown(value),
6885 }
6886 }
6887}
6888
6889impl StaticType for MovementStep {
6890 #[inline]
6891 #[doc(alias = "gtk_movement_step_get_type")]
6892 fn static_type() -> glib::Type {
6893 unsafe { from_glib(ffi::gtk_movement_step_get_type()) }
6894 }
6895}
6896
6897impl glib::HasParamSpec for MovementStep {
6898 type ParamSpec = glib::ParamSpecEnum;
6899 type SetValue = Self;
6900 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
6901
6902 fn param_spec_builder() -> Self::BuilderFn {
6903 Self::ParamSpec::builder_with_default
6904 }
6905}
6906
6907impl glib::value::ValueType for MovementStep {
6908 type Type = Self;
6909}
6910
6911unsafe impl<'a> glib::value::FromValue<'a> for MovementStep {
6912 type Checker = glib::value::GenericValueTypeChecker<Self>;
6913
6914 #[inline]
6915 unsafe fn from_value(value: &'a glib::Value) -> Self {
6916 skip_assert_initialized!();
6917 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
6918 }
6919}
6920
6921impl ToValue for MovementStep {
6922 #[inline]
6923 fn to_value(&self) -> glib::Value {
6924 let mut value = glib::Value::for_value_type::<Self>();
6925 unsafe {
6926 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
6927 }
6928 value
6929 }
6930
6931 #[inline]
6932 fn value_type(&self) -> glib::Type {
6933 Self::static_type()
6934 }
6935}
6936
6937impl From<MovementStep> for glib::Value {
6938 #[inline]
6939 fn from(v: MovementStep) -> Self {
6940 skip_assert_initialized!();
6941 ToValue::to_value(&v)
6942 }
6943}
6944
6945#[cfg(feature = "v4_6")]
6946#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
6947#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
6948#[non_exhaustive]
6949#[doc(alias = "GtkNaturalWrapMode")]
6950pub enum NaturalWrapMode {
6951 #[doc(alias = "GTK_NATURAL_WRAP_INHERIT")]
6952 Inherit,
6953 #[doc(alias = "GTK_NATURAL_WRAP_NONE")]
6954 None,
6955 #[doc(alias = "GTK_NATURAL_WRAP_WORD")]
6956 Word,
6957 #[doc(hidden)]
6958 __Unknown(i32),
6959}
6960
6961#[cfg(feature = "v4_6")]
6962#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
6963#[doc(hidden)]
6964impl IntoGlib for NaturalWrapMode {
6965 type GlibType = ffi::GtkNaturalWrapMode;
6966
6967 #[inline]
6968 fn into_glib(self) -> ffi::GtkNaturalWrapMode {
6969 match self {
6970 Self::Inherit => ffi::GTK_NATURAL_WRAP_INHERIT,
6971 Self::None => ffi::GTK_NATURAL_WRAP_NONE,
6972 Self::Word => ffi::GTK_NATURAL_WRAP_WORD,
6973 Self::__Unknown(value) => value,
6974 }
6975 }
6976}
6977
6978#[cfg(feature = "v4_6")]
6979#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
6980#[doc(hidden)]
6981impl FromGlib<ffi::GtkNaturalWrapMode> for NaturalWrapMode {
6982 #[inline]
6983 unsafe fn from_glib(value: ffi::GtkNaturalWrapMode) -> Self {
6984 skip_assert_initialized!();
6985
6986 match value {
6987 ffi::GTK_NATURAL_WRAP_INHERIT => Self::Inherit,
6988 ffi::GTK_NATURAL_WRAP_NONE => Self::None,
6989 ffi::GTK_NATURAL_WRAP_WORD => Self::Word,
6990 value => Self::__Unknown(value),
6991 }
6992 }
6993}
6994
6995#[cfg(feature = "v4_6")]
6996#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
6997impl StaticType for NaturalWrapMode {
6998 #[inline]
6999 #[doc(alias = "gtk_natural_wrap_mode_get_type")]
7000 fn static_type() -> glib::Type {
7001 unsafe { from_glib(ffi::gtk_natural_wrap_mode_get_type()) }
7002 }
7003}
7004
7005#[cfg(feature = "v4_6")]
7006#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
7007impl glib::HasParamSpec for NaturalWrapMode {
7008 type ParamSpec = glib::ParamSpecEnum;
7009 type SetValue = Self;
7010 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
7011
7012 fn param_spec_builder() -> Self::BuilderFn {
7013 Self::ParamSpec::builder_with_default
7014 }
7015}
7016
7017#[cfg(feature = "v4_6")]
7018#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
7019impl glib::value::ValueType for NaturalWrapMode {
7020 type Type = Self;
7021}
7022
7023#[cfg(feature = "v4_6")]
7024#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
7025unsafe impl<'a> glib::value::FromValue<'a> for NaturalWrapMode {
7026 type Checker = glib::value::GenericValueTypeChecker<Self>;
7027
7028 #[inline]
7029 unsafe fn from_value(value: &'a glib::Value) -> Self {
7030 skip_assert_initialized!();
7031 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
7032 }
7033}
7034
7035#[cfg(feature = "v4_6")]
7036#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
7037impl ToValue for NaturalWrapMode {
7038 #[inline]
7039 fn to_value(&self) -> glib::Value {
7040 let mut value = glib::Value::for_value_type::<Self>();
7041 unsafe {
7042 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
7043 }
7044 value
7045 }
7046
7047 #[inline]
7048 fn value_type(&self) -> glib::Type {
7049 Self::static_type()
7050 }
7051}
7052
7053#[cfg(feature = "v4_6")]
7054#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
7055impl From<NaturalWrapMode> for glib::Value {
7056 #[inline]
7057 fn from(v: NaturalWrapMode) -> Self {
7058 skip_assert_initialized!();
7059 ToValue::to_value(&v)
7060 }
7061}
7062
7063#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
7064#[non_exhaustive]
7065#[doc(alias = "GtkNotebookTab")]
7066pub enum NotebookTab {
7067 #[doc(alias = "GTK_NOTEBOOK_TAB_FIRST")]
7068 First,
7069 #[doc(alias = "GTK_NOTEBOOK_TAB_LAST")]
7070 Last,
7071 #[doc(hidden)]
7072 __Unknown(i32),
7073}
7074
7075#[doc(hidden)]
7076impl IntoGlib for NotebookTab {
7077 type GlibType = ffi::GtkNotebookTab;
7078
7079 #[inline]
7080 fn into_glib(self) -> ffi::GtkNotebookTab {
7081 match self {
7082 Self::First => ffi::GTK_NOTEBOOK_TAB_FIRST,
7083 Self::Last => ffi::GTK_NOTEBOOK_TAB_LAST,
7084 Self::__Unknown(value) => value,
7085 }
7086 }
7087}
7088
7089#[doc(hidden)]
7090impl FromGlib<ffi::GtkNotebookTab> for NotebookTab {
7091 #[inline]
7092 unsafe fn from_glib(value: ffi::GtkNotebookTab) -> Self {
7093 skip_assert_initialized!();
7094
7095 match value {
7096 ffi::GTK_NOTEBOOK_TAB_FIRST => Self::First,
7097 ffi::GTK_NOTEBOOK_TAB_LAST => Self::Last,
7098 value => Self::__Unknown(value),
7099 }
7100 }
7101}
7102
7103impl StaticType for NotebookTab {
7104 #[inline]
7105 #[doc(alias = "gtk_notebook_tab_get_type")]
7106 fn static_type() -> glib::Type {
7107 unsafe { from_glib(ffi::gtk_notebook_tab_get_type()) }
7108 }
7109}
7110
7111impl glib::HasParamSpec for NotebookTab {
7112 type ParamSpec = glib::ParamSpecEnum;
7113 type SetValue = Self;
7114 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
7115
7116 fn param_spec_builder() -> Self::BuilderFn {
7117 Self::ParamSpec::builder_with_default
7118 }
7119}
7120
7121impl glib::value::ValueType for NotebookTab {
7122 type Type = Self;
7123}
7124
7125unsafe impl<'a> glib::value::FromValue<'a> for NotebookTab {
7126 type Checker = glib::value::GenericValueTypeChecker<Self>;
7127
7128 #[inline]
7129 unsafe fn from_value(value: &'a glib::Value) -> Self {
7130 skip_assert_initialized!();
7131 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
7132 }
7133}
7134
7135impl ToValue for NotebookTab {
7136 #[inline]
7137 fn to_value(&self) -> glib::Value {
7138 let mut value = glib::Value::for_value_type::<Self>();
7139 unsafe {
7140 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
7141 }
7142 value
7143 }
7144
7145 #[inline]
7146 fn value_type(&self) -> glib::Type {
7147 Self::static_type()
7148 }
7149}
7150
7151impl From<NotebookTab> for glib::Value {
7152 #[inline]
7153 fn from(v: NotebookTab) -> Self {
7154 skip_assert_initialized!();
7155 ToValue::to_value(&v)
7156 }
7157}
7158
7159#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
7160#[non_exhaustive]
7161#[doc(alias = "GtkNumberUpLayout")]
7162pub enum NumberUpLayout {
7163 #[doc(alias = "GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_TOP_TO_BOTTOM")]
7164 Lrtb,
7165 #[doc(alias = "GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_BOTTOM_TO_TOP")]
7166 Lrbt,
7167 #[doc(alias = "GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_TOP_TO_BOTTOM")]
7168 Rltb,
7169 #[doc(alias = "GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_BOTTOM_TO_TOP")]
7170 Rlbt,
7171 #[doc(alias = "GTK_NUMBER_UP_LAYOUT_TOP_TO_BOTTOM_LEFT_TO_RIGHT")]
7172 Tblr,
7173 #[doc(alias = "GTK_NUMBER_UP_LAYOUT_TOP_TO_BOTTOM_RIGHT_TO_LEFT")]
7174 Tbrl,
7175 #[doc(alias = "GTK_NUMBER_UP_LAYOUT_BOTTOM_TO_TOP_LEFT_TO_RIGHT")]
7176 Btlr,
7177 #[doc(alias = "GTK_NUMBER_UP_LAYOUT_BOTTOM_TO_TOP_RIGHT_TO_LEFT")]
7178 Btrl,
7179 #[doc(hidden)]
7180 __Unknown(i32),
7181}
7182
7183#[doc(hidden)]
7184impl IntoGlib for NumberUpLayout {
7185 type GlibType = ffi::GtkNumberUpLayout;
7186
7187 #[inline]
7188 fn into_glib(self) -> ffi::GtkNumberUpLayout {
7189 match self {
7190 Self::Lrtb => ffi::GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_TOP_TO_BOTTOM,
7191 Self::Lrbt => ffi::GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_BOTTOM_TO_TOP,
7192 Self::Rltb => ffi::GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_TOP_TO_BOTTOM,
7193 Self::Rlbt => ffi::GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_BOTTOM_TO_TOP,
7194 Self::Tblr => ffi::GTK_NUMBER_UP_LAYOUT_TOP_TO_BOTTOM_LEFT_TO_RIGHT,
7195 Self::Tbrl => ffi::GTK_NUMBER_UP_LAYOUT_TOP_TO_BOTTOM_RIGHT_TO_LEFT,
7196 Self::Btlr => ffi::GTK_NUMBER_UP_LAYOUT_BOTTOM_TO_TOP_LEFT_TO_RIGHT,
7197 Self::Btrl => ffi::GTK_NUMBER_UP_LAYOUT_BOTTOM_TO_TOP_RIGHT_TO_LEFT,
7198 Self::__Unknown(value) => value,
7199 }
7200 }
7201}
7202
7203#[doc(hidden)]
7204impl FromGlib<ffi::GtkNumberUpLayout> for NumberUpLayout {
7205 #[inline]
7206 unsafe fn from_glib(value: ffi::GtkNumberUpLayout) -> Self {
7207 skip_assert_initialized!();
7208
7209 match value {
7210 ffi::GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_TOP_TO_BOTTOM => Self::Lrtb,
7211 ffi::GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_BOTTOM_TO_TOP => Self::Lrbt,
7212 ffi::GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_TOP_TO_BOTTOM => Self::Rltb,
7213 ffi::GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_BOTTOM_TO_TOP => Self::Rlbt,
7214 ffi::GTK_NUMBER_UP_LAYOUT_TOP_TO_BOTTOM_LEFT_TO_RIGHT => Self::Tblr,
7215 ffi::GTK_NUMBER_UP_LAYOUT_TOP_TO_BOTTOM_RIGHT_TO_LEFT => Self::Tbrl,
7216 ffi::GTK_NUMBER_UP_LAYOUT_BOTTOM_TO_TOP_LEFT_TO_RIGHT => Self::Btlr,
7217 ffi::GTK_NUMBER_UP_LAYOUT_BOTTOM_TO_TOP_RIGHT_TO_LEFT => Self::Btrl,
7218 value => Self::__Unknown(value),
7219 }
7220 }
7221}
7222
7223impl StaticType for NumberUpLayout {
7224 #[inline]
7225 #[doc(alias = "gtk_number_up_layout_get_type")]
7226 fn static_type() -> glib::Type {
7227 unsafe { from_glib(ffi::gtk_number_up_layout_get_type()) }
7228 }
7229}
7230
7231impl glib::HasParamSpec for NumberUpLayout {
7232 type ParamSpec = glib::ParamSpecEnum;
7233 type SetValue = Self;
7234 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
7235
7236 fn param_spec_builder() -> Self::BuilderFn {
7237 Self::ParamSpec::builder_with_default
7238 }
7239}
7240
7241impl glib::value::ValueType for NumberUpLayout {
7242 type Type = Self;
7243}
7244
7245unsafe impl<'a> glib::value::FromValue<'a> for NumberUpLayout {
7246 type Checker = glib::value::GenericValueTypeChecker<Self>;
7247
7248 #[inline]
7249 unsafe fn from_value(value: &'a glib::Value) -> Self {
7250 skip_assert_initialized!();
7251 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
7252 }
7253}
7254
7255impl ToValue for NumberUpLayout {
7256 #[inline]
7257 fn to_value(&self) -> glib::Value {
7258 let mut value = glib::Value::for_value_type::<Self>();
7259 unsafe {
7260 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
7261 }
7262 value
7263 }
7264
7265 #[inline]
7266 fn value_type(&self) -> glib::Type {
7267 Self::static_type()
7268 }
7269}
7270
7271impl From<NumberUpLayout> for glib::Value {
7272 #[inline]
7273 fn from(v: NumberUpLayout) -> Self {
7274 skip_assert_initialized!();
7275 ToValue::to_value(&v)
7276 }
7277}
7278
7279#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
7280#[non_exhaustive]
7281#[doc(alias = "GtkOrdering")]
7282pub enum Ordering {
7283 #[doc(alias = "GTK_ORDERING_SMALLER")]
7284 Smaller,
7285 #[doc(alias = "GTK_ORDERING_EQUAL")]
7286 Equal,
7287 #[doc(alias = "GTK_ORDERING_LARGER")]
7288 Larger,
7289 #[doc(hidden)]
7290 __Unknown(i32),
7291}
7292
7293#[doc(hidden)]
7294impl IntoGlib for Ordering {
7295 type GlibType = ffi::GtkOrdering;
7296
7297 #[inline]
7298 fn into_glib(self) -> ffi::GtkOrdering {
7299 match self {
7300 Self::Smaller => ffi::GTK_ORDERING_SMALLER,
7301 Self::Equal => ffi::GTK_ORDERING_EQUAL,
7302 Self::Larger => ffi::GTK_ORDERING_LARGER,
7303 Self::__Unknown(value) => value,
7304 }
7305 }
7306}
7307
7308#[doc(hidden)]
7309impl FromGlib<ffi::GtkOrdering> for Ordering {
7310 #[inline]
7311 unsafe fn from_glib(value: ffi::GtkOrdering) -> Self {
7312 skip_assert_initialized!();
7313
7314 match value {
7315 ffi::GTK_ORDERING_SMALLER => Self::Smaller,
7316 ffi::GTK_ORDERING_EQUAL => Self::Equal,
7317 ffi::GTK_ORDERING_LARGER => Self::Larger,
7318 value => Self::__Unknown(value),
7319 }
7320 }
7321}
7322
7323impl StaticType for Ordering {
7324 #[inline]
7325 #[doc(alias = "gtk_ordering_get_type")]
7326 fn static_type() -> glib::Type {
7327 unsafe { from_glib(ffi::gtk_ordering_get_type()) }
7328 }
7329}
7330
7331impl glib::HasParamSpec for Ordering {
7332 type ParamSpec = glib::ParamSpecEnum;
7333 type SetValue = Self;
7334 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
7335
7336 fn param_spec_builder() -> Self::BuilderFn {
7337 Self::ParamSpec::builder_with_default
7338 }
7339}
7340
7341impl glib::value::ValueType for Ordering {
7342 type Type = Self;
7343}
7344
7345unsafe impl<'a> glib::value::FromValue<'a> for Ordering {
7346 type Checker = glib::value::GenericValueTypeChecker<Self>;
7347
7348 #[inline]
7349 unsafe fn from_value(value: &'a glib::Value) -> Self {
7350 skip_assert_initialized!();
7351 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
7352 }
7353}
7354
7355impl ToValue for Ordering {
7356 #[inline]
7357 fn to_value(&self) -> glib::Value {
7358 let mut value = glib::Value::for_value_type::<Self>();
7359 unsafe {
7360 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
7361 }
7362 value
7363 }
7364
7365 #[inline]
7366 fn value_type(&self) -> glib::Type {
7367 Self::static_type()
7368 }
7369}
7370
7371impl From<Ordering> for glib::Value {
7372 #[inline]
7373 fn from(v: Ordering) -> Self {
7374 skip_assert_initialized!();
7375 ToValue::to_value(&v)
7376 }
7377}
7378
7379#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
7380#[non_exhaustive]
7381#[doc(alias = "GtkOrientation")]
7382pub enum Orientation {
7383 #[doc(alias = "GTK_ORIENTATION_HORIZONTAL")]
7384 Horizontal,
7385 #[doc(alias = "GTK_ORIENTATION_VERTICAL")]
7386 Vertical,
7387 #[doc(hidden)]
7388 __Unknown(i32),
7389}
7390
7391#[doc(hidden)]
7392impl IntoGlib for Orientation {
7393 type GlibType = ffi::GtkOrientation;
7394
7395 #[inline]
7396 fn into_glib(self) -> ffi::GtkOrientation {
7397 match self {
7398 Self::Horizontal => ffi::GTK_ORIENTATION_HORIZONTAL,
7399 Self::Vertical => ffi::GTK_ORIENTATION_VERTICAL,
7400 Self::__Unknown(value) => value,
7401 }
7402 }
7403}
7404
7405#[doc(hidden)]
7406impl FromGlib<ffi::GtkOrientation> for Orientation {
7407 #[inline]
7408 unsafe fn from_glib(value: ffi::GtkOrientation) -> Self {
7409 skip_assert_initialized!();
7410
7411 match value {
7412 ffi::GTK_ORIENTATION_HORIZONTAL => Self::Horizontal,
7413 ffi::GTK_ORIENTATION_VERTICAL => Self::Vertical,
7414 value => Self::__Unknown(value),
7415 }
7416 }
7417}
7418
7419impl StaticType for Orientation {
7420 #[inline]
7421 #[doc(alias = "gtk_orientation_get_type")]
7422 fn static_type() -> glib::Type {
7423 unsafe { from_glib(ffi::gtk_orientation_get_type()) }
7424 }
7425}
7426
7427impl glib::HasParamSpec for Orientation {
7428 type ParamSpec = glib::ParamSpecEnum;
7429 type SetValue = Self;
7430 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
7431
7432 fn param_spec_builder() -> Self::BuilderFn {
7433 Self::ParamSpec::builder_with_default
7434 }
7435}
7436
7437impl glib::value::ValueType for Orientation {
7438 type Type = Self;
7439}
7440
7441unsafe impl<'a> glib::value::FromValue<'a> for Orientation {
7442 type Checker = glib::value::GenericValueTypeChecker<Self>;
7443
7444 #[inline]
7445 unsafe fn from_value(value: &'a glib::Value) -> Self {
7446 skip_assert_initialized!();
7447 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
7448 }
7449}
7450
7451impl ToValue for Orientation {
7452 #[inline]
7453 fn to_value(&self) -> glib::Value {
7454 let mut value = glib::Value::for_value_type::<Self>();
7455 unsafe {
7456 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
7457 }
7458 value
7459 }
7460
7461 #[inline]
7462 fn value_type(&self) -> glib::Type {
7463 Self::static_type()
7464 }
7465}
7466
7467impl From<Orientation> for glib::Value {
7468 #[inline]
7469 fn from(v: Orientation) -> Self {
7470 skip_assert_initialized!();
7471 ToValue::to_value(&v)
7472 }
7473}
7474
7475#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
7476#[non_exhaustive]
7477#[doc(alias = "GtkOverflow")]
7478pub enum Overflow {
7479 #[doc(alias = "GTK_OVERFLOW_VISIBLE")]
7480 Visible,
7481 #[doc(alias = "GTK_OVERFLOW_HIDDEN")]
7482 Hidden,
7483 #[doc(hidden)]
7484 __Unknown(i32),
7485}
7486
7487#[doc(hidden)]
7488impl IntoGlib for Overflow {
7489 type GlibType = ffi::GtkOverflow;
7490
7491 #[inline]
7492 fn into_glib(self) -> ffi::GtkOverflow {
7493 match self {
7494 Self::Visible => ffi::GTK_OVERFLOW_VISIBLE,
7495 Self::Hidden => ffi::GTK_OVERFLOW_HIDDEN,
7496 Self::__Unknown(value) => value,
7497 }
7498 }
7499}
7500
7501#[doc(hidden)]
7502impl FromGlib<ffi::GtkOverflow> for Overflow {
7503 #[inline]
7504 unsafe fn from_glib(value: ffi::GtkOverflow) -> Self {
7505 skip_assert_initialized!();
7506
7507 match value {
7508 ffi::GTK_OVERFLOW_VISIBLE => Self::Visible,
7509 ffi::GTK_OVERFLOW_HIDDEN => Self::Hidden,
7510 value => Self::__Unknown(value),
7511 }
7512 }
7513}
7514
7515impl StaticType for Overflow {
7516 #[inline]
7517 #[doc(alias = "gtk_overflow_get_type")]
7518 fn static_type() -> glib::Type {
7519 unsafe { from_glib(ffi::gtk_overflow_get_type()) }
7520 }
7521}
7522
7523impl glib::HasParamSpec for Overflow {
7524 type ParamSpec = glib::ParamSpecEnum;
7525 type SetValue = Self;
7526 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
7527
7528 fn param_spec_builder() -> Self::BuilderFn {
7529 Self::ParamSpec::builder_with_default
7530 }
7531}
7532
7533impl glib::value::ValueType for Overflow {
7534 type Type = Self;
7535}
7536
7537unsafe impl<'a> glib::value::FromValue<'a> for Overflow {
7538 type Checker = glib::value::GenericValueTypeChecker<Self>;
7539
7540 #[inline]
7541 unsafe fn from_value(value: &'a glib::Value) -> Self {
7542 skip_assert_initialized!();
7543 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
7544 }
7545}
7546
7547impl ToValue for Overflow {
7548 #[inline]
7549 fn to_value(&self) -> glib::Value {
7550 let mut value = glib::Value::for_value_type::<Self>();
7551 unsafe {
7552 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
7553 }
7554 value
7555 }
7556
7557 #[inline]
7558 fn value_type(&self) -> glib::Type {
7559 Self::static_type()
7560 }
7561}
7562
7563impl From<Overflow> for glib::Value {
7564 #[inline]
7565 fn from(v: Overflow) -> Self {
7566 skip_assert_initialized!();
7567 ToValue::to_value(&v)
7568 }
7569}
7570
7571#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
7572#[non_exhaustive]
7573#[doc(alias = "GtkPackType")]
7574pub enum PackType {
7575 #[doc(alias = "GTK_PACK_START")]
7576 Start,
7577 #[doc(alias = "GTK_PACK_END")]
7578 End,
7579 #[doc(hidden)]
7580 __Unknown(i32),
7581}
7582
7583#[doc(hidden)]
7584impl IntoGlib for PackType {
7585 type GlibType = ffi::GtkPackType;
7586
7587 #[inline]
7588 fn into_glib(self) -> ffi::GtkPackType {
7589 match self {
7590 Self::Start => ffi::GTK_PACK_START,
7591 Self::End => ffi::GTK_PACK_END,
7592 Self::__Unknown(value) => value,
7593 }
7594 }
7595}
7596
7597#[doc(hidden)]
7598impl FromGlib<ffi::GtkPackType> for PackType {
7599 #[inline]
7600 unsafe fn from_glib(value: ffi::GtkPackType) -> Self {
7601 skip_assert_initialized!();
7602
7603 match value {
7604 ffi::GTK_PACK_START => Self::Start,
7605 ffi::GTK_PACK_END => Self::End,
7606 value => Self::__Unknown(value),
7607 }
7608 }
7609}
7610
7611impl StaticType for PackType {
7612 #[inline]
7613 #[doc(alias = "gtk_pack_type_get_type")]
7614 fn static_type() -> glib::Type {
7615 unsafe { from_glib(ffi::gtk_pack_type_get_type()) }
7616 }
7617}
7618
7619impl glib::HasParamSpec for PackType {
7620 type ParamSpec = glib::ParamSpecEnum;
7621 type SetValue = Self;
7622 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
7623
7624 fn param_spec_builder() -> Self::BuilderFn {
7625 Self::ParamSpec::builder_with_default
7626 }
7627}
7628
7629impl glib::value::ValueType for PackType {
7630 type Type = Self;
7631}
7632
7633unsafe impl<'a> glib::value::FromValue<'a> for PackType {
7634 type Checker = glib::value::GenericValueTypeChecker<Self>;
7635
7636 #[inline]
7637 unsafe fn from_value(value: &'a glib::Value) -> Self {
7638 skip_assert_initialized!();
7639 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
7640 }
7641}
7642
7643impl ToValue for PackType {
7644 #[inline]
7645 fn to_value(&self) -> glib::Value {
7646 let mut value = glib::Value::for_value_type::<Self>();
7647 unsafe {
7648 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
7649 }
7650 value
7651 }
7652
7653 #[inline]
7654 fn value_type(&self) -> glib::Type {
7655 Self::static_type()
7656 }
7657}
7658
7659impl From<PackType> for glib::Value {
7660 #[inline]
7661 fn from(v: PackType) -> Self {
7662 skip_assert_initialized!();
7663 ToValue::to_value(&v)
7664 }
7665}
7666
7667#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
7668#[non_exhaustive]
7669#[doc(alias = "GtkPadActionType")]
7670pub enum PadActionType {
7671 #[doc(alias = "GTK_PAD_ACTION_BUTTON")]
7672 Button,
7673 #[doc(alias = "GTK_PAD_ACTION_RING")]
7674 Ring,
7675 #[doc(alias = "GTK_PAD_ACTION_STRIP")]
7676 Strip,
7677 #[doc(alias = "GTK_PAD_ACTION_DIAL")]
7678 Dial,
7679 #[doc(hidden)]
7680 __Unknown(i32),
7681}
7682
7683#[doc(hidden)]
7684impl IntoGlib for PadActionType {
7685 type GlibType = ffi::GtkPadActionType;
7686
7687 #[inline]
7688 fn into_glib(self) -> ffi::GtkPadActionType {
7689 match self {
7690 Self::Button => ffi::GTK_PAD_ACTION_BUTTON,
7691 Self::Ring => ffi::GTK_PAD_ACTION_RING,
7692 Self::Strip => ffi::GTK_PAD_ACTION_STRIP,
7693 Self::Dial => ffi::GTK_PAD_ACTION_DIAL,
7694 Self::__Unknown(value) => value,
7695 }
7696 }
7697}
7698
7699#[doc(hidden)]
7700impl FromGlib<ffi::GtkPadActionType> for PadActionType {
7701 #[inline]
7702 unsafe fn from_glib(value: ffi::GtkPadActionType) -> Self {
7703 skip_assert_initialized!();
7704
7705 match value {
7706 ffi::GTK_PAD_ACTION_BUTTON => Self::Button,
7707 ffi::GTK_PAD_ACTION_RING => Self::Ring,
7708 ffi::GTK_PAD_ACTION_STRIP => Self::Strip,
7709 ffi::GTK_PAD_ACTION_DIAL => Self::Dial,
7710 value => Self::__Unknown(value),
7711 }
7712 }
7713}
7714
7715impl StaticType for PadActionType {
7716 #[inline]
7717 #[doc(alias = "gtk_pad_action_type_get_type")]
7718 fn static_type() -> glib::Type {
7719 unsafe { from_glib(ffi::gtk_pad_action_type_get_type()) }
7720 }
7721}
7722
7723impl glib::HasParamSpec for PadActionType {
7724 type ParamSpec = glib::ParamSpecEnum;
7725 type SetValue = Self;
7726 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
7727
7728 fn param_spec_builder() -> Self::BuilderFn {
7729 Self::ParamSpec::builder_with_default
7730 }
7731}
7732
7733impl glib::value::ValueType for PadActionType {
7734 type Type = Self;
7735}
7736
7737unsafe impl<'a> glib::value::FromValue<'a> for PadActionType {
7738 type Checker = glib::value::GenericValueTypeChecker<Self>;
7739
7740 #[inline]
7741 unsafe fn from_value(value: &'a glib::Value) -> Self {
7742 skip_assert_initialized!();
7743 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
7744 }
7745}
7746
7747impl ToValue for PadActionType {
7748 #[inline]
7749 fn to_value(&self) -> glib::Value {
7750 let mut value = glib::Value::for_value_type::<Self>();
7751 unsafe {
7752 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
7753 }
7754 value
7755 }
7756
7757 #[inline]
7758 fn value_type(&self) -> glib::Type {
7759 Self::static_type()
7760 }
7761}
7762
7763impl From<PadActionType> for glib::Value {
7764 #[inline]
7765 fn from(v: PadActionType) -> Self {
7766 skip_assert_initialized!();
7767 ToValue::to_value(&v)
7768 }
7769}
7770
7771#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
7772#[non_exhaustive]
7773#[doc(alias = "GtkPageOrientation")]
7774pub enum PageOrientation {
7775 #[doc(alias = "GTK_PAGE_ORIENTATION_PORTRAIT")]
7776 Portrait,
7777 #[doc(alias = "GTK_PAGE_ORIENTATION_LANDSCAPE")]
7778 Landscape,
7779 #[doc(alias = "GTK_PAGE_ORIENTATION_REVERSE_PORTRAIT")]
7780 ReversePortrait,
7781 #[doc(alias = "GTK_PAGE_ORIENTATION_REVERSE_LANDSCAPE")]
7782 ReverseLandscape,
7783 #[doc(hidden)]
7784 __Unknown(i32),
7785}
7786
7787#[doc(hidden)]
7788impl IntoGlib for PageOrientation {
7789 type GlibType = ffi::GtkPageOrientation;
7790
7791 #[inline]
7792 fn into_glib(self) -> ffi::GtkPageOrientation {
7793 match self {
7794 Self::Portrait => ffi::GTK_PAGE_ORIENTATION_PORTRAIT,
7795 Self::Landscape => ffi::GTK_PAGE_ORIENTATION_LANDSCAPE,
7796 Self::ReversePortrait => ffi::GTK_PAGE_ORIENTATION_REVERSE_PORTRAIT,
7797 Self::ReverseLandscape => ffi::GTK_PAGE_ORIENTATION_REVERSE_LANDSCAPE,
7798 Self::__Unknown(value) => value,
7799 }
7800 }
7801}
7802
7803#[doc(hidden)]
7804impl FromGlib<ffi::GtkPageOrientation> for PageOrientation {
7805 #[inline]
7806 unsafe fn from_glib(value: ffi::GtkPageOrientation) -> Self {
7807 skip_assert_initialized!();
7808
7809 match value {
7810 ffi::GTK_PAGE_ORIENTATION_PORTRAIT => Self::Portrait,
7811 ffi::GTK_PAGE_ORIENTATION_LANDSCAPE => Self::Landscape,
7812 ffi::GTK_PAGE_ORIENTATION_REVERSE_PORTRAIT => Self::ReversePortrait,
7813 ffi::GTK_PAGE_ORIENTATION_REVERSE_LANDSCAPE => Self::ReverseLandscape,
7814 value => Self::__Unknown(value),
7815 }
7816 }
7817}
7818
7819impl StaticType for PageOrientation {
7820 #[inline]
7821 #[doc(alias = "gtk_page_orientation_get_type")]
7822 fn static_type() -> glib::Type {
7823 unsafe { from_glib(ffi::gtk_page_orientation_get_type()) }
7824 }
7825}
7826
7827impl glib::HasParamSpec for PageOrientation {
7828 type ParamSpec = glib::ParamSpecEnum;
7829 type SetValue = Self;
7830 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
7831
7832 fn param_spec_builder() -> Self::BuilderFn {
7833 Self::ParamSpec::builder_with_default
7834 }
7835}
7836
7837impl glib::value::ValueType for PageOrientation {
7838 type Type = Self;
7839}
7840
7841unsafe impl<'a> glib::value::FromValue<'a> for PageOrientation {
7842 type Checker = glib::value::GenericValueTypeChecker<Self>;
7843
7844 #[inline]
7845 unsafe fn from_value(value: &'a glib::Value) -> Self {
7846 skip_assert_initialized!();
7847 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
7848 }
7849}
7850
7851impl ToValue for PageOrientation {
7852 #[inline]
7853 fn to_value(&self) -> glib::Value {
7854 let mut value = glib::Value::for_value_type::<Self>();
7855 unsafe {
7856 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
7857 }
7858 value
7859 }
7860
7861 #[inline]
7862 fn value_type(&self) -> glib::Type {
7863 Self::static_type()
7864 }
7865}
7866
7867impl From<PageOrientation> for glib::Value {
7868 #[inline]
7869 fn from(v: PageOrientation) -> Self {
7870 skip_assert_initialized!();
7871 ToValue::to_value(&v)
7872 }
7873}
7874
7875#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
7876#[non_exhaustive]
7877#[doc(alias = "GtkPageSet")]
7878pub enum PageSet {
7879 #[doc(alias = "GTK_PAGE_SET_ALL")]
7880 All,
7881 #[doc(alias = "GTK_PAGE_SET_EVEN")]
7882 Even,
7883 #[doc(alias = "GTK_PAGE_SET_ODD")]
7884 Odd,
7885 #[doc(hidden)]
7886 __Unknown(i32),
7887}
7888
7889#[doc(hidden)]
7890impl IntoGlib for PageSet {
7891 type GlibType = ffi::GtkPageSet;
7892
7893 #[inline]
7894 fn into_glib(self) -> ffi::GtkPageSet {
7895 match self {
7896 Self::All => ffi::GTK_PAGE_SET_ALL,
7897 Self::Even => ffi::GTK_PAGE_SET_EVEN,
7898 Self::Odd => ffi::GTK_PAGE_SET_ODD,
7899 Self::__Unknown(value) => value,
7900 }
7901 }
7902}
7903
7904#[doc(hidden)]
7905impl FromGlib<ffi::GtkPageSet> for PageSet {
7906 #[inline]
7907 unsafe fn from_glib(value: ffi::GtkPageSet) -> Self {
7908 skip_assert_initialized!();
7909
7910 match value {
7911 ffi::GTK_PAGE_SET_ALL => Self::All,
7912 ffi::GTK_PAGE_SET_EVEN => Self::Even,
7913 ffi::GTK_PAGE_SET_ODD => Self::Odd,
7914 value => Self::__Unknown(value),
7915 }
7916 }
7917}
7918
7919impl StaticType for PageSet {
7920 #[inline]
7921 #[doc(alias = "gtk_page_set_get_type")]
7922 fn static_type() -> glib::Type {
7923 unsafe { from_glib(ffi::gtk_page_set_get_type()) }
7924 }
7925}
7926
7927impl glib::HasParamSpec for PageSet {
7928 type ParamSpec = glib::ParamSpecEnum;
7929 type SetValue = Self;
7930 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
7931
7932 fn param_spec_builder() -> Self::BuilderFn {
7933 Self::ParamSpec::builder_with_default
7934 }
7935}
7936
7937impl glib::value::ValueType for PageSet {
7938 type Type = Self;
7939}
7940
7941unsafe impl<'a> glib::value::FromValue<'a> for PageSet {
7942 type Checker = glib::value::GenericValueTypeChecker<Self>;
7943
7944 #[inline]
7945 unsafe fn from_value(value: &'a glib::Value) -> Self {
7946 skip_assert_initialized!();
7947 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
7948 }
7949}
7950
7951impl ToValue for PageSet {
7952 #[inline]
7953 fn to_value(&self) -> glib::Value {
7954 let mut value = glib::Value::for_value_type::<Self>();
7955 unsafe {
7956 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
7957 }
7958 value
7959 }
7960
7961 #[inline]
7962 fn value_type(&self) -> glib::Type {
7963 Self::static_type()
7964 }
7965}
7966
7967impl From<PageSet> for glib::Value {
7968 #[inline]
7969 fn from(v: PageSet) -> Self {
7970 skip_assert_initialized!();
7971 ToValue::to_value(&v)
7972 }
7973}
7974
7975#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
7976#[non_exhaustive]
7977#[doc(alias = "GtkPanDirection")]
7978pub enum PanDirection {
7979 #[doc(alias = "GTK_PAN_DIRECTION_LEFT")]
7980 Left,
7981 #[doc(alias = "GTK_PAN_DIRECTION_RIGHT")]
7982 Right,
7983 #[doc(alias = "GTK_PAN_DIRECTION_UP")]
7984 Up,
7985 #[doc(alias = "GTK_PAN_DIRECTION_DOWN")]
7986 Down,
7987 #[doc(hidden)]
7988 __Unknown(i32),
7989}
7990
7991#[doc(hidden)]
7992impl IntoGlib for PanDirection {
7993 type GlibType = ffi::GtkPanDirection;
7994
7995 #[inline]
7996 fn into_glib(self) -> ffi::GtkPanDirection {
7997 match self {
7998 Self::Left => ffi::GTK_PAN_DIRECTION_LEFT,
7999 Self::Right => ffi::GTK_PAN_DIRECTION_RIGHT,
8000 Self::Up => ffi::GTK_PAN_DIRECTION_UP,
8001 Self::Down => ffi::GTK_PAN_DIRECTION_DOWN,
8002 Self::__Unknown(value) => value,
8003 }
8004 }
8005}
8006
8007#[doc(hidden)]
8008impl FromGlib<ffi::GtkPanDirection> for PanDirection {
8009 #[inline]
8010 unsafe fn from_glib(value: ffi::GtkPanDirection) -> Self {
8011 skip_assert_initialized!();
8012
8013 match value {
8014 ffi::GTK_PAN_DIRECTION_LEFT => Self::Left,
8015 ffi::GTK_PAN_DIRECTION_RIGHT => Self::Right,
8016 ffi::GTK_PAN_DIRECTION_UP => Self::Up,
8017 ffi::GTK_PAN_DIRECTION_DOWN => Self::Down,
8018 value => Self::__Unknown(value),
8019 }
8020 }
8021}
8022
8023impl StaticType for PanDirection {
8024 #[inline]
8025 #[doc(alias = "gtk_pan_direction_get_type")]
8026 fn static_type() -> glib::Type {
8027 unsafe { from_glib(ffi::gtk_pan_direction_get_type()) }
8028 }
8029}
8030
8031impl glib::HasParamSpec for PanDirection {
8032 type ParamSpec = glib::ParamSpecEnum;
8033 type SetValue = Self;
8034 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
8035
8036 fn param_spec_builder() -> Self::BuilderFn {
8037 Self::ParamSpec::builder_with_default
8038 }
8039}
8040
8041impl glib::value::ValueType for PanDirection {
8042 type Type = Self;
8043}
8044
8045unsafe impl<'a> glib::value::FromValue<'a> for PanDirection {
8046 type Checker = glib::value::GenericValueTypeChecker<Self>;
8047
8048 #[inline]
8049 unsafe fn from_value(value: &'a glib::Value) -> Self {
8050 skip_assert_initialized!();
8051 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
8052 }
8053}
8054
8055impl ToValue for PanDirection {
8056 #[inline]
8057 fn to_value(&self) -> glib::Value {
8058 let mut value = glib::Value::for_value_type::<Self>();
8059 unsafe {
8060 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
8061 }
8062 value
8063 }
8064
8065 #[inline]
8066 fn value_type(&self) -> glib::Type {
8067 Self::static_type()
8068 }
8069}
8070
8071impl From<PanDirection> for glib::Value {
8072 #[inline]
8073 fn from(v: PanDirection) -> Self {
8074 skip_assert_initialized!();
8075 ToValue::to_value(&v)
8076 }
8077}
8078
8079#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
8080#[non_exhaustive]
8081#[doc(alias = "GtkPolicyType")]
8082pub enum PolicyType {
8083 #[doc(alias = "GTK_POLICY_ALWAYS")]
8084 Always,
8085 #[doc(alias = "GTK_POLICY_AUTOMATIC")]
8086 Automatic,
8087 #[doc(alias = "GTK_POLICY_NEVER")]
8088 Never,
8089 #[doc(alias = "GTK_POLICY_EXTERNAL")]
8090 External,
8091 #[doc(hidden)]
8092 __Unknown(i32),
8093}
8094
8095#[doc(hidden)]
8096impl IntoGlib for PolicyType {
8097 type GlibType = ffi::GtkPolicyType;
8098
8099 #[inline]
8100 fn into_glib(self) -> ffi::GtkPolicyType {
8101 match self {
8102 Self::Always => ffi::GTK_POLICY_ALWAYS,
8103 Self::Automatic => ffi::GTK_POLICY_AUTOMATIC,
8104 Self::Never => ffi::GTK_POLICY_NEVER,
8105 Self::External => ffi::GTK_POLICY_EXTERNAL,
8106 Self::__Unknown(value) => value,
8107 }
8108 }
8109}
8110
8111#[doc(hidden)]
8112impl FromGlib<ffi::GtkPolicyType> for PolicyType {
8113 #[inline]
8114 unsafe fn from_glib(value: ffi::GtkPolicyType) -> Self {
8115 skip_assert_initialized!();
8116
8117 match value {
8118 ffi::GTK_POLICY_ALWAYS => Self::Always,
8119 ffi::GTK_POLICY_AUTOMATIC => Self::Automatic,
8120 ffi::GTK_POLICY_NEVER => Self::Never,
8121 ffi::GTK_POLICY_EXTERNAL => Self::External,
8122 value => Self::__Unknown(value),
8123 }
8124 }
8125}
8126
8127impl StaticType for PolicyType {
8128 #[inline]
8129 #[doc(alias = "gtk_policy_type_get_type")]
8130 fn static_type() -> glib::Type {
8131 unsafe { from_glib(ffi::gtk_policy_type_get_type()) }
8132 }
8133}
8134
8135impl glib::HasParamSpec for PolicyType {
8136 type ParamSpec = glib::ParamSpecEnum;
8137 type SetValue = Self;
8138 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
8139
8140 fn param_spec_builder() -> Self::BuilderFn {
8141 Self::ParamSpec::builder_with_default
8142 }
8143}
8144
8145impl glib::value::ValueType for PolicyType {
8146 type Type = Self;
8147}
8148
8149unsafe impl<'a> glib::value::FromValue<'a> for PolicyType {
8150 type Checker = glib::value::GenericValueTypeChecker<Self>;
8151
8152 #[inline]
8153 unsafe fn from_value(value: &'a glib::Value) -> Self {
8154 skip_assert_initialized!();
8155 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
8156 }
8157}
8158
8159impl ToValue for PolicyType {
8160 #[inline]
8161 fn to_value(&self) -> glib::Value {
8162 let mut value = glib::Value::for_value_type::<Self>();
8163 unsafe {
8164 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
8165 }
8166 value
8167 }
8168
8169 #[inline]
8170 fn value_type(&self) -> glib::Type {
8171 Self::static_type()
8172 }
8173}
8174
8175impl From<PolicyType> for glib::Value {
8176 #[inline]
8177 fn from(v: PolicyType) -> Self {
8178 skip_assert_initialized!();
8179 ToValue::to_value(&v)
8180 }
8181}
8182
8183#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
8184#[non_exhaustive]
8185#[doc(alias = "GtkPositionType")]
8186pub enum PositionType {
8187 #[doc(alias = "GTK_POS_LEFT")]
8188 Left,
8189 #[doc(alias = "GTK_POS_RIGHT")]
8190 Right,
8191 #[doc(alias = "GTK_POS_TOP")]
8192 Top,
8193 #[doc(alias = "GTK_POS_BOTTOM")]
8194 Bottom,
8195 #[doc(hidden)]
8196 __Unknown(i32),
8197}
8198
8199#[doc(hidden)]
8200impl IntoGlib for PositionType {
8201 type GlibType = ffi::GtkPositionType;
8202
8203 #[inline]
8204 fn into_glib(self) -> ffi::GtkPositionType {
8205 match self {
8206 Self::Left => ffi::GTK_POS_LEFT,
8207 Self::Right => ffi::GTK_POS_RIGHT,
8208 Self::Top => ffi::GTK_POS_TOP,
8209 Self::Bottom => ffi::GTK_POS_BOTTOM,
8210 Self::__Unknown(value) => value,
8211 }
8212 }
8213}
8214
8215#[doc(hidden)]
8216impl FromGlib<ffi::GtkPositionType> for PositionType {
8217 #[inline]
8218 unsafe fn from_glib(value: ffi::GtkPositionType) -> Self {
8219 skip_assert_initialized!();
8220
8221 match value {
8222 ffi::GTK_POS_LEFT => Self::Left,
8223 ffi::GTK_POS_RIGHT => Self::Right,
8224 ffi::GTK_POS_TOP => Self::Top,
8225 ffi::GTK_POS_BOTTOM => Self::Bottom,
8226 value => Self::__Unknown(value),
8227 }
8228 }
8229}
8230
8231impl StaticType for PositionType {
8232 #[inline]
8233 #[doc(alias = "gtk_position_type_get_type")]
8234 fn static_type() -> glib::Type {
8235 unsafe { from_glib(ffi::gtk_position_type_get_type()) }
8236 }
8237}
8238
8239impl glib::HasParamSpec for PositionType {
8240 type ParamSpec = glib::ParamSpecEnum;
8241 type SetValue = Self;
8242 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
8243
8244 fn param_spec_builder() -> Self::BuilderFn {
8245 Self::ParamSpec::builder_with_default
8246 }
8247}
8248
8249impl glib::value::ValueType for PositionType {
8250 type Type = Self;
8251}
8252
8253unsafe impl<'a> glib::value::FromValue<'a> for PositionType {
8254 type Checker = glib::value::GenericValueTypeChecker<Self>;
8255
8256 #[inline]
8257 unsafe fn from_value(value: &'a glib::Value) -> Self {
8258 skip_assert_initialized!();
8259 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
8260 }
8261}
8262
8263impl ToValue for PositionType {
8264 #[inline]
8265 fn to_value(&self) -> glib::Value {
8266 let mut value = glib::Value::for_value_type::<Self>();
8267 unsafe {
8268 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
8269 }
8270 value
8271 }
8272
8273 #[inline]
8274 fn value_type(&self) -> glib::Type {
8275 Self::static_type()
8276 }
8277}
8278
8279impl From<PositionType> for glib::Value {
8280 #[inline]
8281 fn from(v: PositionType) -> Self {
8282 skip_assert_initialized!();
8283 ToValue::to_value(&v)
8284 }
8285}
8286
8287#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
8288#[non_exhaustive]
8289#[doc(alias = "GtkPrintDuplex")]
8290pub enum PrintDuplex {
8291 #[doc(alias = "GTK_PRINT_DUPLEX_SIMPLEX")]
8292 Simplex,
8293 #[doc(alias = "GTK_PRINT_DUPLEX_HORIZONTAL")]
8294 Horizontal,
8295 #[doc(alias = "GTK_PRINT_DUPLEX_VERTICAL")]
8296 Vertical,
8297 #[doc(hidden)]
8298 __Unknown(i32),
8299}
8300
8301#[doc(hidden)]
8302impl IntoGlib for PrintDuplex {
8303 type GlibType = ffi::GtkPrintDuplex;
8304
8305 #[inline]
8306 fn into_glib(self) -> ffi::GtkPrintDuplex {
8307 match self {
8308 Self::Simplex => ffi::GTK_PRINT_DUPLEX_SIMPLEX,
8309 Self::Horizontal => ffi::GTK_PRINT_DUPLEX_HORIZONTAL,
8310 Self::Vertical => ffi::GTK_PRINT_DUPLEX_VERTICAL,
8311 Self::__Unknown(value) => value,
8312 }
8313 }
8314}
8315
8316#[doc(hidden)]
8317impl FromGlib<ffi::GtkPrintDuplex> for PrintDuplex {
8318 #[inline]
8319 unsafe fn from_glib(value: ffi::GtkPrintDuplex) -> Self {
8320 skip_assert_initialized!();
8321
8322 match value {
8323 ffi::GTK_PRINT_DUPLEX_SIMPLEX => Self::Simplex,
8324 ffi::GTK_PRINT_DUPLEX_HORIZONTAL => Self::Horizontal,
8325 ffi::GTK_PRINT_DUPLEX_VERTICAL => Self::Vertical,
8326 value => Self::__Unknown(value),
8327 }
8328 }
8329}
8330
8331impl StaticType for PrintDuplex {
8332 #[inline]
8333 #[doc(alias = "gtk_print_duplex_get_type")]
8334 fn static_type() -> glib::Type {
8335 unsafe { from_glib(ffi::gtk_print_duplex_get_type()) }
8336 }
8337}
8338
8339impl glib::HasParamSpec for PrintDuplex {
8340 type ParamSpec = glib::ParamSpecEnum;
8341 type SetValue = Self;
8342 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
8343
8344 fn param_spec_builder() -> Self::BuilderFn {
8345 Self::ParamSpec::builder_with_default
8346 }
8347}
8348
8349impl glib::value::ValueType for PrintDuplex {
8350 type Type = Self;
8351}
8352
8353unsafe impl<'a> glib::value::FromValue<'a> for PrintDuplex {
8354 type Checker = glib::value::GenericValueTypeChecker<Self>;
8355
8356 #[inline]
8357 unsafe fn from_value(value: &'a glib::Value) -> Self {
8358 skip_assert_initialized!();
8359 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
8360 }
8361}
8362
8363impl ToValue for PrintDuplex {
8364 #[inline]
8365 fn to_value(&self) -> glib::Value {
8366 let mut value = glib::Value::for_value_type::<Self>();
8367 unsafe {
8368 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
8369 }
8370 value
8371 }
8372
8373 #[inline]
8374 fn value_type(&self) -> glib::Type {
8375 Self::static_type()
8376 }
8377}
8378
8379impl From<PrintDuplex> for glib::Value {
8380 #[inline]
8381 fn from(v: PrintDuplex) -> Self {
8382 skip_assert_initialized!();
8383 ToValue::to_value(&v)
8384 }
8385}
8386
8387#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
8388#[non_exhaustive]
8389#[doc(alias = "GtkPrintError")]
8390pub enum PrintError {
8391 #[doc(alias = "GTK_PRINT_ERROR_GENERAL")]
8392 General,
8393 #[doc(alias = "GTK_PRINT_ERROR_INTERNAL_ERROR")]
8394 InternalError,
8395 #[doc(alias = "GTK_PRINT_ERROR_NOMEM")]
8396 Nomem,
8397 #[doc(alias = "GTK_PRINT_ERROR_INVALID_FILE")]
8398 InvalidFile,
8399 #[doc(hidden)]
8400 __Unknown(i32),
8401}
8402
8403#[doc(hidden)]
8404impl IntoGlib for PrintError {
8405 type GlibType = ffi::GtkPrintError;
8406
8407 #[inline]
8408 fn into_glib(self) -> ffi::GtkPrintError {
8409 match self {
8410 Self::General => ffi::GTK_PRINT_ERROR_GENERAL,
8411 Self::InternalError => ffi::GTK_PRINT_ERROR_INTERNAL_ERROR,
8412 Self::Nomem => ffi::GTK_PRINT_ERROR_NOMEM,
8413 Self::InvalidFile => ffi::GTK_PRINT_ERROR_INVALID_FILE,
8414 Self::__Unknown(value) => value,
8415 }
8416 }
8417}
8418
8419#[doc(hidden)]
8420impl FromGlib<ffi::GtkPrintError> for PrintError {
8421 #[inline]
8422 unsafe fn from_glib(value: ffi::GtkPrintError) -> Self {
8423 skip_assert_initialized!();
8424
8425 match value {
8426 ffi::GTK_PRINT_ERROR_GENERAL => Self::General,
8427 ffi::GTK_PRINT_ERROR_INTERNAL_ERROR => Self::InternalError,
8428 ffi::GTK_PRINT_ERROR_NOMEM => Self::Nomem,
8429 ffi::GTK_PRINT_ERROR_INVALID_FILE => Self::InvalidFile,
8430 value => Self::__Unknown(value),
8431 }
8432 }
8433}
8434
8435impl glib::error::ErrorDomain for PrintError {
8436 #[inline]
8437 fn domain() -> glib::Quark {
8438 skip_assert_initialized!();
8439
8440 unsafe { from_glib(ffi::gtk_print_error_quark()) }
8441 }
8442
8443 #[inline]
8444 fn code(self) -> i32 {
8445 self.into_glib()
8446 }
8447
8448 #[inline]
8449 #[allow(clippy::match_single_binding)]
8450 fn from(code: i32) -> Option<Self> {
8451 skip_assert_initialized!();
8452 match unsafe { from_glib(code) } {
8453 value => Some(value),
8454 }
8455 }
8456}
8457
8458impl StaticType for PrintError {
8459 #[inline]
8460 #[doc(alias = "gtk_print_error_get_type")]
8461 fn static_type() -> glib::Type {
8462 unsafe { from_glib(ffi::gtk_print_error_get_type()) }
8463 }
8464}
8465
8466impl glib::HasParamSpec for PrintError {
8467 type ParamSpec = glib::ParamSpecEnum;
8468 type SetValue = Self;
8469 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
8470
8471 fn param_spec_builder() -> Self::BuilderFn {
8472 Self::ParamSpec::builder_with_default
8473 }
8474}
8475
8476impl glib::value::ValueType for PrintError {
8477 type Type = Self;
8478}
8479
8480unsafe impl<'a> glib::value::FromValue<'a> for PrintError {
8481 type Checker = glib::value::GenericValueTypeChecker<Self>;
8482
8483 #[inline]
8484 unsafe fn from_value(value: &'a glib::Value) -> Self {
8485 skip_assert_initialized!();
8486 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
8487 }
8488}
8489
8490impl ToValue for PrintError {
8491 #[inline]
8492 fn to_value(&self) -> glib::Value {
8493 let mut value = glib::Value::for_value_type::<Self>();
8494 unsafe {
8495 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
8496 }
8497 value
8498 }
8499
8500 #[inline]
8501 fn value_type(&self) -> glib::Type {
8502 Self::static_type()
8503 }
8504}
8505
8506impl From<PrintError> for glib::Value {
8507 #[inline]
8508 fn from(v: PrintError) -> Self {
8509 skip_assert_initialized!();
8510 ToValue::to_value(&v)
8511 }
8512}
8513
8514#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
8515#[non_exhaustive]
8516#[doc(alias = "GtkPrintOperationAction")]
8517pub enum PrintOperationAction {
8518 #[doc(alias = "GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG")]
8519 PrintDialog,
8520 #[doc(alias = "GTK_PRINT_OPERATION_ACTION_PRINT")]
8521 Print,
8522 #[doc(alias = "GTK_PRINT_OPERATION_ACTION_PREVIEW")]
8523 Preview,
8524 #[doc(alias = "GTK_PRINT_OPERATION_ACTION_EXPORT")]
8525 Export,
8526 #[doc(hidden)]
8527 __Unknown(i32),
8528}
8529
8530#[doc(hidden)]
8531impl IntoGlib for PrintOperationAction {
8532 type GlibType = ffi::GtkPrintOperationAction;
8533
8534 #[inline]
8535 fn into_glib(self) -> ffi::GtkPrintOperationAction {
8536 match self {
8537 Self::PrintDialog => ffi::GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG,
8538 Self::Print => ffi::GTK_PRINT_OPERATION_ACTION_PRINT,
8539 Self::Preview => ffi::GTK_PRINT_OPERATION_ACTION_PREVIEW,
8540 Self::Export => ffi::GTK_PRINT_OPERATION_ACTION_EXPORT,
8541 Self::__Unknown(value) => value,
8542 }
8543 }
8544}
8545
8546#[doc(hidden)]
8547impl FromGlib<ffi::GtkPrintOperationAction> for PrintOperationAction {
8548 #[inline]
8549 unsafe fn from_glib(value: ffi::GtkPrintOperationAction) -> Self {
8550 skip_assert_initialized!();
8551
8552 match value {
8553 ffi::GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG => Self::PrintDialog,
8554 ffi::GTK_PRINT_OPERATION_ACTION_PRINT => Self::Print,
8555 ffi::GTK_PRINT_OPERATION_ACTION_PREVIEW => Self::Preview,
8556 ffi::GTK_PRINT_OPERATION_ACTION_EXPORT => Self::Export,
8557 value => Self::__Unknown(value),
8558 }
8559 }
8560}
8561
8562impl StaticType for PrintOperationAction {
8563 #[inline]
8564 #[doc(alias = "gtk_print_operation_action_get_type")]
8565 fn static_type() -> glib::Type {
8566 unsafe { from_glib(ffi::gtk_print_operation_action_get_type()) }
8567 }
8568}
8569
8570impl glib::HasParamSpec for PrintOperationAction {
8571 type ParamSpec = glib::ParamSpecEnum;
8572 type SetValue = Self;
8573 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
8574
8575 fn param_spec_builder() -> Self::BuilderFn {
8576 Self::ParamSpec::builder_with_default
8577 }
8578}
8579
8580impl glib::value::ValueType for PrintOperationAction {
8581 type Type = Self;
8582}
8583
8584unsafe impl<'a> glib::value::FromValue<'a> for PrintOperationAction {
8585 type Checker = glib::value::GenericValueTypeChecker<Self>;
8586
8587 #[inline]
8588 unsafe fn from_value(value: &'a glib::Value) -> Self {
8589 skip_assert_initialized!();
8590 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
8591 }
8592}
8593
8594impl ToValue for PrintOperationAction {
8595 #[inline]
8596 fn to_value(&self) -> glib::Value {
8597 let mut value = glib::Value::for_value_type::<Self>();
8598 unsafe {
8599 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
8600 }
8601 value
8602 }
8603
8604 #[inline]
8605 fn value_type(&self) -> glib::Type {
8606 Self::static_type()
8607 }
8608}
8609
8610impl From<PrintOperationAction> for glib::Value {
8611 #[inline]
8612 fn from(v: PrintOperationAction) -> Self {
8613 skip_assert_initialized!();
8614 ToValue::to_value(&v)
8615 }
8616}
8617
8618#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
8619#[non_exhaustive]
8620#[doc(alias = "GtkPrintOperationResult")]
8621pub enum PrintOperationResult {
8622 #[doc(alias = "GTK_PRINT_OPERATION_RESULT_ERROR")]
8623 Error,
8624 #[doc(alias = "GTK_PRINT_OPERATION_RESULT_APPLY")]
8625 Apply,
8626 #[doc(alias = "GTK_PRINT_OPERATION_RESULT_CANCEL")]
8627 Cancel,
8628 #[doc(alias = "GTK_PRINT_OPERATION_RESULT_IN_PROGRESS")]
8629 InProgress,
8630 #[doc(hidden)]
8631 __Unknown(i32),
8632}
8633
8634#[doc(hidden)]
8635impl IntoGlib for PrintOperationResult {
8636 type GlibType = ffi::GtkPrintOperationResult;
8637
8638 #[inline]
8639 fn into_glib(self) -> ffi::GtkPrintOperationResult {
8640 match self {
8641 Self::Error => ffi::GTK_PRINT_OPERATION_RESULT_ERROR,
8642 Self::Apply => ffi::GTK_PRINT_OPERATION_RESULT_APPLY,
8643 Self::Cancel => ffi::GTK_PRINT_OPERATION_RESULT_CANCEL,
8644 Self::InProgress => ffi::GTK_PRINT_OPERATION_RESULT_IN_PROGRESS,
8645 Self::__Unknown(value) => value,
8646 }
8647 }
8648}
8649
8650#[doc(hidden)]
8651impl FromGlib<ffi::GtkPrintOperationResult> for PrintOperationResult {
8652 #[inline]
8653 unsafe fn from_glib(value: ffi::GtkPrintOperationResult) -> Self {
8654 skip_assert_initialized!();
8655
8656 match value {
8657 ffi::GTK_PRINT_OPERATION_RESULT_ERROR => Self::Error,
8658 ffi::GTK_PRINT_OPERATION_RESULT_APPLY => Self::Apply,
8659 ffi::GTK_PRINT_OPERATION_RESULT_CANCEL => Self::Cancel,
8660 ffi::GTK_PRINT_OPERATION_RESULT_IN_PROGRESS => Self::InProgress,
8661 value => Self::__Unknown(value),
8662 }
8663 }
8664}
8665
8666impl StaticType for PrintOperationResult {
8667 #[inline]
8668 #[doc(alias = "gtk_print_operation_result_get_type")]
8669 fn static_type() -> glib::Type {
8670 unsafe { from_glib(ffi::gtk_print_operation_result_get_type()) }
8671 }
8672}
8673
8674impl glib::HasParamSpec for PrintOperationResult {
8675 type ParamSpec = glib::ParamSpecEnum;
8676 type SetValue = Self;
8677 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
8678
8679 fn param_spec_builder() -> Self::BuilderFn {
8680 Self::ParamSpec::builder_with_default
8681 }
8682}
8683
8684impl glib::value::ValueType for PrintOperationResult {
8685 type Type = Self;
8686}
8687
8688unsafe impl<'a> glib::value::FromValue<'a> for PrintOperationResult {
8689 type Checker = glib::value::GenericValueTypeChecker<Self>;
8690
8691 #[inline]
8692 unsafe fn from_value(value: &'a glib::Value) -> Self {
8693 skip_assert_initialized!();
8694 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
8695 }
8696}
8697
8698impl ToValue for PrintOperationResult {
8699 #[inline]
8700 fn to_value(&self) -> glib::Value {
8701 let mut value = glib::Value::for_value_type::<Self>();
8702 unsafe {
8703 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
8704 }
8705 value
8706 }
8707
8708 #[inline]
8709 fn value_type(&self) -> glib::Type {
8710 Self::static_type()
8711 }
8712}
8713
8714impl From<PrintOperationResult> for glib::Value {
8715 #[inline]
8716 fn from(v: PrintOperationResult) -> Self {
8717 skip_assert_initialized!();
8718 ToValue::to_value(&v)
8719 }
8720}
8721
8722#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
8723#[non_exhaustive]
8724#[doc(alias = "GtkPrintPages")]
8725pub enum PrintPages {
8726 #[doc(alias = "GTK_PRINT_PAGES_ALL")]
8727 All,
8728 #[doc(alias = "GTK_PRINT_PAGES_CURRENT")]
8729 Current,
8730 #[doc(alias = "GTK_PRINT_PAGES_RANGES")]
8731 Ranges,
8732 #[doc(alias = "GTK_PRINT_PAGES_SELECTION")]
8733 Selection,
8734 #[doc(hidden)]
8735 __Unknown(i32),
8736}
8737
8738#[doc(hidden)]
8739impl IntoGlib for PrintPages {
8740 type GlibType = ffi::GtkPrintPages;
8741
8742 #[inline]
8743 fn into_glib(self) -> ffi::GtkPrintPages {
8744 match self {
8745 Self::All => ffi::GTK_PRINT_PAGES_ALL,
8746 Self::Current => ffi::GTK_PRINT_PAGES_CURRENT,
8747 Self::Ranges => ffi::GTK_PRINT_PAGES_RANGES,
8748 Self::Selection => ffi::GTK_PRINT_PAGES_SELECTION,
8749 Self::__Unknown(value) => value,
8750 }
8751 }
8752}
8753
8754#[doc(hidden)]
8755impl FromGlib<ffi::GtkPrintPages> for PrintPages {
8756 #[inline]
8757 unsafe fn from_glib(value: ffi::GtkPrintPages) -> Self {
8758 skip_assert_initialized!();
8759
8760 match value {
8761 ffi::GTK_PRINT_PAGES_ALL => Self::All,
8762 ffi::GTK_PRINT_PAGES_CURRENT => Self::Current,
8763 ffi::GTK_PRINT_PAGES_RANGES => Self::Ranges,
8764 ffi::GTK_PRINT_PAGES_SELECTION => Self::Selection,
8765 value => Self::__Unknown(value),
8766 }
8767 }
8768}
8769
8770impl StaticType for PrintPages {
8771 #[inline]
8772 #[doc(alias = "gtk_print_pages_get_type")]
8773 fn static_type() -> glib::Type {
8774 unsafe { from_glib(ffi::gtk_print_pages_get_type()) }
8775 }
8776}
8777
8778impl glib::HasParamSpec for PrintPages {
8779 type ParamSpec = glib::ParamSpecEnum;
8780 type SetValue = Self;
8781 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
8782
8783 fn param_spec_builder() -> Self::BuilderFn {
8784 Self::ParamSpec::builder_with_default
8785 }
8786}
8787
8788impl glib::value::ValueType for PrintPages {
8789 type Type = Self;
8790}
8791
8792unsafe impl<'a> glib::value::FromValue<'a> for PrintPages {
8793 type Checker = glib::value::GenericValueTypeChecker<Self>;
8794
8795 #[inline]
8796 unsafe fn from_value(value: &'a glib::Value) -> Self {
8797 skip_assert_initialized!();
8798 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
8799 }
8800}
8801
8802impl ToValue for PrintPages {
8803 #[inline]
8804 fn to_value(&self) -> glib::Value {
8805 let mut value = glib::Value::for_value_type::<Self>();
8806 unsafe {
8807 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
8808 }
8809 value
8810 }
8811
8812 #[inline]
8813 fn value_type(&self) -> glib::Type {
8814 Self::static_type()
8815 }
8816}
8817
8818impl From<PrintPages> for glib::Value {
8819 #[inline]
8820 fn from(v: PrintPages) -> Self {
8821 skip_assert_initialized!();
8822 ToValue::to_value(&v)
8823 }
8824}
8825
8826#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
8827#[non_exhaustive]
8828#[doc(alias = "GtkPrintQuality")]
8829pub enum PrintQuality {
8830 #[doc(alias = "GTK_PRINT_QUALITY_LOW")]
8831 Low,
8832 #[doc(alias = "GTK_PRINT_QUALITY_NORMAL")]
8833 Normal,
8834 #[doc(alias = "GTK_PRINT_QUALITY_HIGH")]
8835 High,
8836 #[doc(alias = "GTK_PRINT_QUALITY_DRAFT")]
8837 Draft,
8838 #[doc(hidden)]
8839 __Unknown(i32),
8840}
8841
8842#[doc(hidden)]
8843impl IntoGlib for PrintQuality {
8844 type GlibType = ffi::GtkPrintQuality;
8845
8846 #[inline]
8847 fn into_glib(self) -> ffi::GtkPrintQuality {
8848 match self {
8849 Self::Low => ffi::GTK_PRINT_QUALITY_LOW,
8850 Self::Normal => ffi::GTK_PRINT_QUALITY_NORMAL,
8851 Self::High => ffi::GTK_PRINT_QUALITY_HIGH,
8852 Self::Draft => ffi::GTK_PRINT_QUALITY_DRAFT,
8853 Self::__Unknown(value) => value,
8854 }
8855 }
8856}
8857
8858#[doc(hidden)]
8859impl FromGlib<ffi::GtkPrintQuality> for PrintQuality {
8860 #[inline]
8861 unsafe fn from_glib(value: ffi::GtkPrintQuality) -> Self {
8862 skip_assert_initialized!();
8863
8864 match value {
8865 ffi::GTK_PRINT_QUALITY_LOW => Self::Low,
8866 ffi::GTK_PRINT_QUALITY_NORMAL => Self::Normal,
8867 ffi::GTK_PRINT_QUALITY_HIGH => Self::High,
8868 ffi::GTK_PRINT_QUALITY_DRAFT => Self::Draft,
8869 value => Self::__Unknown(value),
8870 }
8871 }
8872}
8873
8874impl StaticType for PrintQuality {
8875 #[inline]
8876 #[doc(alias = "gtk_print_quality_get_type")]
8877 fn static_type() -> glib::Type {
8878 unsafe { from_glib(ffi::gtk_print_quality_get_type()) }
8879 }
8880}
8881
8882impl glib::HasParamSpec for PrintQuality {
8883 type ParamSpec = glib::ParamSpecEnum;
8884 type SetValue = Self;
8885 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
8886
8887 fn param_spec_builder() -> Self::BuilderFn {
8888 Self::ParamSpec::builder_with_default
8889 }
8890}
8891
8892impl glib::value::ValueType for PrintQuality {
8893 type Type = Self;
8894}
8895
8896unsafe impl<'a> glib::value::FromValue<'a> for PrintQuality {
8897 type Checker = glib::value::GenericValueTypeChecker<Self>;
8898
8899 #[inline]
8900 unsafe fn from_value(value: &'a glib::Value) -> Self {
8901 skip_assert_initialized!();
8902 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
8903 }
8904}
8905
8906impl ToValue for PrintQuality {
8907 #[inline]
8908 fn to_value(&self) -> glib::Value {
8909 let mut value = glib::Value::for_value_type::<Self>();
8910 unsafe {
8911 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
8912 }
8913 value
8914 }
8915
8916 #[inline]
8917 fn value_type(&self) -> glib::Type {
8918 Self::static_type()
8919 }
8920}
8921
8922impl From<PrintQuality> for glib::Value {
8923 #[inline]
8924 fn from(v: PrintQuality) -> Self {
8925 skip_assert_initialized!();
8926 ToValue::to_value(&v)
8927 }
8928}
8929
8930#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
8931#[non_exhaustive]
8932#[doc(alias = "GtkPrintStatus")]
8933pub enum PrintStatus {
8934 #[doc(alias = "GTK_PRINT_STATUS_INITIAL")]
8935 Initial,
8936 #[doc(alias = "GTK_PRINT_STATUS_PREPARING")]
8937 Preparing,
8938 #[doc(alias = "GTK_PRINT_STATUS_GENERATING_DATA")]
8939 GeneratingData,
8940 #[doc(alias = "GTK_PRINT_STATUS_SENDING_DATA")]
8941 SendingData,
8942 #[doc(alias = "GTK_PRINT_STATUS_PENDING")]
8943 Pending,
8944 #[doc(alias = "GTK_PRINT_STATUS_PENDING_ISSUE")]
8945 PendingIssue,
8946 #[doc(alias = "GTK_PRINT_STATUS_PRINTING")]
8947 Printing,
8948 #[doc(alias = "GTK_PRINT_STATUS_FINISHED")]
8949 Finished,
8950 #[doc(alias = "GTK_PRINT_STATUS_FINISHED_ABORTED")]
8951 FinishedAborted,
8952 #[doc(hidden)]
8953 __Unknown(i32),
8954}
8955
8956#[doc(hidden)]
8957impl IntoGlib for PrintStatus {
8958 type GlibType = ffi::GtkPrintStatus;
8959
8960 #[inline]
8961 fn into_glib(self) -> ffi::GtkPrintStatus {
8962 match self {
8963 Self::Initial => ffi::GTK_PRINT_STATUS_INITIAL,
8964 Self::Preparing => ffi::GTK_PRINT_STATUS_PREPARING,
8965 Self::GeneratingData => ffi::GTK_PRINT_STATUS_GENERATING_DATA,
8966 Self::SendingData => ffi::GTK_PRINT_STATUS_SENDING_DATA,
8967 Self::Pending => ffi::GTK_PRINT_STATUS_PENDING,
8968 Self::PendingIssue => ffi::GTK_PRINT_STATUS_PENDING_ISSUE,
8969 Self::Printing => ffi::GTK_PRINT_STATUS_PRINTING,
8970 Self::Finished => ffi::GTK_PRINT_STATUS_FINISHED,
8971 Self::FinishedAborted => ffi::GTK_PRINT_STATUS_FINISHED_ABORTED,
8972 Self::__Unknown(value) => value,
8973 }
8974 }
8975}
8976
8977#[doc(hidden)]
8978impl FromGlib<ffi::GtkPrintStatus> for PrintStatus {
8979 #[inline]
8980 unsafe fn from_glib(value: ffi::GtkPrintStatus) -> Self {
8981 skip_assert_initialized!();
8982
8983 match value {
8984 ffi::GTK_PRINT_STATUS_INITIAL => Self::Initial,
8985 ffi::GTK_PRINT_STATUS_PREPARING => Self::Preparing,
8986 ffi::GTK_PRINT_STATUS_GENERATING_DATA => Self::GeneratingData,
8987 ffi::GTK_PRINT_STATUS_SENDING_DATA => Self::SendingData,
8988 ffi::GTK_PRINT_STATUS_PENDING => Self::Pending,
8989 ffi::GTK_PRINT_STATUS_PENDING_ISSUE => Self::PendingIssue,
8990 ffi::GTK_PRINT_STATUS_PRINTING => Self::Printing,
8991 ffi::GTK_PRINT_STATUS_FINISHED => Self::Finished,
8992 ffi::GTK_PRINT_STATUS_FINISHED_ABORTED => Self::FinishedAborted,
8993 value => Self::__Unknown(value),
8994 }
8995 }
8996}
8997
8998impl StaticType for PrintStatus {
8999 #[inline]
9000 #[doc(alias = "gtk_print_status_get_type")]
9001 fn static_type() -> glib::Type {
9002 unsafe { from_glib(ffi::gtk_print_status_get_type()) }
9003 }
9004}
9005
9006impl glib::HasParamSpec for PrintStatus {
9007 type ParamSpec = glib::ParamSpecEnum;
9008 type SetValue = Self;
9009 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
9010
9011 fn param_spec_builder() -> Self::BuilderFn {
9012 Self::ParamSpec::builder_with_default
9013 }
9014}
9015
9016impl glib::value::ValueType for PrintStatus {
9017 type Type = Self;
9018}
9019
9020unsafe impl<'a> glib::value::FromValue<'a> for PrintStatus {
9021 type Checker = glib::value::GenericValueTypeChecker<Self>;
9022
9023 #[inline]
9024 unsafe fn from_value(value: &'a glib::Value) -> Self {
9025 skip_assert_initialized!();
9026 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
9027 }
9028}
9029
9030impl ToValue for PrintStatus {
9031 #[inline]
9032 fn to_value(&self) -> glib::Value {
9033 let mut value = glib::Value::for_value_type::<Self>();
9034 unsafe {
9035 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
9036 }
9037 value
9038 }
9039
9040 #[inline]
9041 fn value_type(&self) -> glib::Type {
9042 Self::static_type()
9043 }
9044}
9045
9046impl From<PrintStatus> for glib::Value {
9047 #[inline]
9048 fn from(v: PrintStatus) -> Self {
9049 skip_assert_initialized!();
9050 ToValue::to_value(&v)
9051 }
9052}
9053
9054#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
9055#[non_exhaustive]
9056#[doc(alias = "GtkPropagationLimit")]
9057pub enum PropagationLimit {
9058 #[doc(alias = "GTK_LIMIT_NONE")]
9059 None,
9060 #[doc(alias = "GTK_LIMIT_SAME_NATIVE")]
9061 SameNative,
9062 #[doc(hidden)]
9063 __Unknown(i32),
9064}
9065
9066#[doc(hidden)]
9067impl IntoGlib for PropagationLimit {
9068 type GlibType = ffi::GtkPropagationLimit;
9069
9070 #[inline]
9071 fn into_glib(self) -> ffi::GtkPropagationLimit {
9072 match self {
9073 Self::None => ffi::GTK_LIMIT_NONE,
9074 Self::SameNative => ffi::GTK_LIMIT_SAME_NATIVE,
9075 Self::__Unknown(value) => value,
9076 }
9077 }
9078}
9079
9080#[doc(hidden)]
9081impl FromGlib<ffi::GtkPropagationLimit> for PropagationLimit {
9082 #[inline]
9083 unsafe fn from_glib(value: ffi::GtkPropagationLimit) -> Self {
9084 skip_assert_initialized!();
9085
9086 match value {
9087 ffi::GTK_LIMIT_NONE => Self::None,
9088 ffi::GTK_LIMIT_SAME_NATIVE => Self::SameNative,
9089 value => Self::__Unknown(value),
9090 }
9091 }
9092}
9093
9094impl StaticType for PropagationLimit {
9095 #[inline]
9096 #[doc(alias = "gtk_propagation_limit_get_type")]
9097 fn static_type() -> glib::Type {
9098 unsafe { from_glib(ffi::gtk_propagation_limit_get_type()) }
9099 }
9100}
9101
9102impl glib::HasParamSpec for PropagationLimit {
9103 type ParamSpec = glib::ParamSpecEnum;
9104 type SetValue = Self;
9105 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
9106
9107 fn param_spec_builder() -> Self::BuilderFn {
9108 Self::ParamSpec::builder_with_default
9109 }
9110}
9111
9112impl glib::value::ValueType for PropagationLimit {
9113 type Type = Self;
9114}
9115
9116unsafe impl<'a> glib::value::FromValue<'a> for PropagationLimit {
9117 type Checker = glib::value::GenericValueTypeChecker<Self>;
9118
9119 #[inline]
9120 unsafe fn from_value(value: &'a glib::Value) -> Self {
9121 skip_assert_initialized!();
9122 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
9123 }
9124}
9125
9126impl ToValue for PropagationLimit {
9127 #[inline]
9128 fn to_value(&self) -> glib::Value {
9129 let mut value = glib::Value::for_value_type::<Self>();
9130 unsafe {
9131 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
9132 }
9133 value
9134 }
9135
9136 #[inline]
9137 fn value_type(&self) -> glib::Type {
9138 Self::static_type()
9139 }
9140}
9141
9142impl From<PropagationLimit> for glib::Value {
9143 #[inline]
9144 fn from(v: PropagationLimit) -> Self {
9145 skip_assert_initialized!();
9146 ToValue::to_value(&v)
9147 }
9148}
9149
9150#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
9151#[non_exhaustive]
9152#[doc(alias = "GtkPropagationPhase")]
9153pub enum PropagationPhase {
9154 #[doc(alias = "GTK_PHASE_NONE")]
9155 None,
9156 #[doc(alias = "GTK_PHASE_CAPTURE")]
9157 Capture,
9158 #[doc(alias = "GTK_PHASE_BUBBLE")]
9159 Bubble,
9160 #[doc(alias = "GTK_PHASE_TARGET")]
9161 Target,
9162 #[doc(hidden)]
9163 __Unknown(i32),
9164}
9165
9166#[doc(hidden)]
9167impl IntoGlib for PropagationPhase {
9168 type GlibType = ffi::GtkPropagationPhase;
9169
9170 #[inline]
9171 fn into_glib(self) -> ffi::GtkPropagationPhase {
9172 match self {
9173 Self::None => ffi::GTK_PHASE_NONE,
9174 Self::Capture => ffi::GTK_PHASE_CAPTURE,
9175 Self::Bubble => ffi::GTK_PHASE_BUBBLE,
9176 Self::Target => ffi::GTK_PHASE_TARGET,
9177 Self::__Unknown(value) => value,
9178 }
9179 }
9180}
9181
9182#[doc(hidden)]
9183impl FromGlib<ffi::GtkPropagationPhase> for PropagationPhase {
9184 #[inline]
9185 unsafe fn from_glib(value: ffi::GtkPropagationPhase) -> Self {
9186 skip_assert_initialized!();
9187
9188 match value {
9189 ffi::GTK_PHASE_NONE => Self::None,
9190 ffi::GTK_PHASE_CAPTURE => Self::Capture,
9191 ffi::GTK_PHASE_BUBBLE => Self::Bubble,
9192 ffi::GTK_PHASE_TARGET => Self::Target,
9193 value => Self::__Unknown(value),
9194 }
9195 }
9196}
9197
9198impl StaticType for PropagationPhase {
9199 #[inline]
9200 #[doc(alias = "gtk_propagation_phase_get_type")]
9201 fn static_type() -> glib::Type {
9202 unsafe { from_glib(ffi::gtk_propagation_phase_get_type()) }
9203 }
9204}
9205
9206impl glib::HasParamSpec for PropagationPhase {
9207 type ParamSpec = glib::ParamSpecEnum;
9208 type SetValue = Self;
9209 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
9210
9211 fn param_spec_builder() -> Self::BuilderFn {
9212 Self::ParamSpec::builder_with_default
9213 }
9214}
9215
9216impl glib::value::ValueType for PropagationPhase {
9217 type Type = Self;
9218}
9219
9220unsafe impl<'a> glib::value::FromValue<'a> for PropagationPhase {
9221 type Checker = glib::value::GenericValueTypeChecker<Self>;
9222
9223 #[inline]
9224 unsafe fn from_value(value: &'a glib::Value) -> Self {
9225 skip_assert_initialized!();
9226 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
9227 }
9228}
9229
9230impl ToValue for PropagationPhase {
9231 #[inline]
9232 fn to_value(&self) -> glib::Value {
9233 let mut value = glib::Value::for_value_type::<Self>();
9234 unsafe {
9235 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
9236 }
9237 value
9238 }
9239
9240 #[inline]
9241 fn value_type(&self) -> glib::Type {
9242 Self::static_type()
9243 }
9244}
9245
9246impl From<PropagationPhase> for glib::Value {
9247 #[inline]
9248 fn from(v: PropagationPhase) -> Self {
9249 skip_assert_initialized!();
9250 ToValue::to_value(&v)
9251 }
9252}
9253
9254#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
9255#[non_exhaustive]
9256#[doc(alias = "GtkRecentManagerError")]
9257pub enum RecentManagerError {
9258 #[doc(alias = "GTK_RECENT_MANAGER_ERROR_NOT_FOUND")]
9259 NotFound,
9260 #[doc(alias = "GTK_RECENT_MANAGER_ERROR_INVALID_URI")]
9261 InvalidUri,
9262 #[doc(alias = "GTK_RECENT_MANAGER_ERROR_INVALID_ENCODING")]
9263 InvalidEncoding,
9264 #[doc(alias = "GTK_RECENT_MANAGER_ERROR_NOT_REGISTERED")]
9265 NotRegistered,
9266 #[doc(alias = "GTK_RECENT_MANAGER_ERROR_READ")]
9267 Read,
9268 #[doc(alias = "GTK_RECENT_MANAGER_ERROR_WRITE")]
9269 Write,
9270 #[doc(alias = "GTK_RECENT_MANAGER_ERROR_UNKNOWN")]
9271 Unknown,
9272 #[doc(hidden)]
9273 __Unknown(i32),
9274}
9275
9276#[doc(hidden)]
9277impl IntoGlib for RecentManagerError {
9278 type GlibType = ffi::GtkRecentManagerError;
9279
9280 #[inline]
9281 fn into_glib(self) -> ffi::GtkRecentManagerError {
9282 match self {
9283 Self::NotFound => ffi::GTK_RECENT_MANAGER_ERROR_NOT_FOUND,
9284 Self::InvalidUri => ffi::GTK_RECENT_MANAGER_ERROR_INVALID_URI,
9285 Self::InvalidEncoding => ffi::GTK_RECENT_MANAGER_ERROR_INVALID_ENCODING,
9286 Self::NotRegistered => ffi::GTK_RECENT_MANAGER_ERROR_NOT_REGISTERED,
9287 Self::Read => ffi::GTK_RECENT_MANAGER_ERROR_READ,
9288 Self::Write => ffi::GTK_RECENT_MANAGER_ERROR_WRITE,
9289 Self::Unknown => ffi::GTK_RECENT_MANAGER_ERROR_UNKNOWN,
9290 Self::__Unknown(value) => value,
9291 }
9292 }
9293}
9294
9295#[doc(hidden)]
9296impl FromGlib<ffi::GtkRecentManagerError> for RecentManagerError {
9297 #[inline]
9298 unsafe fn from_glib(value: ffi::GtkRecentManagerError) -> Self {
9299 skip_assert_initialized!();
9300
9301 match value {
9302 ffi::GTK_RECENT_MANAGER_ERROR_NOT_FOUND => Self::NotFound,
9303 ffi::GTK_RECENT_MANAGER_ERROR_INVALID_URI => Self::InvalidUri,
9304 ffi::GTK_RECENT_MANAGER_ERROR_INVALID_ENCODING => Self::InvalidEncoding,
9305 ffi::GTK_RECENT_MANAGER_ERROR_NOT_REGISTERED => Self::NotRegistered,
9306 ffi::GTK_RECENT_MANAGER_ERROR_READ => Self::Read,
9307 ffi::GTK_RECENT_MANAGER_ERROR_WRITE => Self::Write,
9308 ffi::GTK_RECENT_MANAGER_ERROR_UNKNOWN => Self::Unknown,
9309 value => Self::__Unknown(value),
9310 }
9311 }
9312}
9313
9314impl glib::error::ErrorDomain for RecentManagerError {
9315 #[inline]
9316 fn domain() -> glib::Quark {
9317 skip_assert_initialized!();
9318
9319 unsafe { from_glib(ffi::gtk_recent_manager_error_quark()) }
9320 }
9321
9322 #[inline]
9323 fn code(self) -> i32 {
9324 self.into_glib()
9325 }
9326
9327 #[inline]
9328 #[allow(clippy::match_single_binding)]
9329 fn from(code: i32) -> Option<Self> {
9330 skip_assert_initialized!();
9331 match unsafe { from_glib(code) } {
9332 value => Some(value),
9333 }
9334 }
9335}
9336
9337impl StaticType for RecentManagerError {
9338 #[inline]
9339 #[doc(alias = "gtk_recent_manager_error_get_type")]
9340 fn static_type() -> glib::Type {
9341 unsafe { from_glib(ffi::gtk_recent_manager_error_get_type()) }
9342 }
9343}
9344
9345impl glib::HasParamSpec for RecentManagerError {
9346 type ParamSpec = glib::ParamSpecEnum;
9347 type SetValue = Self;
9348 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
9349
9350 fn param_spec_builder() -> Self::BuilderFn {
9351 Self::ParamSpec::builder_with_default
9352 }
9353}
9354
9355impl glib::value::ValueType for RecentManagerError {
9356 type Type = Self;
9357}
9358
9359unsafe impl<'a> glib::value::FromValue<'a> for RecentManagerError {
9360 type Checker = glib::value::GenericValueTypeChecker<Self>;
9361
9362 #[inline]
9363 unsafe fn from_value(value: &'a glib::Value) -> Self {
9364 skip_assert_initialized!();
9365 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
9366 }
9367}
9368
9369impl ToValue for RecentManagerError {
9370 #[inline]
9371 fn to_value(&self) -> glib::Value {
9372 let mut value = glib::Value::for_value_type::<Self>();
9373 unsafe {
9374 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
9375 }
9376 value
9377 }
9378
9379 #[inline]
9380 fn value_type(&self) -> glib::Type {
9381 Self::static_type()
9382 }
9383}
9384
9385impl From<RecentManagerError> for glib::Value {
9386 #[inline]
9387 fn from(v: RecentManagerError) -> Self {
9388 skip_assert_initialized!();
9389 ToValue::to_value(&v)
9390 }
9391}
9392
9393#[cfg(feature = "v4_22")]
9394#[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
9395#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
9396#[non_exhaustive]
9397#[doc(alias = "GtkReducedMotion")]
9398pub enum ReducedMotion {
9399 #[doc(alias = "GTK_REDUCED_MOTION_NO_PREFERENCE")]
9400 NoPreference,
9401 #[doc(alias = "GTK_REDUCED_MOTION_REDUCE")]
9402 Reduce,
9403 #[doc(hidden)]
9404 __Unknown(i32),
9405}
9406
9407#[cfg(feature = "v4_22")]
9408#[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
9409#[doc(hidden)]
9410impl IntoGlib for ReducedMotion {
9411 type GlibType = ffi::GtkReducedMotion;
9412
9413 #[inline]
9414 fn into_glib(self) -> ffi::GtkReducedMotion {
9415 match self {
9416 Self::NoPreference => ffi::GTK_REDUCED_MOTION_NO_PREFERENCE,
9417 Self::Reduce => ffi::GTK_REDUCED_MOTION_REDUCE,
9418 Self::__Unknown(value) => value,
9419 }
9420 }
9421}
9422
9423#[cfg(feature = "v4_22")]
9424#[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
9425#[doc(hidden)]
9426impl FromGlib<ffi::GtkReducedMotion> for ReducedMotion {
9427 #[inline]
9428 unsafe fn from_glib(value: ffi::GtkReducedMotion) -> Self {
9429 skip_assert_initialized!();
9430
9431 match value {
9432 ffi::GTK_REDUCED_MOTION_NO_PREFERENCE => Self::NoPreference,
9433 ffi::GTK_REDUCED_MOTION_REDUCE => Self::Reduce,
9434 value => Self::__Unknown(value),
9435 }
9436 }
9437}
9438
9439#[cfg(feature = "v4_22")]
9440#[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
9441impl StaticType for ReducedMotion {
9442 #[inline]
9443 #[doc(alias = "gtk_reduced_motion_get_type")]
9444 fn static_type() -> glib::Type {
9445 unsafe { from_glib(ffi::gtk_reduced_motion_get_type()) }
9446 }
9447}
9448
9449#[cfg(feature = "v4_22")]
9450#[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
9451impl glib::HasParamSpec for ReducedMotion {
9452 type ParamSpec = glib::ParamSpecEnum;
9453 type SetValue = Self;
9454 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
9455
9456 fn param_spec_builder() -> Self::BuilderFn {
9457 Self::ParamSpec::builder_with_default
9458 }
9459}
9460
9461#[cfg(feature = "v4_22")]
9462#[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
9463impl glib::value::ValueType for ReducedMotion {
9464 type Type = Self;
9465}
9466
9467#[cfg(feature = "v4_22")]
9468#[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
9469unsafe impl<'a> glib::value::FromValue<'a> for ReducedMotion {
9470 type Checker = glib::value::GenericValueTypeChecker<Self>;
9471
9472 #[inline]
9473 unsafe fn from_value(value: &'a glib::Value) -> Self {
9474 skip_assert_initialized!();
9475 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
9476 }
9477}
9478
9479#[cfg(feature = "v4_22")]
9480#[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
9481impl ToValue for ReducedMotion {
9482 #[inline]
9483 fn to_value(&self) -> glib::Value {
9484 let mut value = glib::Value::for_value_type::<Self>();
9485 unsafe {
9486 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
9487 }
9488 value
9489 }
9490
9491 #[inline]
9492 fn value_type(&self) -> glib::Type {
9493 Self::static_type()
9494 }
9495}
9496
9497#[cfg(feature = "v4_22")]
9498#[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
9499impl From<ReducedMotion> for glib::Value {
9500 #[inline]
9501 fn from(v: ReducedMotion) -> Self {
9502 skip_assert_initialized!();
9503 ToValue::to_value(&v)
9504 }
9505}
9506
9507#[cfg(feature = "v4_22")]
9508#[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
9509#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
9510#[non_exhaustive]
9511#[doc(alias = "GtkRestoreReason")]
9512pub enum RestoreReason {
9513 #[doc(alias = "GTK_RESTORE_REASON_PRISTINE")]
9514 Pristine,
9515 #[doc(alias = "GTK_RESTORE_REASON_LAUNCH")]
9516 Launch,
9517 #[doc(alias = "GTK_RESTORE_REASON_RECOVER")]
9518 Recover,
9519 #[doc(alias = "GTK_RESTORE_REASON_RESTORE")]
9520 Restore,
9521 #[doc(hidden)]
9522 __Unknown(i32),
9523}
9524
9525#[cfg(feature = "v4_22")]
9526#[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
9527#[doc(hidden)]
9528impl IntoGlib for RestoreReason {
9529 type GlibType = ffi::GtkRestoreReason;
9530
9531 #[inline]
9532 fn into_glib(self) -> ffi::GtkRestoreReason {
9533 match self {
9534 Self::Pristine => ffi::GTK_RESTORE_REASON_PRISTINE,
9535 Self::Launch => ffi::GTK_RESTORE_REASON_LAUNCH,
9536 Self::Recover => ffi::GTK_RESTORE_REASON_RECOVER,
9537 Self::Restore => ffi::GTK_RESTORE_REASON_RESTORE,
9538 Self::__Unknown(value) => value,
9539 }
9540 }
9541}
9542
9543#[cfg(feature = "v4_22")]
9544#[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
9545#[doc(hidden)]
9546impl FromGlib<ffi::GtkRestoreReason> for RestoreReason {
9547 #[inline]
9548 unsafe fn from_glib(value: ffi::GtkRestoreReason) -> Self {
9549 skip_assert_initialized!();
9550
9551 match value {
9552 ffi::GTK_RESTORE_REASON_PRISTINE => Self::Pristine,
9553 ffi::GTK_RESTORE_REASON_LAUNCH => Self::Launch,
9554 ffi::GTK_RESTORE_REASON_RECOVER => Self::Recover,
9555 ffi::GTK_RESTORE_REASON_RESTORE => Self::Restore,
9556 value => Self::__Unknown(value),
9557 }
9558 }
9559}
9560
9561#[cfg(feature = "v4_22")]
9562#[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
9563impl StaticType for RestoreReason {
9564 #[inline]
9565 #[doc(alias = "gtk_restore_reason_get_type")]
9566 fn static_type() -> glib::Type {
9567 unsafe { from_glib(ffi::gtk_restore_reason_get_type()) }
9568 }
9569}
9570
9571#[cfg(feature = "v4_22")]
9572#[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
9573impl glib::HasParamSpec for RestoreReason {
9574 type ParamSpec = glib::ParamSpecEnum;
9575 type SetValue = Self;
9576 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
9577
9578 fn param_spec_builder() -> Self::BuilderFn {
9579 Self::ParamSpec::builder_with_default
9580 }
9581}
9582
9583#[cfg(feature = "v4_22")]
9584#[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
9585impl glib::value::ValueType for RestoreReason {
9586 type Type = Self;
9587}
9588
9589#[cfg(feature = "v4_22")]
9590#[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
9591unsafe impl<'a> glib::value::FromValue<'a> for RestoreReason {
9592 type Checker = glib::value::GenericValueTypeChecker<Self>;
9593
9594 #[inline]
9595 unsafe fn from_value(value: &'a glib::Value) -> Self {
9596 skip_assert_initialized!();
9597 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
9598 }
9599}
9600
9601#[cfg(feature = "v4_22")]
9602#[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
9603impl ToValue for RestoreReason {
9604 #[inline]
9605 fn to_value(&self) -> glib::Value {
9606 let mut value = glib::Value::for_value_type::<Self>();
9607 unsafe {
9608 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
9609 }
9610 value
9611 }
9612
9613 #[inline]
9614 fn value_type(&self) -> glib::Type {
9615 Self::static_type()
9616 }
9617}
9618
9619#[cfg(feature = "v4_22")]
9620#[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
9621impl From<RestoreReason> for glib::Value {
9622 #[inline]
9623 fn from(v: RestoreReason) -> Self {
9624 skip_assert_initialized!();
9625 ToValue::to_value(&v)
9626 }
9627}
9628
9629#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
9630#[non_exhaustive]
9631#[doc(alias = "GtkRevealerTransitionType")]
9632pub enum RevealerTransitionType {
9633 #[doc(alias = "GTK_REVEALER_TRANSITION_TYPE_NONE")]
9634 None,
9635 #[doc(alias = "GTK_REVEALER_TRANSITION_TYPE_CROSSFADE")]
9636 Crossfade,
9637 #[doc(alias = "GTK_REVEALER_TRANSITION_TYPE_SLIDE_RIGHT")]
9638 SlideRight,
9639 #[doc(alias = "GTK_REVEALER_TRANSITION_TYPE_SLIDE_LEFT")]
9640 SlideLeft,
9641 #[doc(alias = "GTK_REVEALER_TRANSITION_TYPE_SLIDE_UP")]
9642 SlideUp,
9643 #[doc(alias = "GTK_REVEALER_TRANSITION_TYPE_SLIDE_DOWN")]
9644 SlideDown,
9645 #[doc(alias = "GTK_REVEALER_TRANSITION_TYPE_SWING_RIGHT")]
9646 SwingRight,
9647 #[doc(alias = "GTK_REVEALER_TRANSITION_TYPE_SWING_LEFT")]
9648 SwingLeft,
9649 #[doc(alias = "GTK_REVEALER_TRANSITION_TYPE_SWING_UP")]
9650 SwingUp,
9651 #[doc(alias = "GTK_REVEALER_TRANSITION_TYPE_SWING_DOWN")]
9652 SwingDown,
9653 #[cfg(feature = "v4_22")]
9654 #[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
9655 #[doc(alias = "GTK_REVEALER_TRANSITION_TYPE_FADE_SLIDE_RIGHT")]
9656 FadeSlideRight,
9657 #[cfg(feature = "v4_22")]
9658 #[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
9659 #[doc(alias = "GTK_REVEALER_TRANSITION_TYPE_FADE_SLIDE_LEFT")]
9660 FadeSlideLeft,
9661 #[cfg(feature = "v4_22")]
9662 #[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
9663 #[doc(alias = "GTK_REVEALER_TRANSITION_TYPE_FADE_SLIDE_UP")]
9664 FadeSlideUp,
9665 #[cfg(feature = "v4_22")]
9666 #[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
9667 #[doc(alias = "GTK_REVEALER_TRANSITION_TYPE_FADE_SLIDE_DOWN")]
9668 FadeSlideDown,
9669 #[doc(hidden)]
9670 __Unknown(i32),
9671}
9672
9673#[doc(hidden)]
9674impl IntoGlib for RevealerTransitionType {
9675 type GlibType = ffi::GtkRevealerTransitionType;
9676
9677 fn into_glib(self) -> ffi::GtkRevealerTransitionType {
9678 match self {
9679 Self::None => ffi::GTK_REVEALER_TRANSITION_TYPE_NONE,
9680 Self::Crossfade => ffi::GTK_REVEALER_TRANSITION_TYPE_CROSSFADE,
9681 Self::SlideRight => ffi::GTK_REVEALER_TRANSITION_TYPE_SLIDE_RIGHT,
9682 Self::SlideLeft => ffi::GTK_REVEALER_TRANSITION_TYPE_SLIDE_LEFT,
9683 Self::SlideUp => ffi::GTK_REVEALER_TRANSITION_TYPE_SLIDE_UP,
9684 Self::SlideDown => ffi::GTK_REVEALER_TRANSITION_TYPE_SLIDE_DOWN,
9685 Self::SwingRight => ffi::GTK_REVEALER_TRANSITION_TYPE_SWING_RIGHT,
9686 Self::SwingLeft => ffi::GTK_REVEALER_TRANSITION_TYPE_SWING_LEFT,
9687 Self::SwingUp => ffi::GTK_REVEALER_TRANSITION_TYPE_SWING_UP,
9688 Self::SwingDown => ffi::GTK_REVEALER_TRANSITION_TYPE_SWING_DOWN,
9689 #[cfg(feature = "v4_22")]
9690 Self::FadeSlideRight => ffi::GTK_REVEALER_TRANSITION_TYPE_FADE_SLIDE_RIGHT,
9691 #[cfg(feature = "v4_22")]
9692 Self::FadeSlideLeft => ffi::GTK_REVEALER_TRANSITION_TYPE_FADE_SLIDE_LEFT,
9693 #[cfg(feature = "v4_22")]
9694 Self::FadeSlideUp => ffi::GTK_REVEALER_TRANSITION_TYPE_FADE_SLIDE_UP,
9695 #[cfg(feature = "v4_22")]
9696 Self::FadeSlideDown => ffi::GTK_REVEALER_TRANSITION_TYPE_FADE_SLIDE_DOWN,
9697 Self::__Unknown(value) => value,
9698 }
9699 }
9700}
9701
9702#[doc(hidden)]
9703impl FromGlib<ffi::GtkRevealerTransitionType> for RevealerTransitionType {
9704 unsafe fn from_glib(value: ffi::GtkRevealerTransitionType) -> Self {
9705 skip_assert_initialized!();
9706
9707 match value {
9708 ffi::GTK_REVEALER_TRANSITION_TYPE_NONE => Self::None,
9709 ffi::GTK_REVEALER_TRANSITION_TYPE_CROSSFADE => Self::Crossfade,
9710 ffi::GTK_REVEALER_TRANSITION_TYPE_SLIDE_RIGHT => Self::SlideRight,
9711 ffi::GTK_REVEALER_TRANSITION_TYPE_SLIDE_LEFT => Self::SlideLeft,
9712 ffi::GTK_REVEALER_TRANSITION_TYPE_SLIDE_UP => Self::SlideUp,
9713 ffi::GTK_REVEALER_TRANSITION_TYPE_SLIDE_DOWN => Self::SlideDown,
9714 ffi::GTK_REVEALER_TRANSITION_TYPE_SWING_RIGHT => Self::SwingRight,
9715 ffi::GTK_REVEALER_TRANSITION_TYPE_SWING_LEFT => Self::SwingLeft,
9716 ffi::GTK_REVEALER_TRANSITION_TYPE_SWING_UP => Self::SwingUp,
9717 ffi::GTK_REVEALER_TRANSITION_TYPE_SWING_DOWN => Self::SwingDown,
9718 #[cfg(feature = "v4_22")]
9719 ffi::GTK_REVEALER_TRANSITION_TYPE_FADE_SLIDE_RIGHT => Self::FadeSlideRight,
9720 #[cfg(feature = "v4_22")]
9721 ffi::GTK_REVEALER_TRANSITION_TYPE_FADE_SLIDE_LEFT => Self::FadeSlideLeft,
9722 #[cfg(feature = "v4_22")]
9723 ffi::GTK_REVEALER_TRANSITION_TYPE_FADE_SLIDE_UP => Self::FadeSlideUp,
9724 #[cfg(feature = "v4_22")]
9725 ffi::GTK_REVEALER_TRANSITION_TYPE_FADE_SLIDE_DOWN => Self::FadeSlideDown,
9726 value => Self::__Unknown(value),
9727 }
9728 }
9729}
9730
9731impl StaticType for RevealerTransitionType {
9732 #[inline]
9733 #[doc(alias = "gtk_revealer_transition_type_get_type")]
9734 fn static_type() -> glib::Type {
9735 unsafe { from_glib(ffi::gtk_revealer_transition_type_get_type()) }
9736 }
9737}
9738
9739impl glib::HasParamSpec for RevealerTransitionType {
9740 type ParamSpec = glib::ParamSpecEnum;
9741 type SetValue = Self;
9742 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
9743
9744 fn param_spec_builder() -> Self::BuilderFn {
9745 Self::ParamSpec::builder_with_default
9746 }
9747}
9748
9749impl glib::value::ValueType for RevealerTransitionType {
9750 type Type = Self;
9751}
9752
9753unsafe impl<'a> glib::value::FromValue<'a> for RevealerTransitionType {
9754 type Checker = glib::value::GenericValueTypeChecker<Self>;
9755
9756 #[inline]
9757 unsafe fn from_value(value: &'a glib::Value) -> Self {
9758 skip_assert_initialized!();
9759 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
9760 }
9761}
9762
9763impl ToValue for RevealerTransitionType {
9764 #[inline]
9765 fn to_value(&self) -> glib::Value {
9766 let mut value = glib::Value::for_value_type::<Self>();
9767 unsafe {
9768 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
9769 }
9770 value
9771 }
9772
9773 #[inline]
9774 fn value_type(&self) -> glib::Type {
9775 Self::static_type()
9776 }
9777}
9778
9779impl From<RevealerTransitionType> for glib::Value {
9780 #[inline]
9781 fn from(v: RevealerTransitionType) -> Self {
9782 skip_assert_initialized!();
9783 ToValue::to_value(&v)
9784 }
9785}
9786
9787#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
9788#[non_exhaustive]
9789#[doc(alias = "GtkScrollStep")]
9790pub enum ScrollStep {
9791 #[doc(alias = "GTK_SCROLL_STEPS")]
9792 Steps,
9793 #[doc(alias = "GTK_SCROLL_PAGES")]
9794 Pages,
9795 #[doc(alias = "GTK_SCROLL_ENDS")]
9796 Ends,
9797 #[doc(alias = "GTK_SCROLL_HORIZONTAL_STEPS")]
9798 HorizontalSteps,
9799 #[doc(alias = "GTK_SCROLL_HORIZONTAL_PAGES")]
9800 HorizontalPages,
9801 #[doc(alias = "GTK_SCROLL_HORIZONTAL_ENDS")]
9802 HorizontalEnds,
9803 #[doc(hidden)]
9804 __Unknown(i32),
9805}
9806
9807#[doc(hidden)]
9808impl IntoGlib for ScrollStep {
9809 type GlibType = ffi::GtkScrollStep;
9810
9811 #[inline]
9812 fn into_glib(self) -> ffi::GtkScrollStep {
9813 match self {
9814 Self::Steps => ffi::GTK_SCROLL_STEPS,
9815 Self::Pages => ffi::GTK_SCROLL_PAGES,
9816 Self::Ends => ffi::GTK_SCROLL_ENDS,
9817 Self::HorizontalSteps => ffi::GTK_SCROLL_HORIZONTAL_STEPS,
9818 Self::HorizontalPages => ffi::GTK_SCROLL_HORIZONTAL_PAGES,
9819 Self::HorizontalEnds => ffi::GTK_SCROLL_HORIZONTAL_ENDS,
9820 Self::__Unknown(value) => value,
9821 }
9822 }
9823}
9824
9825#[doc(hidden)]
9826impl FromGlib<ffi::GtkScrollStep> for ScrollStep {
9827 #[inline]
9828 unsafe fn from_glib(value: ffi::GtkScrollStep) -> Self {
9829 skip_assert_initialized!();
9830
9831 match value {
9832 ffi::GTK_SCROLL_STEPS => Self::Steps,
9833 ffi::GTK_SCROLL_PAGES => Self::Pages,
9834 ffi::GTK_SCROLL_ENDS => Self::Ends,
9835 ffi::GTK_SCROLL_HORIZONTAL_STEPS => Self::HorizontalSteps,
9836 ffi::GTK_SCROLL_HORIZONTAL_PAGES => Self::HorizontalPages,
9837 ffi::GTK_SCROLL_HORIZONTAL_ENDS => Self::HorizontalEnds,
9838 value => Self::__Unknown(value),
9839 }
9840 }
9841}
9842
9843impl StaticType for ScrollStep {
9844 #[inline]
9845 #[doc(alias = "gtk_scroll_step_get_type")]
9846 fn static_type() -> glib::Type {
9847 unsafe { from_glib(ffi::gtk_scroll_step_get_type()) }
9848 }
9849}
9850
9851impl glib::HasParamSpec for ScrollStep {
9852 type ParamSpec = glib::ParamSpecEnum;
9853 type SetValue = Self;
9854 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
9855
9856 fn param_spec_builder() -> Self::BuilderFn {
9857 Self::ParamSpec::builder_with_default
9858 }
9859}
9860
9861impl glib::value::ValueType for ScrollStep {
9862 type Type = Self;
9863}
9864
9865unsafe impl<'a> glib::value::FromValue<'a> for ScrollStep {
9866 type Checker = glib::value::GenericValueTypeChecker<Self>;
9867
9868 #[inline]
9869 unsafe fn from_value(value: &'a glib::Value) -> Self {
9870 skip_assert_initialized!();
9871 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
9872 }
9873}
9874
9875impl ToValue for ScrollStep {
9876 #[inline]
9877 fn to_value(&self) -> glib::Value {
9878 let mut value = glib::Value::for_value_type::<Self>();
9879 unsafe {
9880 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
9881 }
9882 value
9883 }
9884
9885 #[inline]
9886 fn value_type(&self) -> glib::Type {
9887 Self::static_type()
9888 }
9889}
9890
9891impl From<ScrollStep> for glib::Value {
9892 #[inline]
9893 fn from(v: ScrollStep) -> Self {
9894 skip_assert_initialized!();
9895 ToValue::to_value(&v)
9896 }
9897}
9898
9899#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
9900#[non_exhaustive]
9901#[doc(alias = "GtkScrollType")]
9902pub enum ScrollType {
9903 #[doc(alias = "GTK_SCROLL_NONE")]
9904 None,
9905 #[doc(alias = "GTK_SCROLL_JUMP")]
9906 Jump,
9907 #[doc(alias = "GTK_SCROLL_STEP_BACKWARD")]
9908 StepBackward,
9909 #[doc(alias = "GTK_SCROLL_STEP_FORWARD")]
9910 StepForward,
9911 #[doc(alias = "GTK_SCROLL_PAGE_BACKWARD")]
9912 PageBackward,
9913 #[doc(alias = "GTK_SCROLL_PAGE_FORWARD")]
9914 PageForward,
9915 #[doc(alias = "GTK_SCROLL_STEP_UP")]
9916 StepUp,
9917 #[doc(alias = "GTK_SCROLL_STEP_DOWN")]
9918 StepDown,
9919 #[doc(alias = "GTK_SCROLL_PAGE_UP")]
9920 PageUp,
9921 #[doc(alias = "GTK_SCROLL_PAGE_DOWN")]
9922 PageDown,
9923 #[doc(alias = "GTK_SCROLL_STEP_LEFT")]
9924 StepLeft,
9925 #[doc(alias = "GTK_SCROLL_STEP_RIGHT")]
9926 StepRight,
9927 #[doc(alias = "GTK_SCROLL_PAGE_LEFT")]
9928 PageLeft,
9929 #[doc(alias = "GTK_SCROLL_PAGE_RIGHT")]
9930 PageRight,
9931 #[doc(alias = "GTK_SCROLL_START")]
9932 Start,
9933 #[doc(alias = "GTK_SCROLL_END")]
9934 End,
9935 #[doc(hidden)]
9936 __Unknown(i32),
9937}
9938
9939#[doc(hidden)]
9940impl IntoGlib for ScrollType {
9941 type GlibType = ffi::GtkScrollType;
9942
9943 fn into_glib(self) -> ffi::GtkScrollType {
9944 match self {
9945 Self::None => ffi::GTK_SCROLL_NONE,
9946 Self::Jump => ffi::GTK_SCROLL_JUMP,
9947 Self::StepBackward => ffi::GTK_SCROLL_STEP_BACKWARD,
9948 Self::StepForward => ffi::GTK_SCROLL_STEP_FORWARD,
9949 Self::PageBackward => ffi::GTK_SCROLL_PAGE_BACKWARD,
9950 Self::PageForward => ffi::GTK_SCROLL_PAGE_FORWARD,
9951 Self::StepUp => ffi::GTK_SCROLL_STEP_UP,
9952 Self::StepDown => ffi::GTK_SCROLL_STEP_DOWN,
9953 Self::PageUp => ffi::GTK_SCROLL_PAGE_UP,
9954 Self::PageDown => ffi::GTK_SCROLL_PAGE_DOWN,
9955 Self::StepLeft => ffi::GTK_SCROLL_STEP_LEFT,
9956 Self::StepRight => ffi::GTK_SCROLL_STEP_RIGHT,
9957 Self::PageLeft => ffi::GTK_SCROLL_PAGE_LEFT,
9958 Self::PageRight => ffi::GTK_SCROLL_PAGE_RIGHT,
9959 Self::Start => ffi::GTK_SCROLL_START,
9960 Self::End => ffi::GTK_SCROLL_END,
9961 Self::__Unknown(value) => value,
9962 }
9963 }
9964}
9965
9966#[doc(hidden)]
9967impl FromGlib<ffi::GtkScrollType> for ScrollType {
9968 unsafe fn from_glib(value: ffi::GtkScrollType) -> Self {
9969 skip_assert_initialized!();
9970
9971 match value {
9972 ffi::GTK_SCROLL_NONE => Self::None,
9973 ffi::GTK_SCROLL_JUMP => Self::Jump,
9974 ffi::GTK_SCROLL_STEP_BACKWARD => Self::StepBackward,
9975 ffi::GTK_SCROLL_STEP_FORWARD => Self::StepForward,
9976 ffi::GTK_SCROLL_PAGE_BACKWARD => Self::PageBackward,
9977 ffi::GTK_SCROLL_PAGE_FORWARD => Self::PageForward,
9978 ffi::GTK_SCROLL_STEP_UP => Self::StepUp,
9979 ffi::GTK_SCROLL_STEP_DOWN => Self::StepDown,
9980 ffi::GTK_SCROLL_PAGE_UP => Self::PageUp,
9981 ffi::GTK_SCROLL_PAGE_DOWN => Self::PageDown,
9982 ffi::GTK_SCROLL_STEP_LEFT => Self::StepLeft,
9983 ffi::GTK_SCROLL_STEP_RIGHT => Self::StepRight,
9984 ffi::GTK_SCROLL_PAGE_LEFT => Self::PageLeft,
9985 ffi::GTK_SCROLL_PAGE_RIGHT => Self::PageRight,
9986 ffi::GTK_SCROLL_START => Self::Start,
9987 ffi::GTK_SCROLL_END => Self::End,
9988 value => Self::__Unknown(value),
9989 }
9990 }
9991}
9992
9993impl StaticType for ScrollType {
9994 #[inline]
9995 #[doc(alias = "gtk_scroll_type_get_type")]
9996 fn static_type() -> glib::Type {
9997 unsafe { from_glib(ffi::gtk_scroll_type_get_type()) }
9998 }
9999}
10000
10001impl glib::HasParamSpec for ScrollType {
10002 type ParamSpec = glib::ParamSpecEnum;
10003 type SetValue = Self;
10004 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
10005
10006 fn param_spec_builder() -> Self::BuilderFn {
10007 Self::ParamSpec::builder_with_default
10008 }
10009}
10010
10011impl glib::value::ValueType for ScrollType {
10012 type Type = Self;
10013}
10014
10015unsafe impl<'a> glib::value::FromValue<'a> for ScrollType {
10016 type Checker = glib::value::GenericValueTypeChecker<Self>;
10017
10018 #[inline]
10019 unsafe fn from_value(value: &'a glib::Value) -> Self {
10020 skip_assert_initialized!();
10021 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
10022 }
10023}
10024
10025impl ToValue for ScrollType {
10026 #[inline]
10027 fn to_value(&self) -> glib::Value {
10028 let mut value = glib::Value::for_value_type::<Self>();
10029 unsafe {
10030 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
10031 }
10032 value
10033 }
10034
10035 #[inline]
10036 fn value_type(&self) -> glib::Type {
10037 Self::static_type()
10038 }
10039}
10040
10041impl From<ScrollType> for glib::Value {
10042 #[inline]
10043 fn from(v: ScrollType) -> Self {
10044 skip_assert_initialized!();
10045 ToValue::to_value(&v)
10046 }
10047}
10048
10049#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
10050#[non_exhaustive]
10051#[doc(alias = "GtkScrollablePolicy")]
10052pub enum ScrollablePolicy {
10053 #[doc(alias = "GTK_SCROLL_MINIMUM")]
10054 Minimum,
10055 #[doc(alias = "GTK_SCROLL_NATURAL")]
10056 Natural,
10057 #[doc(hidden)]
10058 __Unknown(i32),
10059}
10060
10061#[doc(hidden)]
10062impl IntoGlib for ScrollablePolicy {
10063 type GlibType = ffi::GtkScrollablePolicy;
10064
10065 #[inline]
10066 fn into_glib(self) -> ffi::GtkScrollablePolicy {
10067 match self {
10068 Self::Minimum => ffi::GTK_SCROLL_MINIMUM,
10069 Self::Natural => ffi::GTK_SCROLL_NATURAL,
10070 Self::__Unknown(value) => value,
10071 }
10072 }
10073}
10074
10075#[doc(hidden)]
10076impl FromGlib<ffi::GtkScrollablePolicy> for ScrollablePolicy {
10077 #[inline]
10078 unsafe fn from_glib(value: ffi::GtkScrollablePolicy) -> Self {
10079 skip_assert_initialized!();
10080
10081 match value {
10082 ffi::GTK_SCROLL_MINIMUM => Self::Minimum,
10083 ffi::GTK_SCROLL_NATURAL => Self::Natural,
10084 value => Self::__Unknown(value),
10085 }
10086 }
10087}
10088
10089impl StaticType for ScrollablePolicy {
10090 #[inline]
10091 #[doc(alias = "gtk_scrollable_policy_get_type")]
10092 fn static_type() -> glib::Type {
10093 unsafe { from_glib(ffi::gtk_scrollable_policy_get_type()) }
10094 }
10095}
10096
10097impl glib::HasParamSpec for ScrollablePolicy {
10098 type ParamSpec = glib::ParamSpecEnum;
10099 type SetValue = Self;
10100 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
10101
10102 fn param_spec_builder() -> Self::BuilderFn {
10103 Self::ParamSpec::builder_with_default
10104 }
10105}
10106
10107impl glib::value::ValueType for ScrollablePolicy {
10108 type Type = Self;
10109}
10110
10111unsafe impl<'a> glib::value::FromValue<'a> for ScrollablePolicy {
10112 type Checker = glib::value::GenericValueTypeChecker<Self>;
10113
10114 #[inline]
10115 unsafe fn from_value(value: &'a glib::Value) -> Self {
10116 skip_assert_initialized!();
10117 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
10118 }
10119}
10120
10121impl ToValue for ScrollablePolicy {
10122 #[inline]
10123 fn to_value(&self) -> glib::Value {
10124 let mut value = glib::Value::for_value_type::<Self>();
10125 unsafe {
10126 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
10127 }
10128 value
10129 }
10130
10131 #[inline]
10132 fn value_type(&self) -> glib::Type {
10133 Self::static_type()
10134 }
10135}
10136
10137impl From<ScrollablePolicy> for glib::Value {
10138 #[inline]
10139 fn from(v: ScrollablePolicy) -> Self {
10140 skip_assert_initialized!();
10141 ToValue::to_value(&v)
10142 }
10143}
10144
10145#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
10146#[non_exhaustive]
10147#[doc(alias = "GtkSelectionMode")]
10148pub enum SelectionMode {
10149 #[doc(alias = "GTK_SELECTION_NONE")]
10150 None,
10151 #[doc(alias = "GTK_SELECTION_SINGLE")]
10152 Single,
10153 #[doc(alias = "GTK_SELECTION_BROWSE")]
10154 Browse,
10155 #[doc(alias = "GTK_SELECTION_MULTIPLE")]
10156 Multiple,
10157 #[doc(hidden)]
10158 __Unknown(i32),
10159}
10160
10161#[doc(hidden)]
10162impl IntoGlib for SelectionMode {
10163 type GlibType = ffi::GtkSelectionMode;
10164
10165 #[inline]
10166 fn into_glib(self) -> ffi::GtkSelectionMode {
10167 match self {
10168 Self::None => ffi::GTK_SELECTION_NONE,
10169 Self::Single => ffi::GTK_SELECTION_SINGLE,
10170 Self::Browse => ffi::GTK_SELECTION_BROWSE,
10171 Self::Multiple => ffi::GTK_SELECTION_MULTIPLE,
10172 Self::__Unknown(value) => value,
10173 }
10174 }
10175}
10176
10177#[doc(hidden)]
10178impl FromGlib<ffi::GtkSelectionMode> for SelectionMode {
10179 #[inline]
10180 unsafe fn from_glib(value: ffi::GtkSelectionMode) -> Self {
10181 skip_assert_initialized!();
10182
10183 match value {
10184 ffi::GTK_SELECTION_NONE => Self::None,
10185 ffi::GTK_SELECTION_SINGLE => Self::Single,
10186 ffi::GTK_SELECTION_BROWSE => Self::Browse,
10187 ffi::GTK_SELECTION_MULTIPLE => Self::Multiple,
10188 value => Self::__Unknown(value),
10189 }
10190 }
10191}
10192
10193impl StaticType for SelectionMode {
10194 #[inline]
10195 #[doc(alias = "gtk_selection_mode_get_type")]
10196 fn static_type() -> glib::Type {
10197 unsafe { from_glib(ffi::gtk_selection_mode_get_type()) }
10198 }
10199}
10200
10201impl glib::HasParamSpec for SelectionMode {
10202 type ParamSpec = glib::ParamSpecEnum;
10203 type SetValue = Self;
10204 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
10205
10206 fn param_spec_builder() -> Self::BuilderFn {
10207 Self::ParamSpec::builder_with_default
10208 }
10209}
10210
10211impl glib::value::ValueType for SelectionMode {
10212 type Type = Self;
10213}
10214
10215unsafe impl<'a> glib::value::FromValue<'a> for SelectionMode {
10216 type Checker = glib::value::GenericValueTypeChecker<Self>;
10217
10218 #[inline]
10219 unsafe fn from_value(value: &'a glib::Value) -> Self {
10220 skip_assert_initialized!();
10221 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
10222 }
10223}
10224
10225impl ToValue for SelectionMode {
10226 #[inline]
10227 fn to_value(&self) -> glib::Value {
10228 let mut value = glib::Value::for_value_type::<Self>();
10229 unsafe {
10230 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
10231 }
10232 value
10233 }
10234
10235 #[inline]
10236 fn value_type(&self) -> glib::Type {
10237 Self::static_type()
10238 }
10239}
10240
10241impl From<SelectionMode> for glib::Value {
10242 #[inline]
10243 fn from(v: SelectionMode) -> Self {
10244 skip_assert_initialized!();
10245 ToValue::to_value(&v)
10246 }
10247}
10248
10249#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
10250#[non_exhaustive]
10251#[doc(alias = "GtkSensitivityType")]
10252pub enum SensitivityType {
10253 #[doc(alias = "GTK_SENSITIVITY_AUTO")]
10254 Auto,
10255 #[doc(alias = "GTK_SENSITIVITY_ON")]
10256 On,
10257 #[doc(alias = "GTK_SENSITIVITY_OFF")]
10258 Off,
10259 #[doc(hidden)]
10260 __Unknown(i32),
10261}
10262
10263#[doc(hidden)]
10264impl IntoGlib for SensitivityType {
10265 type GlibType = ffi::GtkSensitivityType;
10266
10267 #[inline]
10268 fn into_glib(self) -> ffi::GtkSensitivityType {
10269 match self {
10270 Self::Auto => ffi::GTK_SENSITIVITY_AUTO,
10271 Self::On => ffi::GTK_SENSITIVITY_ON,
10272 Self::Off => ffi::GTK_SENSITIVITY_OFF,
10273 Self::__Unknown(value) => value,
10274 }
10275 }
10276}
10277
10278#[doc(hidden)]
10279impl FromGlib<ffi::GtkSensitivityType> for SensitivityType {
10280 #[inline]
10281 unsafe fn from_glib(value: ffi::GtkSensitivityType) -> Self {
10282 skip_assert_initialized!();
10283
10284 match value {
10285 ffi::GTK_SENSITIVITY_AUTO => Self::Auto,
10286 ffi::GTK_SENSITIVITY_ON => Self::On,
10287 ffi::GTK_SENSITIVITY_OFF => Self::Off,
10288 value => Self::__Unknown(value),
10289 }
10290 }
10291}
10292
10293impl StaticType for SensitivityType {
10294 #[inline]
10295 #[doc(alias = "gtk_sensitivity_type_get_type")]
10296 fn static_type() -> glib::Type {
10297 unsafe { from_glib(ffi::gtk_sensitivity_type_get_type()) }
10298 }
10299}
10300
10301impl glib::HasParamSpec for SensitivityType {
10302 type ParamSpec = glib::ParamSpecEnum;
10303 type SetValue = Self;
10304 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
10305
10306 fn param_spec_builder() -> Self::BuilderFn {
10307 Self::ParamSpec::builder_with_default
10308 }
10309}
10310
10311impl glib::value::ValueType for SensitivityType {
10312 type Type = Self;
10313}
10314
10315unsafe impl<'a> glib::value::FromValue<'a> for SensitivityType {
10316 type Checker = glib::value::GenericValueTypeChecker<Self>;
10317
10318 #[inline]
10319 unsafe fn from_value(value: &'a glib::Value) -> Self {
10320 skip_assert_initialized!();
10321 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
10322 }
10323}
10324
10325impl ToValue for SensitivityType {
10326 #[inline]
10327 fn to_value(&self) -> glib::Value {
10328 let mut value = glib::Value::for_value_type::<Self>();
10329 unsafe {
10330 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
10331 }
10332 value
10333 }
10334
10335 #[inline]
10336 fn value_type(&self) -> glib::Type {
10337 Self::static_type()
10338 }
10339}
10340
10341impl From<SensitivityType> for glib::Value {
10342 #[inline]
10343 fn from(v: SensitivityType) -> Self {
10344 skip_assert_initialized!();
10345 ToValue::to_value(&v)
10346 }
10347}
10348
10349#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
10350#[non_exhaustive]
10351#[doc(alias = "GtkShortcutScope")]
10352pub enum ShortcutScope {
10353 #[doc(alias = "GTK_SHORTCUT_SCOPE_LOCAL")]
10354 Local,
10355 #[doc(alias = "GTK_SHORTCUT_SCOPE_MANAGED")]
10356 Managed,
10357 #[doc(alias = "GTK_SHORTCUT_SCOPE_GLOBAL")]
10358 Global,
10359 #[doc(hidden)]
10360 __Unknown(i32),
10361}
10362
10363#[doc(hidden)]
10364impl IntoGlib for ShortcutScope {
10365 type GlibType = ffi::GtkShortcutScope;
10366
10367 #[inline]
10368 fn into_glib(self) -> ffi::GtkShortcutScope {
10369 match self {
10370 Self::Local => ffi::GTK_SHORTCUT_SCOPE_LOCAL,
10371 Self::Managed => ffi::GTK_SHORTCUT_SCOPE_MANAGED,
10372 Self::Global => ffi::GTK_SHORTCUT_SCOPE_GLOBAL,
10373 Self::__Unknown(value) => value,
10374 }
10375 }
10376}
10377
10378#[doc(hidden)]
10379impl FromGlib<ffi::GtkShortcutScope> for ShortcutScope {
10380 #[inline]
10381 unsafe fn from_glib(value: ffi::GtkShortcutScope) -> Self {
10382 skip_assert_initialized!();
10383
10384 match value {
10385 ffi::GTK_SHORTCUT_SCOPE_LOCAL => Self::Local,
10386 ffi::GTK_SHORTCUT_SCOPE_MANAGED => Self::Managed,
10387 ffi::GTK_SHORTCUT_SCOPE_GLOBAL => Self::Global,
10388 value => Self::__Unknown(value),
10389 }
10390 }
10391}
10392
10393impl StaticType for ShortcutScope {
10394 #[inline]
10395 #[doc(alias = "gtk_shortcut_scope_get_type")]
10396 fn static_type() -> glib::Type {
10397 unsafe { from_glib(ffi::gtk_shortcut_scope_get_type()) }
10398 }
10399}
10400
10401impl glib::HasParamSpec for ShortcutScope {
10402 type ParamSpec = glib::ParamSpecEnum;
10403 type SetValue = Self;
10404 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
10405
10406 fn param_spec_builder() -> Self::BuilderFn {
10407 Self::ParamSpec::builder_with_default
10408 }
10409}
10410
10411impl glib::value::ValueType for ShortcutScope {
10412 type Type = Self;
10413}
10414
10415unsafe impl<'a> glib::value::FromValue<'a> for ShortcutScope {
10416 type Checker = glib::value::GenericValueTypeChecker<Self>;
10417
10418 #[inline]
10419 unsafe fn from_value(value: &'a glib::Value) -> Self {
10420 skip_assert_initialized!();
10421 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
10422 }
10423}
10424
10425impl ToValue for ShortcutScope {
10426 #[inline]
10427 fn to_value(&self) -> glib::Value {
10428 let mut value = glib::Value::for_value_type::<Self>();
10429 unsafe {
10430 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
10431 }
10432 value
10433 }
10434
10435 #[inline]
10436 fn value_type(&self) -> glib::Type {
10437 Self::static_type()
10438 }
10439}
10440
10441impl From<ShortcutScope> for glib::Value {
10442 #[inline]
10443 fn from(v: ShortcutScope) -> Self {
10444 skip_assert_initialized!();
10445 ToValue::to_value(&v)
10446 }
10447}
10448
10449#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
10450#[non_exhaustive]
10451#[doc(alias = "GtkShortcutType")]
10452pub enum ShortcutType {
10453 #[doc(alias = "GTK_SHORTCUT_ACCELERATOR")]
10454 Accelerator,
10455 #[doc(alias = "GTK_SHORTCUT_GESTURE_PINCH")]
10456 GesturePinch,
10457 #[doc(alias = "GTK_SHORTCUT_GESTURE_STRETCH")]
10458 GestureStretch,
10459 #[doc(alias = "GTK_SHORTCUT_GESTURE_ROTATE_CLOCKWISE")]
10460 GestureRotateClockwise,
10461 #[doc(alias = "GTK_SHORTCUT_GESTURE_ROTATE_COUNTERCLOCKWISE")]
10462 GestureRotateCounterclockwise,
10463 #[doc(alias = "GTK_SHORTCUT_GESTURE_TWO_FINGER_SWIPE_LEFT")]
10464 GestureTwoFingerSwipeLeft,
10465 #[doc(alias = "GTK_SHORTCUT_GESTURE_TWO_FINGER_SWIPE_RIGHT")]
10466 GestureTwoFingerSwipeRight,
10467 #[doc(alias = "GTK_SHORTCUT_GESTURE")]
10468 Gesture,
10469 #[doc(alias = "GTK_SHORTCUT_GESTURE_SWIPE_LEFT")]
10470 GestureSwipeLeft,
10471 #[doc(alias = "GTK_SHORTCUT_GESTURE_SWIPE_RIGHT")]
10472 GestureSwipeRight,
10473 #[doc(hidden)]
10474 __Unknown(i32),
10475}
10476
10477#[doc(hidden)]
10478impl IntoGlib for ShortcutType {
10479 type GlibType = ffi::GtkShortcutType;
10480
10481 #[inline]
10482 fn into_glib(self) -> ffi::GtkShortcutType {
10483 match self {
10484 Self::Accelerator => ffi::GTK_SHORTCUT_ACCELERATOR,
10485 Self::GesturePinch => ffi::GTK_SHORTCUT_GESTURE_PINCH,
10486 Self::GestureStretch => ffi::GTK_SHORTCUT_GESTURE_STRETCH,
10487 Self::GestureRotateClockwise => ffi::GTK_SHORTCUT_GESTURE_ROTATE_CLOCKWISE,
10488 Self::GestureRotateCounterclockwise => {
10489 ffi::GTK_SHORTCUT_GESTURE_ROTATE_COUNTERCLOCKWISE
10490 }
10491 Self::GestureTwoFingerSwipeLeft => ffi::GTK_SHORTCUT_GESTURE_TWO_FINGER_SWIPE_LEFT,
10492 Self::GestureTwoFingerSwipeRight => ffi::GTK_SHORTCUT_GESTURE_TWO_FINGER_SWIPE_RIGHT,
10493 Self::Gesture => ffi::GTK_SHORTCUT_GESTURE,
10494 Self::GestureSwipeLeft => ffi::GTK_SHORTCUT_GESTURE_SWIPE_LEFT,
10495 Self::GestureSwipeRight => ffi::GTK_SHORTCUT_GESTURE_SWIPE_RIGHT,
10496 Self::__Unknown(value) => value,
10497 }
10498 }
10499}
10500
10501#[doc(hidden)]
10502impl FromGlib<ffi::GtkShortcutType> for ShortcutType {
10503 #[inline]
10504 unsafe fn from_glib(value: ffi::GtkShortcutType) -> Self {
10505 skip_assert_initialized!();
10506
10507 match value {
10508 ffi::GTK_SHORTCUT_ACCELERATOR => Self::Accelerator,
10509 ffi::GTK_SHORTCUT_GESTURE_PINCH => Self::GesturePinch,
10510 ffi::GTK_SHORTCUT_GESTURE_STRETCH => Self::GestureStretch,
10511 ffi::GTK_SHORTCUT_GESTURE_ROTATE_CLOCKWISE => Self::GestureRotateClockwise,
10512 ffi::GTK_SHORTCUT_GESTURE_ROTATE_COUNTERCLOCKWISE => {
10513 Self::GestureRotateCounterclockwise
10514 }
10515 ffi::GTK_SHORTCUT_GESTURE_TWO_FINGER_SWIPE_LEFT => Self::GestureTwoFingerSwipeLeft,
10516 ffi::GTK_SHORTCUT_GESTURE_TWO_FINGER_SWIPE_RIGHT => Self::GestureTwoFingerSwipeRight,
10517 ffi::GTK_SHORTCUT_GESTURE => Self::Gesture,
10518 ffi::GTK_SHORTCUT_GESTURE_SWIPE_LEFT => Self::GestureSwipeLeft,
10519 ffi::GTK_SHORTCUT_GESTURE_SWIPE_RIGHT => Self::GestureSwipeRight,
10520 value => Self::__Unknown(value),
10521 }
10522 }
10523}
10524
10525impl StaticType for ShortcutType {
10526 #[inline]
10527 #[doc(alias = "gtk_shortcut_type_get_type")]
10528 fn static_type() -> glib::Type {
10529 unsafe { from_glib(ffi::gtk_shortcut_type_get_type()) }
10530 }
10531}
10532
10533impl glib::HasParamSpec for ShortcutType {
10534 type ParamSpec = glib::ParamSpecEnum;
10535 type SetValue = Self;
10536 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
10537
10538 fn param_spec_builder() -> Self::BuilderFn {
10539 Self::ParamSpec::builder_with_default
10540 }
10541}
10542
10543impl glib::value::ValueType for ShortcutType {
10544 type Type = Self;
10545}
10546
10547unsafe impl<'a> glib::value::FromValue<'a> for ShortcutType {
10548 type Checker = glib::value::GenericValueTypeChecker<Self>;
10549
10550 #[inline]
10551 unsafe fn from_value(value: &'a glib::Value) -> Self {
10552 skip_assert_initialized!();
10553 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
10554 }
10555}
10556
10557impl ToValue for ShortcutType {
10558 #[inline]
10559 fn to_value(&self) -> glib::Value {
10560 let mut value = glib::Value::for_value_type::<Self>();
10561 unsafe {
10562 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
10563 }
10564 value
10565 }
10566
10567 #[inline]
10568 fn value_type(&self) -> glib::Type {
10569 Self::static_type()
10570 }
10571}
10572
10573impl From<ShortcutType> for glib::Value {
10574 #[inline]
10575 fn from(v: ShortcutType) -> Self {
10576 skip_assert_initialized!();
10577 ToValue::to_value(&v)
10578 }
10579}
10580
10581#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
10582#[non_exhaustive]
10583#[doc(alias = "GtkSizeGroupMode")]
10584pub enum SizeGroupMode {
10585 #[doc(alias = "GTK_SIZE_GROUP_NONE")]
10586 None,
10587 #[doc(alias = "GTK_SIZE_GROUP_HORIZONTAL")]
10588 Horizontal,
10589 #[doc(alias = "GTK_SIZE_GROUP_VERTICAL")]
10590 Vertical,
10591 #[doc(alias = "GTK_SIZE_GROUP_BOTH")]
10592 Both,
10593 #[doc(hidden)]
10594 __Unknown(i32),
10595}
10596
10597#[doc(hidden)]
10598impl IntoGlib for SizeGroupMode {
10599 type GlibType = ffi::GtkSizeGroupMode;
10600
10601 #[inline]
10602 fn into_glib(self) -> ffi::GtkSizeGroupMode {
10603 match self {
10604 Self::None => ffi::GTK_SIZE_GROUP_NONE,
10605 Self::Horizontal => ffi::GTK_SIZE_GROUP_HORIZONTAL,
10606 Self::Vertical => ffi::GTK_SIZE_GROUP_VERTICAL,
10607 Self::Both => ffi::GTK_SIZE_GROUP_BOTH,
10608 Self::__Unknown(value) => value,
10609 }
10610 }
10611}
10612
10613#[doc(hidden)]
10614impl FromGlib<ffi::GtkSizeGroupMode> for SizeGroupMode {
10615 #[inline]
10616 unsafe fn from_glib(value: ffi::GtkSizeGroupMode) -> Self {
10617 skip_assert_initialized!();
10618
10619 match value {
10620 ffi::GTK_SIZE_GROUP_NONE => Self::None,
10621 ffi::GTK_SIZE_GROUP_HORIZONTAL => Self::Horizontal,
10622 ffi::GTK_SIZE_GROUP_VERTICAL => Self::Vertical,
10623 ffi::GTK_SIZE_GROUP_BOTH => Self::Both,
10624 value => Self::__Unknown(value),
10625 }
10626 }
10627}
10628
10629impl StaticType for SizeGroupMode {
10630 #[inline]
10631 #[doc(alias = "gtk_size_group_mode_get_type")]
10632 fn static_type() -> glib::Type {
10633 unsafe { from_glib(ffi::gtk_size_group_mode_get_type()) }
10634 }
10635}
10636
10637impl glib::HasParamSpec for SizeGroupMode {
10638 type ParamSpec = glib::ParamSpecEnum;
10639 type SetValue = Self;
10640 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
10641
10642 fn param_spec_builder() -> Self::BuilderFn {
10643 Self::ParamSpec::builder_with_default
10644 }
10645}
10646
10647impl glib::value::ValueType for SizeGroupMode {
10648 type Type = Self;
10649}
10650
10651unsafe impl<'a> glib::value::FromValue<'a> for SizeGroupMode {
10652 type Checker = glib::value::GenericValueTypeChecker<Self>;
10653
10654 #[inline]
10655 unsafe fn from_value(value: &'a glib::Value) -> Self {
10656 skip_assert_initialized!();
10657 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
10658 }
10659}
10660
10661impl ToValue for SizeGroupMode {
10662 #[inline]
10663 fn to_value(&self) -> glib::Value {
10664 let mut value = glib::Value::for_value_type::<Self>();
10665 unsafe {
10666 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
10667 }
10668 value
10669 }
10670
10671 #[inline]
10672 fn value_type(&self) -> glib::Type {
10673 Self::static_type()
10674 }
10675}
10676
10677impl From<SizeGroupMode> for glib::Value {
10678 #[inline]
10679 fn from(v: SizeGroupMode) -> Self {
10680 skip_assert_initialized!();
10681 ToValue::to_value(&v)
10682 }
10683}
10684
10685#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
10686#[non_exhaustive]
10687#[doc(alias = "GtkSizeRequestMode")]
10688pub enum SizeRequestMode {
10689 #[doc(alias = "GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH")]
10690 HeightForWidth,
10691 #[doc(alias = "GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT")]
10692 WidthForHeight,
10693 #[doc(alias = "GTK_SIZE_REQUEST_CONSTANT_SIZE")]
10694 ConstantSize,
10695 #[doc(hidden)]
10696 __Unknown(i32),
10697}
10698
10699#[doc(hidden)]
10700impl IntoGlib for SizeRequestMode {
10701 type GlibType = ffi::GtkSizeRequestMode;
10702
10703 #[inline]
10704 fn into_glib(self) -> ffi::GtkSizeRequestMode {
10705 match self {
10706 Self::HeightForWidth => ffi::GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH,
10707 Self::WidthForHeight => ffi::GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT,
10708 Self::ConstantSize => ffi::GTK_SIZE_REQUEST_CONSTANT_SIZE,
10709 Self::__Unknown(value) => value,
10710 }
10711 }
10712}
10713
10714#[doc(hidden)]
10715impl FromGlib<ffi::GtkSizeRequestMode> for SizeRequestMode {
10716 #[inline]
10717 unsafe fn from_glib(value: ffi::GtkSizeRequestMode) -> Self {
10718 skip_assert_initialized!();
10719
10720 match value {
10721 ffi::GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH => Self::HeightForWidth,
10722 ffi::GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT => Self::WidthForHeight,
10723 ffi::GTK_SIZE_REQUEST_CONSTANT_SIZE => Self::ConstantSize,
10724 value => Self::__Unknown(value),
10725 }
10726 }
10727}
10728
10729impl StaticType for SizeRequestMode {
10730 #[inline]
10731 #[doc(alias = "gtk_size_request_mode_get_type")]
10732 fn static_type() -> glib::Type {
10733 unsafe { from_glib(ffi::gtk_size_request_mode_get_type()) }
10734 }
10735}
10736
10737impl glib::HasParamSpec for SizeRequestMode {
10738 type ParamSpec = glib::ParamSpecEnum;
10739 type SetValue = Self;
10740 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
10741
10742 fn param_spec_builder() -> Self::BuilderFn {
10743 Self::ParamSpec::builder_with_default
10744 }
10745}
10746
10747impl glib::value::ValueType for SizeRequestMode {
10748 type Type = Self;
10749}
10750
10751unsafe impl<'a> glib::value::FromValue<'a> for SizeRequestMode {
10752 type Checker = glib::value::GenericValueTypeChecker<Self>;
10753
10754 #[inline]
10755 unsafe fn from_value(value: &'a glib::Value) -> Self {
10756 skip_assert_initialized!();
10757 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
10758 }
10759}
10760
10761impl ToValue for SizeRequestMode {
10762 #[inline]
10763 fn to_value(&self) -> glib::Value {
10764 let mut value = glib::Value::for_value_type::<Self>();
10765 unsafe {
10766 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
10767 }
10768 value
10769 }
10770
10771 #[inline]
10772 fn value_type(&self) -> glib::Type {
10773 Self::static_type()
10774 }
10775}
10776
10777impl From<SizeRequestMode> for glib::Value {
10778 #[inline]
10779 fn from(v: SizeRequestMode) -> Self {
10780 skip_assert_initialized!();
10781 ToValue::to_value(&v)
10782 }
10783}
10784
10785#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
10786#[non_exhaustive]
10787#[doc(alias = "GtkSortType")]
10788pub enum SortType {
10789 #[doc(alias = "GTK_SORT_ASCENDING")]
10790 Ascending,
10791 #[doc(alias = "GTK_SORT_DESCENDING")]
10792 Descending,
10793 #[doc(hidden)]
10794 __Unknown(i32),
10795}
10796
10797#[doc(hidden)]
10798impl IntoGlib for SortType {
10799 type GlibType = ffi::GtkSortType;
10800
10801 #[inline]
10802 fn into_glib(self) -> ffi::GtkSortType {
10803 match self {
10804 Self::Ascending => ffi::GTK_SORT_ASCENDING,
10805 Self::Descending => ffi::GTK_SORT_DESCENDING,
10806 Self::__Unknown(value) => value,
10807 }
10808 }
10809}
10810
10811#[doc(hidden)]
10812impl FromGlib<ffi::GtkSortType> for SortType {
10813 #[inline]
10814 unsafe fn from_glib(value: ffi::GtkSortType) -> Self {
10815 skip_assert_initialized!();
10816
10817 match value {
10818 ffi::GTK_SORT_ASCENDING => Self::Ascending,
10819 ffi::GTK_SORT_DESCENDING => Self::Descending,
10820 value => Self::__Unknown(value),
10821 }
10822 }
10823}
10824
10825impl StaticType for SortType {
10826 #[inline]
10827 #[doc(alias = "gtk_sort_type_get_type")]
10828 fn static_type() -> glib::Type {
10829 unsafe { from_glib(ffi::gtk_sort_type_get_type()) }
10830 }
10831}
10832
10833impl glib::HasParamSpec for SortType {
10834 type ParamSpec = glib::ParamSpecEnum;
10835 type SetValue = Self;
10836 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
10837
10838 fn param_spec_builder() -> Self::BuilderFn {
10839 Self::ParamSpec::builder_with_default
10840 }
10841}
10842
10843impl glib::value::ValueType for SortType {
10844 type Type = Self;
10845}
10846
10847unsafe impl<'a> glib::value::FromValue<'a> for SortType {
10848 type Checker = glib::value::GenericValueTypeChecker<Self>;
10849
10850 #[inline]
10851 unsafe fn from_value(value: &'a glib::Value) -> Self {
10852 skip_assert_initialized!();
10853 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
10854 }
10855}
10856
10857impl ToValue for SortType {
10858 #[inline]
10859 fn to_value(&self) -> glib::Value {
10860 let mut value = glib::Value::for_value_type::<Self>();
10861 unsafe {
10862 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
10863 }
10864 value
10865 }
10866
10867 #[inline]
10868 fn value_type(&self) -> glib::Type {
10869 Self::static_type()
10870 }
10871}
10872
10873impl From<SortType> for glib::Value {
10874 #[inline]
10875 fn from(v: SortType) -> Self {
10876 skip_assert_initialized!();
10877 ToValue::to_value(&v)
10878 }
10879}
10880
10881#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
10882#[non_exhaustive]
10883#[doc(alias = "GtkSorterChange")]
10884pub enum SorterChange {
10885 #[doc(alias = "GTK_SORTER_CHANGE_DIFFERENT")]
10886 Different,
10887 #[doc(alias = "GTK_SORTER_CHANGE_INVERTED")]
10888 Inverted,
10889 #[doc(alias = "GTK_SORTER_CHANGE_LESS_STRICT")]
10890 LessStrict,
10891 #[doc(alias = "GTK_SORTER_CHANGE_MORE_STRICT")]
10892 MoreStrict,
10893 #[doc(hidden)]
10894 __Unknown(i32),
10895}
10896
10897#[doc(hidden)]
10898impl IntoGlib for SorterChange {
10899 type GlibType = ffi::GtkSorterChange;
10900
10901 #[inline]
10902 fn into_glib(self) -> ffi::GtkSorterChange {
10903 match self {
10904 Self::Different => ffi::GTK_SORTER_CHANGE_DIFFERENT,
10905 Self::Inverted => ffi::GTK_SORTER_CHANGE_INVERTED,
10906 Self::LessStrict => ffi::GTK_SORTER_CHANGE_LESS_STRICT,
10907 Self::MoreStrict => ffi::GTK_SORTER_CHANGE_MORE_STRICT,
10908 Self::__Unknown(value) => value,
10909 }
10910 }
10911}
10912
10913#[doc(hidden)]
10914impl FromGlib<ffi::GtkSorterChange> for SorterChange {
10915 #[inline]
10916 unsafe fn from_glib(value: ffi::GtkSorterChange) -> Self {
10917 skip_assert_initialized!();
10918
10919 match value {
10920 ffi::GTK_SORTER_CHANGE_DIFFERENT => Self::Different,
10921 ffi::GTK_SORTER_CHANGE_INVERTED => Self::Inverted,
10922 ffi::GTK_SORTER_CHANGE_LESS_STRICT => Self::LessStrict,
10923 ffi::GTK_SORTER_CHANGE_MORE_STRICT => Self::MoreStrict,
10924 value => Self::__Unknown(value),
10925 }
10926 }
10927}
10928
10929impl StaticType for SorterChange {
10930 #[inline]
10931 #[doc(alias = "gtk_sorter_change_get_type")]
10932 fn static_type() -> glib::Type {
10933 unsafe { from_glib(ffi::gtk_sorter_change_get_type()) }
10934 }
10935}
10936
10937impl glib::HasParamSpec for SorterChange {
10938 type ParamSpec = glib::ParamSpecEnum;
10939 type SetValue = Self;
10940 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
10941
10942 fn param_spec_builder() -> Self::BuilderFn {
10943 Self::ParamSpec::builder_with_default
10944 }
10945}
10946
10947impl glib::value::ValueType for SorterChange {
10948 type Type = Self;
10949}
10950
10951unsafe impl<'a> glib::value::FromValue<'a> for SorterChange {
10952 type Checker = glib::value::GenericValueTypeChecker<Self>;
10953
10954 #[inline]
10955 unsafe fn from_value(value: &'a glib::Value) -> Self {
10956 skip_assert_initialized!();
10957 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
10958 }
10959}
10960
10961impl ToValue for SorterChange {
10962 #[inline]
10963 fn to_value(&self) -> glib::Value {
10964 let mut value = glib::Value::for_value_type::<Self>();
10965 unsafe {
10966 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
10967 }
10968 value
10969 }
10970
10971 #[inline]
10972 fn value_type(&self) -> glib::Type {
10973 Self::static_type()
10974 }
10975}
10976
10977impl From<SorterChange> for glib::Value {
10978 #[inline]
10979 fn from(v: SorterChange) -> Self {
10980 skip_assert_initialized!();
10981 ToValue::to_value(&v)
10982 }
10983}
10984
10985#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
10986#[non_exhaustive]
10987#[doc(alias = "GtkSorterOrder")]
10988pub enum SorterOrder {
10989 #[doc(alias = "GTK_SORTER_ORDER_PARTIAL")]
10990 Partial,
10991 #[doc(alias = "GTK_SORTER_ORDER_NONE")]
10992 None,
10993 #[doc(alias = "GTK_SORTER_ORDER_TOTAL")]
10994 Total,
10995 #[doc(hidden)]
10996 __Unknown(i32),
10997}
10998
10999#[doc(hidden)]
11000impl IntoGlib for SorterOrder {
11001 type GlibType = ffi::GtkSorterOrder;
11002
11003 #[inline]
11004 fn into_glib(self) -> ffi::GtkSorterOrder {
11005 match self {
11006 Self::Partial => ffi::GTK_SORTER_ORDER_PARTIAL,
11007 Self::None => ffi::GTK_SORTER_ORDER_NONE,
11008 Self::Total => ffi::GTK_SORTER_ORDER_TOTAL,
11009 Self::__Unknown(value) => value,
11010 }
11011 }
11012}
11013
11014#[doc(hidden)]
11015impl FromGlib<ffi::GtkSorterOrder> for SorterOrder {
11016 #[inline]
11017 unsafe fn from_glib(value: ffi::GtkSorterOrder) -> Self {
11018 skip_assert_initialized!();
11019
11020 match value {
11021 ffi::GTK_SORTER_ORDER_PARTIAL => Self::Partial,
11022 ffi::GTK_SORTER_ORDER_NONE => Self::None,
11023 ffi::GTK_SORTER_ORDER_TOTAL => Self::Total,
11024 value => Self::__Unknown(value),
11025 }
11026 }
11027}
11028
11029impl StaticType for SorterOrder {
11030 #[inline]
11031 #[doc(alias = "gtk_sorter_order_get_type")]
11032 fn static_type() -> glib::Type {
11033 unsafe { from_glib(ffi::gtk_sorter_order_get_type()) }
11034 }
11035}
11036
11037impl glib::HasParamSpec for SorterOrder {
11038 type ParamSpec = glib::ParamSpecEnum;
11039 type SetValue = Self;
11040 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
11041
11042 fn param_spec_builder() -> Self::BuilderFn {
11043 Self::ParamSpec::builder_with_default
11044 }
11045}
11046
11047impl glib::value::ValueType for SorterOrder {
11048 type Type = Self;
11049}
11050
11051unsafe impl<'a> glib::value::FromValue<'a> for SorterOrder {
11052 type Checker = glib::value::GenericValueTypeChecker<Self>;
11053
11054 #[inline]
11055 unsafe fn from_value(value: &'a glib::Value) -> Self {
11056 skip_assert_initialized!();
11057 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
11058 }
11059}
11060
11061impl ToValue for SorterOrder {
11062 #[inline]
11063 fn to_value(&self) -> glib::Value {
11064 let mut value = glib::Value::for_value_type::<Self>();
11065 unsafe {
11066 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
11067 }
11068 value
11069 }
11070
11071 #[inline]
11072 fn value_type(&self) -> glib::Type {
11073 Self::static_type()
11074 }
11075}
11076
11077impl From<SorterOrder> for glib::Value {
11078 #[inline]
11079 fn from(v: SorterOrder) -> Self {
11080 skip_assert_initialized!();
11081 ToValue::to_value(&v)
11082 }
11083}
11084
11085#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
11086#[non_exhaustive]
11087#[doc(alias = "GtkSpinButtonUpdatePolicy")]
11088pub enum SpinButtonUpdatePolicy {
11089 #[doc(alias = "GTK_UPDATE_ALWAYS")]
11090 Always,
11091 #[doc(alias = "GTK_UPDATE_IF_VALID")]
11092 IfValid,
11093 #[doc(hidden)]
11094 __Unknown(i32),
11095}
11096
11097#[doc(hidden)]
11098impl IntoGlib for SpinButtonUpdatePolicy {
11099 type GlibType = ffi::GtkSpinButtonUpdatePolicy;
11100
11101 #[inline]
11102 fn into_glib(self) -> ffi::GtkSpinButtonUpdatePolicy {
11103 match self {
11104 Self::Always => ffi::GTK_UPDATE_ALWAYS,
11105 Self::IfValid => ffi::GTK_UPDATE_IF_VALID,
11106 Self::__Unknown(value) => value,
11107 }
11108 }
11109}
11110
11111#[doc(hidden)]
11112impl FromGlib<ffi::GtkSpinButtonUpdatePolicy> for SpinButtonUpdatePolicy {
11113 #[inline]
11114 unsafe fn from_glib(value: ffi::GtkSpinButtonUpdatePolicy) -> Self {
11115 skip_assert_initialized!();
11116
11117 match value {
11118 ffi::GTK_UPDATE_ALWAYS => Self::Always,
11119 ffi::GTK_UPDATE_IF_VALID => Self::IfValid,
11120 value => Self::__Unknown(value),
11121 }
11122 }
11123}
11124
11125impl StaticType for SpinButtonUpdatePolicy {
11126 #[inline]
11127 #[doc(alias = "gtk_spin_button_update_policy_get_type")]
11128 fn static_type() -> glib::Type {
11129 unsafe { from_glib(ffi::gtk_spin_button_update_policy_get_type()) }
11130 }
11131}
11132
11133impl glib::HasParamSpec for SpinButtonUpdatePolicy {
11134 type ParamSpec = glib::ParamSpecEnum;
11135 type SetValue = Self;
11136 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
11137
11138 fn param_spec_builder() -> Self::BuilderFn {
11139 Self::ParamSpec::builder_with_default
11140 }
11141}
11142
11143impl glib::value::ValueType for SpinButtonUpdatePolicy {
11144 type Type = Self;
11145}
11146
11147unsafe impl<'a> glib::value::FromValue<'a> for SpinButtonUpdatePolicy {
11148 type Checker = glib::value::GenericValueTypeChecker<Self>;
11149
11150 #[inline]
11151 unsafe fn from_value(value: &'a glib::Value) -> Self {
11152 skip_assert_initialized!();
11153 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
11154 }
11155}
11156
11157impl ToValue for SpinButtonUpdatePolicy {
11158 #[inline]
11159 fn to_value(&self) -> glib::Value {
11160 let mut value = glib::Value::for_value_type::<Self>();
11161 unsafe {
11162 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
11163 }
11164 value
11165 }
11166
11167 #[inline]
11168 fn value_type(&self) -> glib::Type {
11169 Self::static_type()
11170 }
11171}
11172
11173impl From<SpinButtonUpdatePolicy> for glib::Value {
11174 #[inline]
11175 fn from(v: SpinButtonUpdatePolicy) -> Self {
11176 skip_assert_initialized!();
11177 ToValue::to_value(&v)
11178 }
11179}
11180
11181#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
11182#[non_exhaustive]
11183#[doc(alias = "GtkSpinType")]
11184pub enum SpinType {
11185 #[doc(alias = "GTK_SPIN_STEP_FORWARD")]
11186 StepForward,
11187 #[doc(alias = "GTK_SPIN_STEP_BACKWARD")]
11188 StepBackward,
11189 #[doc(alias = "GTK_SPIN_PAGE_FORWARD")]
11190 PageForward,
11191 #[doc(alias = "GTK_SPIN_PAGE_BACKWARD")]
11192 PageBackward,
11193 #[doc(alias = "GTK_SPIN_HOME")]
11194 Home,
11195 #[doc(alias = "GTK_SPIN_END")]
11196 End,
11197 #[doc(alias = "GTK_SPIN_USER_DEFINED")]
11198 UserDefined,
11199 #[doc(hidden)]
11200 __Unknown(i32),
11201}
11202
11203#[doc(hidden)]
11204impl IntoGlib for SpinType {
11205 type GlibType = ffi::GtkSpinType;
11206
11207 #[inline]
11208 fn into_glib(self) -> ffi::GtkSpinType {
11209 match self {
11210 Self::StepForward => ffi::GTK_SPIN_STEP_FORWARD,
11211 Self::StepBackward => ffi::GTK_SPIN_STEP_BACKWARD,
11212 Self::PageForward => ffi::GTK_SPIN_PAGE_FORWARD,
11213 Self::PageBackward => ffi::GTK_SPIN_PAGE_BACKWARD,
11214 Self::Home => ffi::GTK_SPIN_HOME,
11215 Self::End => ffi::GTK_SPIN_END,
11216 Self::UserDefined => ffi::GTK_SPIN_USER_DEFINED,
11217 Self::__Unknown(value) => value,
11218 }
11219 }
11220}
11221
11222#[doc(hidden)]
11223impl FromGlib<ffi::GtkSpinType> for SpinType {
11224 #[inline]
11225 unsafe fn from_glib(value: ffi::GtkSpinType) -> Self {
11226 skip_assert_initialized!();
11227
11228 match value {
11229 ffi::GTK_SPIN_STEP_FORWARD => Self::StepForward,
11230 ffi::GTK_SPIN_STEP_BACKWARD => Self::StepBackward,
11231 ffi::GTK_SPIN_PAGE_FORWARD => Self::PageForward,
11232 ffi::GTK_SPIN_PAGE_BACKWARD => Self::PageBackward,
11233 ffi::GTK_SPIN_HOME => Self::Home,
11234 ffi::GTK_SPIN_END => Self::End,
11235 ffi::GTK_SPIN_USER_DEFINED => Self::UserDefined,
11236 value => Self::__Unknown(value),
11237 }
11238 }
11239}
11240
11241impl StaticType for SpinType {
11242 #[inline]
11243 #[doc(alias = "gtk_spin_type_get_type")]
11244 fn static_type() -> glib::Type {
11245 unsafe { from_glib(ffi::gtk_spin_type_get_type()) }
11246 }
11247}
11248
11249impl glib::HasParamSpec for SpinType {
11250 type ParamSpec = glib::ParamSpecEnum;
11251 type SetValue = Self;
11252 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
11253
11254 fn param_spec_builder() -> Self::BuilderFn {
11255 Self::ParamSpec::builder_with_default
11256 }
11257}
11258
11259impl glib::value::ValueType for SpinType {
11260 type Type = Self;
11261}
11262
11263unsafe impl<'a> glib::value::FromValue<'a> for SpinType {
11264 type Checker = glib::value::GenericValueTypeChecker<Self>;
11265
11266 #[inline]
11267 unsafe fn from_value(value: &'a glib::Value) -> Self {
11268 skip_assert_initialized!();
11269 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
11270 }
11271}
11272
11273impl ToValue for SpinType {
11274 #[inline]
11275 fn to_value(&self) -> glib::Value {
11276 let mut value = glib::Value::for_value_type::<Self>();
11277 unsafe {
11278 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
11279 }
11280 value
11281 }
11282
11283 #[inline]
11284 fn value_type(&self) -> glib::Type {
11285 Self::static_type()
11286 }
11287}
11288
11289impl From<SpinType> for glib::Value {
11290 #[inline]
11291 fn from(v: SpinType) -> Self {
11292 skip_assert_initialized!();
11293 ToValue::to_value(&v)
11294 }
11295}
11296
11297#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
11298#[non_exhaustive]
11299#[doc(alias = "GtkStackTransitionType")]
11300pub enum StackTransitionType {
11301 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_NONE")]
11302 None,
11303 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_CROSSFADE")]
11304 Crossfade,
11305 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_SLIDE_RIGHT")]
11306 SlideRight,
11307 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT")]
11308 SlideLeft,
11309 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_SLIDE_UP")]
11310 SlideUp,
11311 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_SLIDE_DOWN")]
11312 SlideDown,
11313 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT_RIGHT")]
11314 SlideLeftRight,
11315 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_SLIDE_UP_DOWN")]
11316 SlideUpDown,
11317 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_OVER_UP")]
11318 OverUp,
11319 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_OVER_DOWN")]
11320 OverDown,
11321 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_OVER_LEFT")]
11322 OverLeft,
11323 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_OVER_RIGHT")]
11324 OverRight,
11325 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_UNDER_UP")]
11326 UnderUp,
11327 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_UNDER_DOWN")]
11328 UnderDown,
11329 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_UNDER_LEFT")]
11330 UnderLeft,
11331 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_UNDER_RIGHT")]
11332 UnderRight,
11333 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_OVER_UP_DOWN")]
11334 OverUpDown,
11335 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_OVER_DOWN_UP")]
11336 OverDownUp,
11337 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_OVER_LEFT_RIGHT")]
11338 OverLeftRight,
11339 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_OVER_RIGHT_LEFT")]
11340 OverRightLeft,
11341 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_ROTATE_LEFT")]
11342 RotateLeft,
11343 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_ROTATE_RIGHT")]
11344 RotateRight,
11345 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_ROTATE_LEFT_RIGHT")]
11346 RotateLeftRight,
11347 #[doc(hidden)]
11348 __Unknown(i32),
11349}
11350
11351#[doc(hidden)]
11352impl IntoGlib for StackTransitionType {
11353 type GlibType = ffi::GtkStackTransitionType;
11354
11355 fn into_glib(self) -> ffi::GtkStackTransitionType {
11356 match self {
11357 Self::None => ffi::GTK_STACK_TRANSITION_TYPE_NONE,
11358 Self::Crossfade => ffi::GTK_STACK_TRANSITION_TYPE_CROSSFADE,
11359 Self::SlideRight => ffi::GTK_STACK_TRANSITION_TYPE_SLIDE_RIGHT,
11360 Self::SlideLeft => ffi::GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT,
11361 Self::SlideUp => ffi::GTK_STACK_TRANSITION_TYPE_SLIDE_UP,
11362 Self::SlideDown => ffi::GTK_STACK_TRANSITION_TYPE_SLIDE_DOWN,
11363 Self::SlideLeftRight => ffi::GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT_RIGHT,
11364 Self::SlideUpDown => ffi::GTK_STACK_TRANSITION_TYPE_SLIDE_UP_DOWN,
11365 Self::OverUp => ffi::GTK_STACK_TRANSITION_TYPE_OVER_UP,
11366 Self::OverDown => ffi::GTK_STACK_TRANSITION_TYPE_OVER_DOWN,
11367 Self::OverLeft => ffi::GTK_STACK_TRANSITION_TYPE_OVER_LEFT,
11368 Self::OverRight => ffi::GTK_STACK_TRANSITION_TYPE_OVER_RIGHT,
11369 Self::UnderUp => ffi::GTK_STACK_TRANSITION_TYPE_UNDER_UP,
11370 Self::UnderDown => ffi::GTK_STACK_TRANSITION_TYPE_UNDER_DOWN,
11371 Self::UnderLeft => ffi::GTK_STACK_TRANSITION_TYPE_UNDER_LEFT,
11372 Self::UnderRight => ffi::GTK_STACK_TRANSITION_TYPE_UNDER_RIGHT,
11373 Self::OverUpDown => ffi::GTK_STACK_TRANSITION_TYPE_OVER_UP_DOWN,
11374 Self::OverDownUp => ffi::GTK_STACK_TRANSITION_TYPE_OVER_DOWN_UP,
11375 Self::OverLeftRight => ffi::GTK_STACK_TRANSITION_TYPE_OVER_LEFT_RIGHT,
11376 Self::OverRightLeft => ffi::GTK_STACK_TRANSITION_TYPE_OVER_RIGHT_LEFT,
11377 Self::RotateLeft => ffi::GTK_STACK_TRANSITION_TYPE_ROTATE_LEFT,
11378 Self::RotateRight => ffi::GTK_STACK_TRANSITION_TYPE_ROTATE_RIGHT,
11379 Self::RotateLeftRight => ffi::GTK_STACK_TRANSITION_TYPE_ROTATE_LEFT_RIGHT,
11380 Self::__Unknown(value) => value,
11381 }
11382 }
11383}
11384
11385#[doc(hidden)]
11386impl FromGlib<ffi::GtkStackTransitionType> for StackTransitionType {
11387 unsafe fn from_glib(value: ffi::GtkStackTransitionType) -> Self {
11388 skip_assert_initialized!();
11389
11390 match value {
11391 ffi::GTK_STACK_TRANSITION_TYPE_NONE => Self::None,
11392 ffi::GTK_STACK_TRANSITION_TYPE_CROSSFADE => Self::Crossfade,
11393 ffi::GTK_STACK_TRANSITION_TYPE_SLIDE_RIGHT => Self::SlideRight,
11394 ffi::GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT => Self::SlideLeft,
11395 ffi::GTK_STACK_TRANSITION_TYPE_SLIDE_UP => Self::SlideUp,
11396 ffi::GTK_STACK_TRANSITION_TYPE_SLIDE_DOWN => Self::SlideDown,
11397 ffi::GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT_RIGHT => Self::SlideLeftRight,
11398 ffi::GTK_STACK_TRANSITION_TYPE_SLIDE_UP_DOWN => Self::SlideUpDown,
11399 ffi::GTK_STACK_TRANSITION_TYPE_OVER_UP => Self::OverUp,
11400 ffi::GTK_STACK_TRANSITION_TYPE_OVER_DOWN => Self::OverDown,
11401 ffi::GTK_STACK_TRANSITION_TYPE_OVER_LEFT => Self::OverLeft,
11402 ffi::GTK_STACK_TRANSITION_TYPE_OVER_RIGHT => Self::OverRight,
11403 ffi::GTK_STACK_TRANSITION_TYPE_UNDER_UP => Self::UnderUp,
11404 ffi::GTK_STACK_TRANSITION_TYPE_UNDER_DOWN => Self::UnderDown,
11405 ffi::GTK_STACK_TRANSITION_TYPE_UNDER_LEFT => Self::UnderLeft,
11406 ffi::GTK_STACK_TRANSITION_TYPE_UNDER_RIGHT => Self::UnderRight,
11407 ffi::GTK_STACK_TRANSITION_TYPE_OVER_UP_DOWN => Self::OverUpDown,
11408 ffi::GTK_STACK_TRANSITION_TYPE_OVER_DOWN_UP => Self::OverDownUp,
11409 ffi::GTK_STACK_TRANSITION_TYPE_OVER_LEFT_RIGHT => Self::OverLeftRight,
11410 ffi::GTK_STACK_TRANSITION_TYPE_OVER_RIGHT_LEFT => Self::OverRightLeft,
11411 ffi::GTK_STACK_TRANSITION_TYPE_ROTATE_LEFT => Self::RotateLeft,
11412 ffi::GTK_STACK_TRANSITION_TYPE_ROTATE_RIGHT => Self::RotateRight,
11413 ffi::GTK_STACK_TRANSITION_TYPE_ROTATE_LEFT_RIGHT => Self::RotateLeftRight,
11414 value => Self::__Unknown(value),
11415 }
11416 }
11417}
11418
11419impl StaticType for StackTransitionType {
11420 #[inline]
11421 #[doc(alias = "gtk_stack_transition_type_get_type")]
11422 fn static_type() -> glib::Type {
11423 unsafe { from_glib(ffi::gtk_stack_transition_type_get_type()) }
11424 }
11425}
11426
11427impl glib::HasParamSpec for StackTransitionType {
11428 type ParamSpec = glib::ParamSpecEnum;
11429 type SetValue = Self;
11430 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
11431
11432 fn param_spec_builder() -> Self::BuilderFn {
11433 Self::ParamSpec::builder_with_default
11434 }
11435}
11436
11437impl glib::value::ValueType for StackTransitionType {
11438 type Type = Self;
11439}
11440
11441unsafe impl<'a> glib::value::FromValue<'a> for StackTransitionType {
11442 type Checker = glib::value::GenericValueTypeChecker<Self>;
11443
11444 #[inline]
11445 unsafe fn from_value(value: &'a glib::Value) -> Self {
11446 skip_assert_initialized!();
11447 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
11448 }
11449}
11450
11451impl ToValue for StackTransitionType {
11452 #[inline]
11453 fn to_value(&self) -> glib::Value {
11454 let mut value = glib::Value::for_value_type::<Self>();
11455 unsafe {
11456 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
11457 }
11458 value
11459 }
11460
11461 #[inline]
11462 fn value_type(&self) -> glib::Type {
11463 Self::static_type()
11464 }
11465}
11466
11467impl From<StackTransitionType> for glib::Value {
11468 #[inline]
11469 fn from(v: StackTransitionType) -> Self {
11470 skip_assert_initialized!();
11471 ToValue::to_value(&v)
11472 }
11473}
11474
11475#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
11476#[non_exhaustive]
11477#[doc(alias = "GtkStringFilterMatchMode")]
11478pub enum StringFilterMatchMode {
11479 #[doc(alias = "GTK_STRING_FILTER_MATCH_MODE_EXACT")]
11480 Exact,
11481 #[doc(alias = "GTK_STRING_FILTER_MATCH_MODE_SUBSTRING")]
11482 Substring,
11483 #[doc(alias = "GTK_STRING_FILTER_MATCH_MODE_PREFIX")]
11484 Prefix,
11485 #[doc(hidden)]
11486 __Unknown(i32),
11487}
11488
11489#[doc(hidden)]
11490impl IntoGlib for StringFilterMatchMode {
11491 type GlibType = ffi::GtkStringFilterMatchMode;
11492
11493 #[inline]
11494 fn into_glib(self) -> ffi::GtkStringFilterMatchMode {
11495 match self {
11496 Self::Exact => ffi::GTK_STRING_FILTER_MATCH_MODE_EXACT,
11497 Self::Substring => ffi::GTK_STRING_FILTER_MATCH_MODE_SUBSTRING,
11498 Self::Prefix => ffi::GTK_STRING_FILTER_MATCH_MODE_PREFIX,
11499 Self::__Unknown(value) => value,
11500 }
11501 }
11502}
11503
11504#[doc(hidden)]
11505impl FromGlib<ffi::GtkStringFilterMatchMode> for StringFilterMatchMode {
11506 #[inline]
11507 unsafe fn from_glib(value: ffi::GtkStringFilterMatchMode) -> Self {
11508 skip_assert_initialized!();
11509
11510 match value {
11511 ffi::GTK_STRING_FILTER_MATCH_MODE_EXACT => Self::Exact,
11512 ffi::GTK_STRING_FILTER_MATCH_MODE_SUBSTRING => Self::Substring,
11513 ffi::GTK_STRING_FILTER_MATCH_MODE_PREFIX => Self::Prefix,
11514 value => Self::__Unknown(value),
11515 }
11516 }
11517}
11518
11519impl StaticType for StringFilterMatchMode {
11520 #[inline]
11521 #[doc(alias = "gtk_string_filter_match_mode_get_type")]
11522 fn static_type() -> glib::Type {
11523 unsafe { from_glib(ffi::gtk_string_filter_match_mode_get_type()) }
11524 }
11525}
11526
11527impl glib::HasParamSpec for StringFilterMatchMode {
11528 type ParamSpec = glib::ParamSpecEnum;
11529 type SetValue = Self;
11530 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
11531
11532 fn param_spec_builder() -> Self::BuilderFn {
11533 Self::ParamSpec::builder_with_default
11534 }
11535}
11536
11537impl glib::value::ValueType for StringFilterMatchMode {
11538 type Type = Self;
11539}
11540
11541unsafe impl<'a> glib::value::FromValue<'a> for StringFilterMatchMode {
11542 type Checker = glib::value::GenericValueTypeChecker<Self>;
11543
11544 #[inline]
11545 unsafe fn from_value(value: &'a glib::Value) -> Self {
11546 skip_assert_initialized!();
11547 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
11548 }
11549}
11550
11551impl ToValue for StringFilterMatchMode {
11552 #[inline]
11553 fn to_value(&self) -> glib::Value {
11554 let mut value = glib::Value::for_value_type::<Self>();
11555 unsafe {
11556 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
11557 }
11558 value
11559 }
11560
11561 #[inline]
11562 fn value_type(&self) -> glib::Type {
11563 Self::static_type()
11564 }
11565}
11566
11567impl From<StringFilterMatchMode> for glib::Value {
11568 #[inline]
11569 fn from(v: StringFilterMatchMode) -> Self {
11570 skip_assert_initialized!();
11571 ToValue::to_value(&v)
11572 }
11573}
11574
11575#[cfg(feature = "v4_6")]
11576#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
11577#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
11578#[non_exhaustive]
11579#[doc(alias = "GtkSymbolicColor")]
11580pub enum SymbolicColor {
11581 #[doc(alias = "GTK_SYMBOLIC_COLOR_FOREGROUND")]
11582 Foreground,
11583 #[doc(alias = "GTK_SYMBOLIC_COLOR_ERROR")]
11584 Error,
11585 #[doc(alias = "GTK_SYMBOLIC_COLOR_WARNING")]
11586 Warning,
11587 #[doc(alias = "GTK_SYMBOLIC_COLOR_SUCCESS")]
11588 Success,
11589 #[cfg(feature = "v4_22")]
11590 #[cfg_attr(docsrs, doc(cfg(feature = "v4_22")))]
11591 #[doc(alias = "GTK_SYMBOLIC_COLOR_ACCENT")]
11592 Accent,
11593 #[doc(hidden)]
11594 __Unknown(i32),
11595}
11596
11597#[cfg(feature = "v4_6")]
11598#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
11599#[doc(hidden)]
11600impl IntoGlib for SymbolicColor {
11601 type GlibType = ffi::GtkSymbolicColor;
11602
11603 #[inline]
11604 fn into_glib(self) -> ffi::GtkSymbolicColor {
11605 match self {
11606 Self::Foreground => ffi::GTK_SYMBOLIC_COLOR_FOREGROUND,
11607 Self::Error => ffi::GTK_SYMBOLIC_COLOR_ERROR,
11608 Self::Warning => ffi::GTK_SYMBOLIC_COLOR_WARNING,
11609 Self::Success => ffi::GTK_SYMBOLIC_COLOR_SUCCESS,
11610 #[cfg(feature = "v4_22")]
11611 Self::Accent => ffi::GTK_SYMBOLIC_COLOR_ACCENT,
11612 Self::__Unknown(value) => value,
11613 }
11614 }
11615}
11616
11617#[cfg(feature = "v4_6")]
11618#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
11619#[doc(hidden)]
11620impl FromGlib<ffi::GtkSymbolicColor> for SymbolicColor {
11621 #[inline]
11622 unsafe fn from_glib(value: ffi::GtkSymbolicColor) -> Self {
11623 skip_assert_initialized!();
11624
11625 match value {
11626 ffi::GTK_SYMBOLIC_COLOR_FOREGROUND => Self::Foreground,
11627 ffi::GTK_SYMBOLIC_COLOR_ERROR => Self::Error,
11628 ffi::GTK_SYMBOLIC_COLOR_WARNING => Self::Warning,
11629 ffi::GTK_SYMBOLIC_COLOR_SUCCESS => Self::Success,
11630 #[cfg(feature = "v4_22")]
11631 ffi::GTK_SYMBOLIC_COLOR_ACCENT => Self::Accent,
11632 value => Self::__Unknown(value),
11633 }
11634 }
11635}
11636
11637#[cfg(feature = "v4_6")]
11638#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
11639impl StaticType for SymbolicColor {
11640 #[inline]
11641 #[doc(alias = "gtk_symbolic_color_get_type")]
11642 fn static_type() -> glib::Type {
11643 unsafe { from_glib(ffi::gtk_symbolic_color_get_type()) }
11644 }
11645}
11646
11647#[cfg(feature = "v4_6")]
11648#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
11649impl glib::HasParamSpec for SymbolicColor {
11650 type ParamSpec = glib::ParamSpecEnum;
11651 type SetValue = Self;
11652 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
11653
11654 fn param_spec_builder() -> Self::BuilderFn {
11655 Self::ParamSpec::builder_with_default
11656 }
11657}
11658
11659#[cfg(feature = "v4_6")]
11660#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
11661impl glib::value::ValueType for SymbolicColor {
11662 type Type = Self;
11663}
11664
11665#[cfg(feature = "v4_6")]
11666#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
11667unsafe impl<'a> glib::value::FromValue<'a> for SymbolicColor {
11668 type Checker = glib::value::GenericValueTypeChecker<Self>;
11669
11670 #[inline]
11671 unsafe fn from_value(value: &'a glib::Value) -> Self {
11672 skip_assert_initialized!();
11673 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
11674 }
11675}
11676
11677#[cfg(feature = "v4_6")]
11678#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
11679impl ToValue for SymbolicColor {
11680 #[inline]
11681 fn to_value(&self) -> glib::Value {
11682 let mut value = glib::Value::for_value_type::<Self>();
11683 unsafe {
11684 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
11685 }
11686 value
11687 }
11688
11689 #[inline]
11690 fn value_type(&self) -> glib::Type {
11691 Self::static_type()
11692 }
11693}
11694
11695#[cfg(feature = "v4_6")]
11696#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
11697impl From<SymbolicColor> for glib::Value {
11698 #[inline]
11699 fn from(v: SymbolicColor) -> Self {
11700 skip_assert_initialized!();
11701 ToValue::to_value(&v)
11702 }
11703}
11704
11705#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
11706#[non_exhaustive]
11707#[doc(alias = "GtkSystemSetting")]
11708pub enum SystemSetting {
11709 #[doc(alias = "GTK_SYSTEM_SETTING_DPI")]
11710 Dpi,
11711 #[doc(alias = "GTK_SYSTEM_SETTING_FONT_NAME")]
11712 FontName,
11713 #[doc(alias = "GTK_SYSTEM_SETTING_FONT_CONFIG")]
11714 FontConfig,
11715 #[doc(alias = "GTK_SYSTEM_SETTING_DISPLAY")]
11716 Display,
11717 #[doc(alias = "GTK_SYSTEM_SETTING_ICON_THEME")]
11718 IconTheme,
11719 #[doc(hidden)]
11720 __Unknown(i32),
11721}
11722
11723#[doc(hidden)]
11724impl IntoGlib for SystemSetting {
11725 type GlibType = ffi::GtkSystemSetting;
11726
11727 #[inline]
11728 fn into_glib(self) -> ffi::GtkSystemSetting {
11729 match self {
11730 Self::Dpi => ffi::GTK_SYSTEM_SETTING_DPI,
11731 Self::FontName => ffi::GTK_SYSTEM_SETTING_FONT_NAME,
11732 Self::FontConfig => ffi::GTK_SYSTEM_SETTING_FONT_CONFIG,
11733 Self::Display => ffi::GTK_SYSTEM_SETTING_DISPLAY,
11734 Self::IconTheme => ffi::GTK_SYSTEM_SETTING_ICON_THEME,
11735 Self::__Unknown(value) => value,
11736 }
11737 }
11738}
11739
11740#[doc(hidden)]
11741impl FromGlib<ffi::GtkSystemSetting> for SystemSetting {
11742 #[inline]
11743 unsafe fn from_glib(value: ffi::GtkSystemSetting) -> Self {
11744 skip_assert_initialized!();
11745
11746 match value {
11747 ffi::GTK_SYSTEM_SETTING_DPI => Self::Dpi,
11748 ffi::GTK_SYSTEM_SETTING_FONT_NAME => Self::FontName,
11749 ffi::GTK_SYSTEM_SETTING_FONT_CONFIG => Self::FontConfig,
11750 ffi::GTK_SYSTEM_SETTING_DISPLAY => Self::Display,
11751 ffi::GTK_SYSTEM_SETTING_ICON_THEME => Self::IconTheme,
11752 value => Self::__Unknown(value),
11753 }
11754 }
11755}
11756
11757impl StaticType for SystemSetting {
11758 #[inline]
11759 #[doc(alias = "gtk_system_setting_get_type")]
11760 fn static_type() -> glib::Type {
11761 unsafe { from_glib(ffi::gtk_system_setting_get_type()) }
11762 }
11763}
11764
11765impl glib::HasParamSpec for SystemSetting {
11766 type ParamSpec = glib::ParamSpecEnum;
11767 type SetValue = Self;
11768 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
11769
11770 fn param_spec_builder() -> Self::BuilderFn {
11771 Self::ParamSpec::builder_with_default
11772 }
11773}
11774
11775impl glib::value::ValueType for SystemSetting {
11776 type Type = Self;
11777}
11778
11779unsafe impl<'a> glib::value::FromValue<'a> for SystemSetting {
11780 type Checker = glib::value::GenericValueTypeChecker<Self>;
11781
11782 #[inline]
11783 unsafe fn from_value(value: &'a glib::Value) -> Self {
11784 skip_assert_initialized!();
11785 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
11786 }
11787}
11788
11789impl ToValue for SystemSetting {
11790 #[inline]
11791 fn to_value(&self) -> glib::Value {
11792 let mut value = glib::Value::for_value_type::<Self>();
11793 unsafe {
11794 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
11795 }
11796 value
11797 }
11798
11799 #[inline]
11800 fn value_type(&self) -> glib::Type {
11801 Self::static_type()
11802 }
11803}
11804
11805impl From<SystemSetting> for glib::Value {
11806 #[inline]
11807 fn from(v: SystemSetting) -> Self {
11808 skip_assert_initialized!();
11809 ToValue::to_value(&v)
11810 }
11811}
11812
11813#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
11814#[non_exhaustive]
11815#[doc(alias = "GtkTextDirection")]
11816pub enum TextDirection {
11817 #[doc(alias = "GTK_TEXT_DIR_NONE")]
11818 None,
11819 #[doc(alias = "GTK_TEXT_DIR_LTR")]
11820 Ltr,
11821 #[doc(alias = "GTK_TEXT_DIR_RTL")]
11822 Rtl,
11823 #[doc(hidden)]
11824 __Unknown(i32),
11825}
11826
11827#[doc(hidden)]
11828impl IntoGlib for TextDirection {
11829 type GlibType = ffi::GtkTextDirection;
11830
11831 #[inline]
11832 fn into_glib(self) -> ffi::GtkTextDirection {
11833 match self {
11834 Self::None => ffi::GTK_TEXT_DIR_NONE,
11835 Self::Ltr => ffi::GTK_TEXT_DIR_LTR,
11836 Self::Rtl => ffi::GTK_TEXT_DIR_RTL,
11837 Self::__Unknown(value) => value,
11838 }
11839 }
11840}
11841
11842#[doc(hidden)]
11843impl FromGlib<ffi::GtkTextDirection> for TextDirection {
11844 #[inline]
11845 unsafe fn from_glib(value: ffi::GtkTextDirection) -> Self {
11846 skip_assert_initialized!();
11847
11848 match value {
11849 ffi::GTK_TEXT_DIR_NONE => Self::None,
11850 ffi::GTK_TEXT_DIR_LTR => Self::Ltr,
11851 ffi::GTK_TEXT_DIR_RTL => Self::Rtl,
11852 value => Self::__Unknown(value),
11853 }
11854 }
11855}
11856
11857impl StaticType for TextDirection {
11858 #[inline]
11859 #[doc(alias = "gtk_text_direction_get_type")]
11860 fn static_type() -> glib::Type {
11861 unsafe { from_glib(ffi::gtk_text_direction_get_type()) }
11862 }
11863}
11864
11865impl glib::HasParamSpec for TextDirection {
11866 type ParamSpec = glib::ParamSpecEnum;
11867 type SetValue = Self;
11868 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
11869
11870 fn param_spec_builder() -> Self::BuilderFn {
11871 Self::ParamSpec::builder_with_default
11872 }
11873}
11874
11875impl glib::value::ValueType for TextDirection {
11876 type Type = Self;
11877}
11878
11879unsafe impl<'a> glib::value::FromValue<'a> for TextDirection {
11880 type Checker = glib::value::GenericValueTypeChecker<Self>;
11881
11882 #[inline]
11883 unsafe fn from_value(value: &'a glib::Value) -> Self {
11884 skip_assert_initialized!();
11885 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
11886 }
11887}
11888
11889impl ToValue for TextDirection {
11890 #[inline]
11891 fn to_value(&self) -> glib::Value {
11892 let mut value = glib::Value::for_value_type::<Self>();
11893 unsafe {
11894 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
11895 }
11896 value
11897 }
11898
11899 #[inline]
11900 fn value_type(&self) -> glib::Type {
11901 Self::static_type()
11902 }
11903}
11904
11905impl From<TextDirection> for glib::Value {
11906 #[inline]
11907 fn from(v: TextDirection) -> Self {
11908 skip_assert_initialized!();
11909 ToValue::to_value(&v)
11910 }
11911}
11912
11913#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
11914#[non_exhaustive]
11915#[doc(alias = "GtkTextExtendSelection")]
11916pub enum TextExtendSelection {
11917 #[doc(alias = "GTK_TEXT_EXTEND_SELECTION_WORD")]
11918 Word,
11919 #[doc(alias = "GTK_TEXT_EXTEND_SELECTION_LINE")]
11920 Line,
11921 #[doc(hidden)]
11922 __Unknown(i32),
11923}
11924
11925#[doc(hidden)]
11926impl IntoGlib for TextExtendSelection {
11927 type GlibType = ffi::GtkTextExtendSelection;
11928
11929 #[inline]
11930 fn into_glib(self) -> ffi::GtkTextExtendSelection {
11931 match self {
11932 Self::Word => ffi::GTK_TEXT_EXTEND_SELECTION_WORD,
11933 Self::Line => ffi::GTK_TEXT_EXTEND_SELECTION_LINE,
11934 Self::__Unknown(value) => value,
11935 }
11936 }
11937}
11938
11939#[doc(hidden)]
11940impl FromGlib<ffi::GtkTextExtendSelection> for TextExtendSelection {
11941 #[inline]
11942 unsafe fn from_glib(value: ffi::GtkTextExtendSelection) -> Self {
11943 skip_assert_initialized!();
11944
11945 match value {
11946 ffi::GTK_TEXT_EXTEND_SELECTION_WORD => Self::Word,
11947 ffi::GTK_TEXT_EXTEND_SELECTION_LINE => Self::Line,
11948 value => Self::__Unknown(value),
11949 }
11950 }
11951}
11952
11953impl StaticType for TextExtendSelection {
11954 #[inline]
11955 #[doc(alias = "gtk_text_extend_selection_get_type")]
11956 fn static_type() -> glib::Type {
11957 unsafe { from_glib(ffi::gtk_text_extend_selection_get_type()) }
11958 }
11959}
11960
11961impl glib::HasParamSpec for TextExtendSelection {
11962 type ParamSpec = glib::ParamSpecEnum;
11963 type SetValue = Self;
11964 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
11965
11966 fn param_spec_builder() -> Self::BuilderFn {
11967 Self::ParamSpec::builder_with_default
11968 }
11969}
11970
11971impl glib::value::ValueType for TextExtendSelection {
11972 type Type = Self;
11973}
11974
11975unsafe impl<'a> glib::value::FromValue<'a> for TextExtendSelection {
11976 type Checker = glib::value::GenericValueTypeChecker<Self>;
11977
11978 #[inline]
11979 unsafe fn from_value(value: &'a glib::Value) -> Self {
11980 skip_assert_initialized!();
11981 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
11982 }
11983}
11984
11985impl ToValue for TextExtendSelection {
11986 #[inline]
11987 fn to_value(&self) -> glib::Value {
11988 let mut value = glib::Value::for_value_type::<Self>();
11989 unsafe {
11990 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
11991 }
11992 value
11993 }
11994
11995 #[inline]
11996 fn value_type(&self) -> glib::Type {
11997 Self::static_type()
11998 }
11999}
12000
12001impl From<TextExtendSelection> for glib::Value {
12002 #[inline]
12003 fn from(v: TextExtendSelection) -> Self {
12004 skip_assert_initialized!();
12005 ToValue::to_value(&v)
12006 }
12007}
12008
12009#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
12010#[non_exhaustive]
12011#[doc(alias = "GtkTextViewLayer")]
12012pub enum TextViewLayer {
12013 #[doc(alias = "GTK_TEXT_VIEW_LAYER_BELOW_TEXT")]
12014 BelowText,
12015 #[doc(alias = "GTK_TEXT_VIEW_LAYER_ABOVE_TEXT")]
12016 AboveText,
12017 #[doc(hidden)]
12018 __Unknown(i32),
12019}
12020
12021#[doc(hidden)]
12022impl IntoGlib for TextViewLayer {
12023 type GlibType = ffi::GtkTextViewLayer;
12024
12025 #[inline]
12026 fn into_glib(self) -> ffi::GtkTextViewLayer {
12027 match self {
12028 Self::BelowText => ffi::GTK_TEXT_VIEW_LAYER_BELOW_TEXT,
12029 Self::AboveText => ffi::GTK_TEXT_VIEW_LAYER_ABOVE_TEXT,
12030 Self::__Unknown(value) => value,
12031 }
12032 }
12033}
12034
12035#[doc(hidden)]
12036impl FromGlib<ffi::GtkTextViewLayer> for TextViewLayer {
12037 #[inline]
12038 unsafe fn from_glib(value: ffi::GtkTextViewLayer) -> Self {
12039 skip_assert_initialized!();
12040
12041 match value {
12042 ffi::GTK_TEXT_VIEW_LAYER_BELOW_TEXT => Self::BelowText,
12043 ffi::GTK_TEXT_VIEW_LAYER_ABOVE_TEXT => Self::AboveText,
12044 value => Self::__Unknown(value),
12045 }
12046 }
12047}
12048
12049impl StaticType for TextViewLayer {
12050 #[inline]
12051 #[doc(alias = "gtk_text_view_layer_get_type")]
12052 fn static_type() -> glib::Type {
12053 unsafe { from_glib(ffi::gtk_text_view_layer_get_type()) }
12054 }
12055}
12056
12057impl glib::HasParamSpec for TextViewLayer {
12058 type ParamSpec = glib::ParamSpecEnum;
12059 type SetValue = Self;
12060 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
12061
12062 fn param_spec_builder() -> Self::BuilderFn {
12063 Self::ParamSpec::builder_with_default
12064 }
12065}
12066
12067impl glib::value::ValueType for TextViewLayer {
12068 type Type = Self;
12069}
12070
12071unsafe impl<'a> glib::value::FromValue<'a> for TextViewLayer {
12072 type Checker = glib::value::GenericValueTypeChecker<Self>;
12073
12074 #[inline]
12075 unsafe fn from_value(value: &'a glib::Value) -> Self {
12076 skip_assert_initialized!();
12077 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
12078 }
12079}
12080
12081impl ToValue for TextViewLayer {
12082 #[inline]
12083 fn to_value(&self) -> glib::Value {
12084 let mut value = glib::Value::for_value_type::<Self>();
12085 unsafe {
12086 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
12087 }
12088 value
12089 }
12090
12091 #[inline]
12092 fn value_type(&self) -> glib::Type {
12093 Self::static_type()
12094 }
12095}
12096
12097impl From<TextViewLayer> for glib::Value {
12098 #[inline]
12099 fn from(v: TextViewLayer) -> Self {
12100 skip_assert_initialized!();
12101 ToValue::to_value(&v)
12102 }
12103}
12104
12105#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
12106#[non_exhaustive]
12107#[doc(alias = "GtkTextWindowType")]
12108pub enum TextWindowType {
12109 #[doc(alias = "GTK_TEXT_WINDOW_WIDGET")]
12110 Widget,
12111 #[doc(alias = "GTK_TEXT_WINDOW_TEXT")]
12112 Text,
12113 #[doc(alias = "GTK_TEXT_WINDOW_LEFT")]
12114 Left,
12115 #[doc(alias = "GTK_TEXT_WINDOW_RIGHT")]
12116 Right,
12117 #[doc(alias = "GTK_TEXT_WINDOW_TOP")]
12118 Top,
12119 #[doc(alias = "GTK_TEXT_WINDOW_BOTTOM")]
12120 Bottom,
12121 #[doc(hidden)]
12122 __Unknown(i32),
12123}
12124
12125#[doc(hidden)]
12126impl IntoGlib for TextWindowType {
12127 type GlibType = ffi::GtkTextWindowType;
12128
12129 #[inline]
12130 fn into_glib(self) -> ffi::GtkTextWindowType {
12131 match self {
12132 Self::Widget => ffi::GTK_TEXT_WINDOW_WIDGET,
12133 Self::Text => ffi::GTK_TEXT_WINDOW_TEXT,
12134 Self::Left => ffi::GTK_TEXT_WINDOW_LEFT,
12135 Self::Right => ffi::GTK_TEXT_WINDOW_RIGHT,
12136 Self::Top => ffi::GTK_TEXT_WINDOW_TOP,
12137 Self::Bottom => ffi::GTK_TEXT_WINDOW_BOTTOM,
12138 Self::__Unknown(value) => value,
12139 }
12140 }
12141}
12142
12143#[doc(hidden)]
12144impl FromGlib<ffi::GtkTextWindowType> for TextWindowType {
12145 #[inline]
12146 unsafe fn from_glib(value: ffi::GtkTextWindowType) -> Self {
12147 skip_assert_initialized!();
12148
12149 match value {
12150 ffi::GTK_TEXT_WINDOW_WIDGET => Self::Widget,
12151 ffi::GTK_TEXT_WINDOW_TEXT => Self::Text,
12152 ffi::GTK_TEXT_WINDOW_LEFT => Self::Left,
12153 ffi::GTK_TEXT_WINDOW_RIGHT => Self::Right,
12154 ffi::GTK_TEXT_WINDOW_TOP => Self::Top,
12155 ffi::GTK_TEXT_WINDOW_BOTTOM => Self::Bottom,
12156 value => Self::__Unknown(value),
12157 }
12158 }
12159}
12160
12161impl StaticType for TextWindowType {
12162 #[inline]
12163 #[doc(alias = "gtk_text_window_type_get_type")]
12164 fn static_type() -> glib::Type {
12165 unsafe { from_glib(ffi::gtk_text_window_type_get_type()) }
12166 }
12167}
12168
12169impl glib::HasParamSpec for TextWindowType {
12170 type ParamSpec = glib::ParamSpecEnum;
12171 type SetValue = Self;
12172 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
12173
12174 fn param_spec_builder() -> Self::BuilderFn {
12175 Self::ParamSpec::builder_with_default
12176 }
12177}
12178
12179impl glib::value::ValueType for TextWindowType {
12180 type Type = Self;
12181}
12182
12183unsafe impl<'a> glib::value::FromValue<'a> for TextWindowType {
12184 type Checker = glib::value::GenericValueTypeChecker<Self>;
12185
12186 #[inline]
12187 unsafe fn from_value(value: &'a glib::Value) -> Self {
12188 skip_assert_initialized!();
12189 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
12190 }
12191}
12192
12193impl ToValue for TextWindowType {
12194 #[inline]
12195 fn to_value(&self) -> glib::Value {
12196 let mut value = glib::Value::for_value_type::<Self>();
12197 unsafe {
12198 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
12199 }
12200 value
12201 }
12202
12203 #[inline]
12204 fn value_type(&self) -> glib::Type {
12205 Self::static_type()
12206 }
12207}
12208
12209impl From<TextWindowType> for glib::Value {
12210 #[inline]
12211 fn from(v: TextWindowType) -> Self {
12212 skip_assert_initialized!();
12213 ToValue::to_value(&v)
12214 }
12215}
12216
12217#[cfg_attr(feature = "v4_20", deprecated = "Since 4.20")]
12218#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
12219#[non_exhaustive]
12220#[doc(alias = "GtkTreeViewColumnSizing")]
12221pub enum TreeViewColumnSizing {
12222 #[doc(alias = "GTK_TREE_VIEW_COLUMN_GROW_ONLY")]
12223 GrowOnly,
12224 #[doc(alias = "GTK_TREE_VIEW_COLUMN_AUTOSIZE")]
12225 Autosize,
12226 #[doc(alias = "GTK_TREE_VIEW_COLUMN_FIXED")]
12227 Fixed,
12228 #[doc(hidden)]
12229 __Unknown(i32),
12230}
12231
12232#[allow(deprecated)]
12233#[doc(hidden)]
12234impl IntoGlib for TreeViewColumnSizing {
12235 type GlibType = ffi::GtkTreeViewColumnSizing;
12236
12237 #[inline]
12238 fn into_glib(self) -> ffi::GtkTreeViewColumnSizing {
12239 match self {
12240 Self::GrowOnly => ffi::GTK_TREE_VIEW_COLUMN_GROW_ONLY,
12241 Self::Autosize => ffi::GTK_TREE_VIEW_COLUMN_AUTOSIZE,
12242 Self::Fixed => ffi::GTK_TREE_VIEW_COLUMN_FIXED,
12243 Self::__Unknown(value) => value,
12244 }
12245 }
12246}
12247
12248#[allow(deprecated)]
12249#[doc(hidden)]
12250impl FromGlib<ffi::GtkTreeViewColumnSizing> for TreeViewColumnSizing {
12251 #[inline]
12252 unsafe fn from_glib(value: ffi::GtkTreeViewColumnSizing) -> Self {
12253 skip_assert_initialized!();
12254
12255 match value {
12256 ffi::GTK_TREE_VIEW_COLUMN_GROW_ONLY => Self::GrowOnly,
12257 ffi::GTK_TREE_VIEW_COLUMN_AUTOSIZE => Self::Autosize,
12258 ffi::GTK_TREE_VIEW_COLUMN_FIXED => Self::Fixed,
12259 value => Self::__Unknown(value),
12260 }
12261 }
12262}
12263
12264#[allow(deprecated)]
12265impl StaticType for TreeViewColumnSizing {
12266 #[inline]
12267 #[doc(alias = "gtk_tree_view_column_sizing_get_type")]
12268 fn static_type() -> glib::Type {
12269 unsafe { from_glib(ffi::gtk_tree_view_column_sizing_get_type()) }
12270 }
12271}
12272
12273#[allow(deprecated)]
12274impl glib::HasParamSpec for TreeViewColumnSizing {
12275 type ParamSpec = glib::ParamSpecEnum;
12276 type SetValue = Self;
12277 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
12278
12279 fn param_spec_builder() -> Self::BuilderFn {
12280 Self::ParamSpec::builder_with_default
12281 }
12282}
12283
12284#[allow(deprecated)]
12285impl glib::value::ValueType for TreeViewColumnSizing {
12286 type Type = Self;
12287}
12288
12289#[allow(deprecated)]
12290unsafe impl<'a> glib::value::FromValue<'a> for TreeViewColumnSizing {
12291 type Checker = glib::value::GenericValueTypeChecker<Self>;
12292
12293 #[inline]
12294 unsafe fn from_value(value: &'a glib::Value) -> Self {
12295 skip_assert_initialized!();
12296 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
12297 }
12298}
12299
12300#[allow(deprecated)]
12301impl ToValue for TreeViewColumnSizing {
12302 #[inline]
12303 fn to_value(&self) -> glib::Value {
12304 let mut value = glib::Value::for_value_type::<Self>();
12305 unsafe {
12306 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
12307 }
12308 value
12309 }
12310
12311 #[inline]
12312 fn value_type(&self) -> glib::Type {
12313 Self::static_type()
12314 }
12315}
12316
12317#[allow(deprecated)]
12318impl From<TreeViewColumnSizing> for glib::Value {
12319 #[inline]
12320 fn from(v: TreeViewColumnSizing) -> Self {
12321 skip_assert_initialized!();
12322 ToValue::to_value(&v)
12323 }
12324}
12325
12326#[cfg_attr(feature = "v4_20", deprecated = "Since 4.20")]
12327#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
12328#[non_exhaustive]
12329#[doc(alias = "GtkTreeViewDropPosition")]
12330pub enum TreeViewDropPosition {
12331 #[doc(alias = "GTK_TREE_VIEW_DROP_BEFORE")]
12332 Before,
12333 #[doc(alias = "GTK_TREE_VIEW_DROP_AFTER")]
12334 After,
12335 #[doc(alias = "GTK_TREE_VIEW_DROP_INTO_OR_BEFORE")]
12336 IntoOrBefore,
12337 #[doc(alias = "GTK_TREE_VIEW_DROP_INTO_OR_AFTER")]
12338 IntoOrAfter,
12339 #[doc(hidden)]
12340 __Unknown(i32),
12341}
12342
12343#[allow(deprecated)]
12344#[doc(hidden)]
12345impl IntoGlib for TreeViewDropPosition {
12346 type GlibType = ffi::GtkTreeViewDropPosition;
12347
12348 #[inline]
12349 fn into_glib(self) -> ffi::GtkTreeViewDropPosition {
12350 match self {
12351 Self::Before => ffi::GTK_TREE_VIEW_DROP_BEFORE,
12352 Self::After => ffi::GTK_TREE_VIEW_DROP_AFTER,
12353 Self::IntoOrBefore => ffi::GTK_TREE_VIEW_DROP_INTO_OR_BEFORE,
12354 Self::IntoOrAfter => ffi::GTK_TREE_VIEW_DROP_INTO_OR_AFTER,
12355 Self::__Unknown(value) => value,
12356 }
12357 }
12358}
12359
12360#[allow(deprecated)]
12361#[doc(hidden)]
12362impl FromGlib<ffi::GtkTreeViewDropPosition> for TreeViewDropPosition {
12363 #[inline]
12364 unsafe fn from_glib(value: ffi::GtkTreeViewDropPosition) -> Self {
12365 skip_assert_initialized!();
12366
12367 match value {
12368 ffi::GTK_TREE_VIEW_DROP_BEFORE => Self::Before,
12369 ffi::GTK_TREE_VIEW_DROP_AFTER => Self::After,
12370 ffi::GTK_TREE_VIEW_DROP_INTO_OR_BEFORE => Self::IntoOrBefore,
12371 ffi::GTK_TREE_VIEW_DROP_INTO_OR_AFTER => Self::IntoOrAfter,
12372 value => Self::__Unknown(value),
12373 }
12374 }
12375}
12376
12377#[allow(deprecated)]
12378impl StaticType for TreeViewDropPosition {
12379 #[inline]
12380 #[doc(alias = "gtk_tree_view_drop_position_get_type")]
12381 fn static_type() -> glib::Type {
12382 unsafe { from_glib(ffi::gtk_tree_view_drop_position_get_type()) }
12383 }
12384}
12385
12386#[allow(deprecated)]
12387impl glib::HasParamSpec for TreeViewDropPosition {
12388 type ParamSpec = glib::ParamSpecEnum;
12389 type SetValue = Self;
12390 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
12391
12392 fn param_spec_builder() -> Self::BuilderFn {
12393 Self::ParamSpec::builder_with_default
12394 }
12395}
12396
12397#[allow(deprecated)]
12398impl glib::value::ValueType for TreeViewDropPosition {
12399 type Type = Self;
12400}
12401
12402#[allow(deprecated)]
12403unsafe impl<'a> glib::value::FromValue<'a> for TreeViewDropPosition {
12404 type Checker = glib::value::GenericValueTypeChecker<Self>;
12405
12406 #[inline]
12407 unsafe fn from_value(value: &'a glib::Value) -> Self {
12408 skip_assert_initialized!();
12409 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
12410 }
12411}
12412
12413#[allow(deprecated)]
12414impl ToValue for TreeViewDropPosition {
12415 #[inline]
12416 fn to_value(&self) -> glib::Value {
12417 let mut value = glib::Value::for_value_type::<Self>();
12418 unsafe {
12419 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
12420 }
12421 value
12422 }
12423
12424 #[inline]
12425 fn value_type(&self) -> glib::Type {
12426 Self::static_type()
12427 }
12428}
12429
12430#[allow(deprecated)]
12431impl From<TreeViewDropPosition> for glib::Value {
12432 #[inline]
12433 fn from(v: TreeViewDropPosition) -> Self {
12434 skip_assert_initialized!();
12435 ToValue::to_value(&v)
12436 }
12437}
12438
12439#[cfg_attr(feature = "v4_20", deprecated = "Since 4.20")]
12440#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
12441#[non_exhaustive]
12442#[doc(alias = "GtkTreeViewGridLines")]
12443pub enum TreeViewGridLines {
12444 #[doc(alias = "GTK_TREE_VIEW_GRID_LINES_NONE")]
12445 None,
12446 #[doc(alias = "GTK_TREE_VIEW_GRID_LINES_HORIZONTAL")]
12447 Horizontal,
12448 #[doc(alias = "GTK_TREE_VIEW_GRID_LINES_VERTICAL")]
12449 Vertical,
12450 #[doc(alias = "GTK_TREE_VIEW_GRID_LINES_BOTH")]
12451 Both,
12452 #[doc(hidden)]
12453 __Unknown(i32),
12454}
12455
12456#[allow(deprecated)]
12457#[doc(hidden)]
12458impl IntoGlib for TreeViewGridLines {
12459 type GlibType = ffi::GtkTreeViewGridLines;
12460
12461 #[inline]
12462 fn into_glib(self) -> ffi::GtkTreeViewGridLines {
12463 match self {
12464 Self::None => ffi::GTK_TREE_VIEW_GRID_LINES_NONE,
12465 Self::Horizontal => ffi::GTK_TREE_VIEW_GRID_LINES_HORIZONTAL,
12466 Self::Vertical => ffi::GTK_TREE_VIEW_GRID_LINES_VERTICAL,
12467 Self::Both => ffi::GTK_TREE_VIEW_GRID_LINES_BOTH,
12468 Self::__Unknown(value) => value,
12469 }
12470 }
12471}
12472
12473#[allow(deprecated)]
12474#[doc(hidden)]
12475impl FromGlib<ffi::GtkTreeViewGridLines> for TreeViewGridLines {
12476 #[inline]
12477 unsafe fn from_glib(value: ffi::GtkTreeViewGridLines) -> Self {
12478 skip_assert_initialized!();
12479
12480 match value {
12481 ffi::GTK_TREE_VIEW_GRID_LINES_NONE => Self::None,
12482 ffi::GTK_TREE_VIEW_GRID_LINES_HORIZONTAL => Self::Horizontal,
12483 ffi::GTK_TREE_VIEW_GRID_LINES_VERTICAL => Self::Vertical,
12484 ffi::GTK_TREE_VIEW_GRID_LINES_BOTH => Self::Both,
12485 value => Self::__Unknown(value),
12486 }
12487 }
12488}
12489
12490#[allow(deprecated)]
12491impl StaticType for TreeViewGridLines {
12492 #[inline]
12493 #[doc(alias = "gtk_tree_view_grid_lines_get_type")]
12494 fn static_type() -> glib::Type {
12495 unsafe { from_glib(ffi::gtk_tree_view_grid_lines_get_type()) }
12496 }
12497}
12498
12499#[allow(deprecated)]
12500impl glib::HasParamSpec for TreeViewGridLines {
12501 type ParamSpec = glib::ParamSpecEnum;
12502 type SetValue = Self;
12503 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
12504
12505 fn param_spec_builder() -> Self::BuilderFn {
12506 Self::ParamSpec::builder_with_default
12507 }
12508}
12509
12510#[allow(deprecated)]
12511impl glib::value::ValueType for TreeViewGridLines {
12512 type Type = Self;
12513}
12514
12515#[allow(deprecated)]
12516unsafe impl<'a> glib::value::FromValue<'a> for TreeViewGridLines {
12517 type Checker = glib::value::GenericValueTypeChecker<Self>;
12518
12519 #[inline]
12520 unsafe fn from_value(value: &'a glib::Value) -> Self {
12521 skip_assert_initialized!();
12522 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
12523 }
12524}
12525
12526#[allow(deprecated)]
12527impl ToValue for TreeViewGridLines {
12528 #[inline]
12529 fn to_value(&self) -> glib::Value {
12530 let mut value = glib::Value::for_value_type::<Self>();
12531 unsafe {
12532 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
12533 }
12534 value
12535 }
12536
12537 #[inline]
12538 fn value_type(&self) -> glib::Type {
12539 Self::static_type()
12540 }
12541}
12542
12543#[allow(deprecated)]
12544impl From<TreeViewGridLines> for glib::Value {
12545 #[inline]
12546 fn from(v: TreeViewGridLines) -> Self {
12547 skip_assert_initialized!();
12548 ToValue::to_value(&v)
12549 }
12550}
12551
12552#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
12553#[non_exhaustive]
12554#[doc(alias = "GtkUnit")]
12555pub enum Unit {
12556 #[doc(alias = "GTK_UNIT_NONE")]
12557 None,
12558 #[doc(alias = "GTK_UNIT_POINTS")]
12559 Points,
12560 #[doc(alias = "GTK_UNIT_INCH")]
12561 Inch,
12562 #[doc(alias = "GTK_UNIT_MM")]
12563 Mm,
12564 #[doc(hidden)]
12565 __Unknown(i32),
12566}
12567
12568#[doc(hidden)]
12569impl IntoGlib for Unit {
12570 type GlibType = ffi::GtkUnit;
12571
12572 #[inline]
12573 fn into_glib(self) -> ffi::GtkUnit {
12574 match self {
12575 Self::None => ffi::GTK_UNIT_NONE,
12576 Self::Points => ffi::GTK_UNIT_POINTS,
12577 Self::Inch => ffi::GTK_UNIT_INCH,
12578 Self::Mm => ffi::GTK_UNIT_MM,
12579 Self::__Unknown(value) => value,
12580 }
12581 }
12582}
12583
12584#[doc(hidden)]
12585impl FromGlib<ffi::GtkUnit> for Unit {
12586 #[inline]
12587 unsafe fn from_glib(value: ffi::GtkUnit) -> Self {
12588 skip_assert_initialized!();
12589
12590 match value {
12591 ffi::GTK_UNIT_NONE => Self::None,
12592 ffi::GTK_UNIT_POINTS => Self::Points,
12593 ffi::GTK_UNIT_INCH => Self::Inch,
12594 ffi::GTK_UNIT_MM => Self::Mm,
12595 value => Self::__Unknown(value),
12596 }
12597 }
12598}
12599
12600impl StaticType for Unit {
12601 #[inline]
12602 #[doc(alias = "gtk_unit_get_type")]
12603 fn static_type() -> glib::Type {
12604 unsafe { from_glib(ffi::gtk_unit_get_type()) }
12605 }
12606}
12607
12608impl glib::HasParamSpec for Unit {
12609 type ParamSpec = glib::ParamSpecEnum;
12610 type SetValue = Self;
12611 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
12612
12613 fn param_spec_builder() -> Self::BuilderFn {
12614 Self::ParamSpec::builder_with_default
12615 }
12616}
12617
12618impl glib::value::ValueType for Unit {
12619 type Type = Self;
12620}
12621
12622unsafe impl<'a> glib::value::FromValue<'a> for Unit {
12623 type Checker = glib::value::GenericValueTypeChecker<Self>;
12624
12625 #[inline]
12626 unsafe fn from_value(value: &'a glib::Value) -> Self {
12627 skip_assert_initialized!();
12628 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
12629 }
12630}
12631
12632impl ToValue for Unit {
12633 #[inline]
12634 fn to_value(&self) -> glib::Value {
12635 let mut value = glib::Value::for_value_type::<Self>();
12636 unsafe {
12637 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
12638 }
12639 value
12640 }
12641
12642 #[inline]
12643 fn value_type(&self) -> glib::Type {
12644 Self::static_type()
12645 }
12646}
12647
12648impl From<Unit> for glib::Value {
12649 #[inline]
12650 fn from(v: Unit) -> Self {
12651 skip_assert_initialized!();
12652 ToValue::to_value(&v)
12653 }
12654}
12655
12656#[cfg(feature = "v4_20")]
12657#[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
12658#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
12659#[non_exhaustive]
12660#[doc(alias = "GtkWindowGravity")]
12661pub enum WindowGravity {
12662 #[doc(alias = "GTK_WINDOW_GRAVITY_TOP_LEFT")]
12663 TopLeft,
12664 #[doc(alias = "GTK_WINDOW_GRAVITY_TOP")]
12665 Top,
12666 #[doc(alias = "GTK_WINDOW_GRAVITY_TOP_RIGHT")]
12667 TopRight,
12668 #[doc(alias = "GTK_WINDOW_GRAVITY_LEFT")]
12669 Left,
12670 #[doc(alias = "GTK_WINDOW_GRAVITY_CENTER")]
12671 Center,
12672 #[doc(alias = "GTK_WINDOW_GRAVITY_RIGHT")]
12673 Right,
12674 #[doc(alias = "GTK_WINDOW_GRAVITY_BOTTOM_LEFT")]
12675 BottomLeft,
12676 #[doc(alias = "GTK_WINDOW_GRAVITY_BOTTOM")]
12677 Bottom,
12678 #[doc(alias = "GTK_WINDOW_GRAVITY_BOTTOM_RIGHT")]
12679 BottomRight,
12680 #[doc(alias = "GTK_WINDOW_GRAVITY_TOP_START")]
12681 TopStart,
12682 #[doc(alias = "GTK_WINDOW_GRAVITY_TOP_END")]
12683 TopEnd,
12684 #[doc(alias = "GTK_WINDOW_GRAVITY_START")]
12685 Start,
12686 #[doc(alias = "GTK_WINDOW_GRAVITY_END")]
12687 End,
12688 #[doc(alias = "GTK_WINDOW_GRAVITY_BOTTOM_START")]
12689 BottomStart,
12690 #[doc(alias = "GTK_WINDOW_GRAVITY_BOTTOM_END")]
12691 BottomEnd,
12692 #[doc(hidden)]
12693 __Unknown(i32),
12694}
12695
12696#[cfg(feature = "v4_20")]
12697#[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
12698#[doc(hidden)]
12699impl IntoGlib for WindowGravity {
12700 type GlibType = ffi::GtkWindowGravity;
12701
12702 fn into_glib(self) -> ffi::GtkWindowGravity {
12703 match self {
12704 Self::TopLeft => ffi::GTK_WINDOW_GRAVITY_TOP_LEFT,
12705 Self::Top => ffi::GTK_WINDOW_GRAVITY_TOP,
12706 Self::TopRight => ffi::GTK_WINDOW_GRAVITY_TOP_RIGHT,
12707 Self::Left => ffi::GTK_WINDOW_GRAVITY_LEFT,
12708 Self::Center => ffi::GTK_WINDOW_GRAVITY_CENTER,
12709 Self::Right => ffi::GTK_WINDOW_GRAVITY_RIGHT,
12710 Self::BottomLeft => ffi::GTK_WINDOW_GRAVITY_BOTTOM_LEFT,
12711 Self::Bottom => ffi::GTK_WINDOW_GRAVITY_BOTTOM,
12712 Self::BottomRight => ffi::GTK_WINDOW_GRAVITY_BOTTOM_RIGHT,
12713 Self::TopStart => ffi::GTK_WINDOW_GRAVITY_TOP_START,
12714 Self::TopEnd => ffi::GTK_WINDOW_GRAVITY_TOP_END,
12715 Self::Start => ffi::GTK_WINDOW_GRAVITY_START,
12716 Self::End => ffi::GTK_WINDOW_GRAVITY_END,
12717 Self::BottomStart => ffi::GTK_WINDOW_GRAVITY_BOTTOM_START,
12718 Self::BottomEnd => ffi::GTK_WINDOW_GRAVITY_BOTTOM_END,
12719 Self::__Unknown(value) => value,
12720 }
12721 }
12722}
12723
12724#[cfg(feature = "v4_20")]
12725#[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
12726#[doc(hidden)]
12727impl FromGlib<ffi::GtkWindowGravity> for WindowGravity {
12728 unsafe fn from_glib(value: ffi::GtkWindowGravity) -> Self {
12729 skip_assert_initialized!();
12730
12731 match value {
12732 ffi::GTK_WINDOW_GRAVITY_TOP_LEFT => Self::TopLeft,
12733 ffi::GTK_WINDOW_GRAVITY_TOP => Self::Top,
12734 ffi::GTK_WINDOW_GRAVITY_TOP_RIGHT => Self::TopRight,
12735 ffi::GTK_WINDOW_GRAVITY_LEFT => Self::Left,
12736 ffi::GTK_WINDOW_GRAVITY_CENTER => Self::Center,
12737 ffi::GTK_WINDOW_GRAVITY_RIGHT => Self::Right,
12738 ffi::GTK_WINDOW_GRAVITY_BOTTOM_LEFT => Self::BottomLeft,
12739 ffi::GTK_WINDOW_GRAVITY_BOTTOM => Self::Bottom,
12740 ffi::GTK_WINDOW_GRAVITY_BOTTOM_RIGHT => Self::BottomRight,
12741 ffi::GTK_WINDOW_GRAVITY_TOP_START => Self::TopStart,
12742 ffi::GTK_WINDOW_GRAVITY_TOP_END => Self::TopEnd,
12743 ffi::GTK_WINDOW_GRAVITY_START => Self::Start,
12744 ffi::GTK_WINDOW_GRAVITY_END => Self::End,
12745 ffi::GTK_WINDOW_GRAVITY_BOTTOM_START => Self::BottomStart,
12746 ffi::GTK_WINDOW_GRAVITY_BOTTOM_END => Self::BottomEnd,
12747 value => Self::__Unknown(value),
12748 }
12749 }
12750}
12751
12752#[cfg(feature = "v4_20")]
12753#[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
12754impl StaticType for WindowGravity {
12755 #[inline]
12756 #[doc(alias = "gtk_window_gravity_get_type")]
12757 fn static_type() -> glib::Type {
12758 unsafe { from_glib(ffi::gtk_window_gravity_get_type()) }
12759 }
12760}
12761
12762#[cfg(feature = "v4_20")]
12763#[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
12764impl glib::HasParamSpec for WindowGravity {
12765 type ParamSpec = glib::ParamSpecEnum;
12766 type SetValue = Self;
12767 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
12768
12769 fn param_spec_builder() -> Self::BuilderFn {
12770 Self::ParamSpec::builder_with_default
12771 }
12772}
12773
12774#[cfg(feature = "v4_20")]
12775#[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
12776impl glib::value::ValueType for WindowGravity {
12777 type Type = Self;
12778}
12779
12780#[cfg(feature = "v4_20")]
12781#[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
12782unsafe impl<'a> glib::value::FromValue<'a> for WindowGravity {
12783 type Checker = glib::value::GenericValueTypeChecker<Self>;
12784
12785 #[inline]
12786 unsafe fn from_value(value: &'a glib::Value) -> Self {
12787 skip_assert_initialized!();
12788 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
12789 }
12790}
12791
12792#[cfg(feature = "v4_20")]
12793#[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
12794impl ToValue for WindowGravity {
12795 #[inline]
12796 fn to_value(&self) -> glib::Value {
12797 let mut value = glib::Value::for_value_type::<Self>();
12798 unsafe {
12799 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
12800 }
12801 value
12802 }
12803
12804 #[inline]
12805 fn value_type(&self) -> glib::Type {
12806 Self::static_type()
12807 }
12808}
12809
12810#[cfg(feature = "v4_20")]
12811#[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
12812impl From<WindowGravity> for glib::Value {
12813 #[inline]
12814 fn from(v: WindowGravity) -> Self {
12815 skip_assert_initialized!();
12816 ToValue::to_value(&v)
12817 }
12818}
12819
12820#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
12821#[non_exhaustive]
12822#[doc(alias = "GtkWrapMode")]
12823pub enum WrapMode {
12824 #[doc(alias = "GTK_WRAP_NONE")]
12825 None,
12826 #[doc(alias = "GTK_WRAP_CHAR")]
12827 Char,
12828 #[doc(alias = "GTK_WRAP_WORD")]
12829 Word,
12830 #[doc(alias = "GTK_WRAP_WORD_CHAR")]
12831 WordChar,
12832 #[doc(hidden)]
12833 __Unknown(i32),
12834}
12835
12836#[doc(hidden)]
12837impl IntoGlib for WrapMode {
12838 type GlibType = ffi::GtkWrapMode;
12839
12840 #[inline]
12841 fn into_glib(self) -> ffi::GtkWrapMode {
12842 match self {
12843 Self::None => ffi::GTK_WRAP_NONE,
12844 Self::Char => ffi::GTK_WRAP_CHAR,
12845 Self::Word => ffi::GTK_WRAP_WORD,
12846 Self::WordChar => ffi::GTK_WRAP_WORD_CHAR,
12847 Self::__Unknown(value) => value,
12848 }
12849 }
12850}
12851
12852#[doc(hidden)]
12853impl FromGlib<ffi::GtkWrapMode> for WrapMode {
12854 #[inline]
12855 unsafe fn from_glib(value: ffi::GtkWrapMode) -> Self {
12856 skip_assert_initialized!();
12857
12858 match value {
12859 ffi::GTK_WRAP_NONE => Self::None,
12860 ffi::GTK_WRAP_CHAR => Self::Char,
12861 ffi::GTK_WRAP_WORD => Self::Word,
12862 ffi::GTK_WRAP_WORD_CHAR => Self::WordChar,
12863 value => Self::__Unknown(value),
12864 }
12865 }
12866}
12867
12868impl StaticType for WrapMode {
12869 #[inline]
12870 #[doc(alias = "gtk_wrap_mode_get_type")]
12871 fn static_type() -> glib::Type {
12872 unsafe { from_glib(ffi::gtk_wrap_mode_get_type()) }
12873 }
12874}
12875
12876impl glib::HasParamSpec for WrapMode {
12877 type ParamSpec = glib::ParamSpecEnum;
12878 type SetValue = Self;
12879 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
12880
12881 fn param_spec_builder() -> Self::BuilderFn {
12882 Self::ParamSpec::builder_with_default
12883 }
12884}
12885
12886impl glib::value::ValueType for WrapMode {
12887 type Type = Self;
12888}
12889
12890unsafe impl<'a> glib::value::FromValue<'a> for WrapMode {
12891 type Checker = glib::value::GenericValueTypeChecker<Self>;
12892
12893 #[inline]
12894 unsafe fn from_value(value: &'a glib::Value) -> Self {
12895 skip_assert_initialized!();
12896 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
12897 }
12898}
12899
12900impl ToValue for WrapMode {
12901 #[inline]
12902 fn to_value(&self) -> glib::Value {
12903 let mut value = glib::Value::for_value_type::<Self>();
12904 unsafe {
12905 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
12906 }
12907 value
12908 }
12909
12910 #[inline]
12911 fn value_type(&self) -> glib::Type {
12912 Self::static_type()
12913 }
12914}
12915
12916impl From<WrapMode> for glib::Value {
12917 #[inline]
12918 fn from(v: WrapMode) -> Self {
12919 skip_assert_initialized!();
12920 ToValue::to_value(&v)
12921 }
12922}