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 Symbol,
3300 #[doc(alias = "GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_ATTRIBUTE")]
3301 Attribute,
3302 #[doc(alias = "GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_VIEW")]
3303 View,
3304 #[doc(alias = "GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_METRIC")]
3305 Metric,
3306 #[doc(alias = "GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_PRIORITY")]
3307 Priority,
3308 #[doc(alias = "GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_RELATION")]
3309 Relation,
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::Symbol => ffi::GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_SYMBOL,
3322 Self::Attribute => ffi::GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_ATTRIBUTE,
3323 Self::View => ffi::GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_VIEW,
3324 Self::Metric => ffi::GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_METRIC,
3325 Self::Priority => ffi::GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_PRIORITY,
3326 Self::Relation => 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::Symbol,
3340 ffi::GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_ATTRIBUTE => Self::Attribute,
3341 ffi::GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_VIEW => Self::View,
3342 ffi::GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_METRIC => Self::Metric,
3343 ffi::GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_PRIORITY => Self::Priority,
3344 ffi::GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_RELATION => Self::Relation,
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 #[doc(hidden)]
4719 __Unknown(i32),
4720}
4721
4722#[doc(hidden)]
4723impl IntoGlib for FilterChange {
4724 type GlibType = ffi::GtkFilterChange;
4725
4726 #[inline]
4727 fn into_glib(self) -> ffi::GtkFilterChange {
4728 match self {
4729 Self::Different => ffi::GTK_FILTER_CHANGE_DIFFERENT,
4730 Self::LessStrict => ffi::GTK_FILTER_CHANGE_LESS_STRICT,
4731 Self::MoreStrict => ffi::GTK_FILTER_CHANGE_MORE_STRICT,
4732 Self::__Unknown(value) => value,
4733 }
4734 }
4735}
4736
4737#[doc(hidden)]
4738impl FromGlib<ffi::GtkFilterChange> for FilterChange {
4739 #[inline]
4740 unsafe fn from_glib(value: ffi::GtkFilterChange) -> Self {
4741 skip_assert_initialized!();
4742
4743 match value {
4744 ffi::GTK_FILTER_CHANGE_DIFFERENT => Self::Different,
4745 ffi::GTK_FILTER_CHANGE_LESS_STRICT => Self::LessStrict,
4746 ffi::GTK_FILTER_CHANGE_MORE_STRICT => Self::MoreStrict,
4747 value => Self::__Unknown(value),
4748 }
4749 }
4750}
4751
4752impl StaticType for FilterChange {
4753 #[inline]
4754 #[doc(alias = "gtk_filter_change_get_type")]
4755 fn static_type() -> glib::Type {
4756 unsafe { from_glib(ffi::gtk_filter_change_get_type()) }
4757 }
4758}
4759
4760impl glib::HasParamSpec for FilterChange {
4761 type ParamSpec = glib::ParamSpecEnum;
4762 type SetValue = Self;
4763 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
4764
4765 fn param_spec_builder() -> Self::BuilderFn {
4766 Self::ParamSpec::builder_with_default
4767 }
4768}
4769
4770impl glib::value::ValueType for FilterChange {
4771 type Type = Self;
4772}
4773
4774unsafe impl<'a> glib::value::FromValue<'a> for FilterChange {
4775 type Checker = glib::value::GenericValueTypeChecker<Self>;
4776
4777 #[inline]
4778 unsafe fn from_value(value: &'a glib::Value) -> Self {
4779 skip_assert_initialized!();
4780 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
4781 }
4782}
4783
4784impl ToValue for FilterChange {
4785 #[inline]
4786 fn to_value(&self) -> glib::Value {
4787 let mut value = glib::Value::for_value_type::<Self>();
4788 unsafe {
4789 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
4790 }
4791 value
4792 }
4793
4794 #[inline]
4795 fn value_type(&self) -> glib::Type {
4796 Self::static_type()
4797 }
4798}
4799
4800impl From<FilterChange> for glib::Value {
4801 #[inline]
4802 fn from(v: FilterChange) -> Self {
4803 skip_assert_initialized!();
4804 ToValue::to_value(&v)
4805 }
4806}
4807
4808#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
4809#[non_exhaustive]
4810#[doc(alias = "GtkFilterMatch")]
4811pub enum FilterMatch {
4812 #[doc(alias = "GTK_FILTER_MATCH_SOME")]
4813 Some,
4814 #[doc(alias = "GTK_FILTER_MATCH_NONE")]
4815 None,
4816 #[doc(alias = "GTK_FILTER_MATCH_ALL")]
4817 All,
4818 #[doc(hidden)]
4819 __Unknown(i32),
4820}
4821
4822#[doc(hidden)]
4823impl IntoGlib for FilterMatch {
4824 type GlibType = ffi::GtkFilterMatch;
4825
4826 #[inline]
4827 fn into_glib(self) -> ffi::GtkFilterMatch {
4828 match self {
4829 Self::Some => ffi::GTK_FILTER_MATCH_SOME,
4830 Self::None => ffi::GTK_FILTER_MATCH_NONE,
4831 Self::All => ffi::GTK_FILTER_MATCH_ALL,
4832 Self::__Unknown(value) => value,
4833 }
4834 }
4835}
4836
4837#[doc(hidden)]
4838impl FromGlib<ffi::GtkFilterMatch> for FilterMatch {
4839 #[inline]
4840 unsafe fn from_glib(value: ffi::GtkFilterMatch) -> Self {
4841 skip_assert_initialized!();
4842
4843 match value {
4844 ffi::GTK_FILTER_MATCH_SOME => Self::Some,
4845 ffi::GTK_FILTER_MATCH_NONE => Self::None,
4846 ffi::GTK_FILTER_MATCH_ALL => Self::All,
4847 value => Self::__Unknown(value),
4848 }
4849 }
4850}
4851
4852impl StaticType for FilterMatch {
4853 #[inline]
4854 #[doc(alias = "gtk_filter_match_get_type")]
4855 fn static_type() -> glib::Type {
4856 unsafe { from_glib(ffi::gtk_filter_match_get_type()) }
4857 }
4858}
4859
4860impl glib::HasParamSpec for FilterMatch {
4861 type ParamSpec = glib::ParamSpecEnum;
4862 type SetValue = Self;
4863 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
4864
4865 fn param_spec_builder() -> Self::BuilderFn {
4866 Self::ParamSpec::builder_with_default
4867 }
4868}
4869
4870impl glib::value::ValueType for FilterMatch {
4871 type Type = Self;
4872}
4873
4874unsafe impl<'a> glib::value::FromValue<'a> for FilterMatch {
4875 type Checker = glib::value::GenericValueTypeChecker<Self>;
4876
4877 #[inline]
4878 unsafe fn from_value(value: &'a glib::Value) -> Self {
4879 skip_assert_initialized!();
4880 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
4881 }
4882}
4883
4884impl ToValue for FilterMatch {
4885 #[inline]
4886 fn to_value(&self) -> glib::Value {
4887 let mut value = glib::Value::for_value_type::<Self>();
4888 unsafe {
4889 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
4890 }
4891 value
4892 }
4893
4894 #[inline]
4895 fn value_type(&self) -> glib::Type {
4896 Self::static_type()
4897 }
4898}
4899
4900impl From<FilterMatch> for glib::Value {
4901 #[inline]
4902 fn from(v: FilterMatch) -> Self {
4903 skip_assert_initialized!();
4904 ToValue::to_value(&v)
4905 }
4906}
4907
4908#[cfg(feature = "v4_10")]
4909#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
4910#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
4911#[non_exhaustive]
4912#[doc(alias = "GtkFontLevel")]
4913pub enum FontLevel {
4914 #[doc(alias = "GTK_FONT_LEVEL_FAMILY")]
4915 Family,
4916 #[doc(alias = "GTK_FONT_LEVEL_FACE")]
4917 Face,
4918 #[doc(alias = "GTK_FONT_LEVEL_FONT")]
4919 Font,
4920 #[doc(alias = "GTK_FONT_LEVEL_FEATURES")]
4921 Features,
4922 #[doc(hidden)]
4923 __Unknown(i32),
4924}
4925
4926#[cfg(feature = "v4_10")]
4927#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
4928#[doc(hidden)]
4929impl IntoGlib for FontLevel {
4930 type GlibType = ffi::GtkFontLevel;
4931
4932 #[inline]
4933 fn into_glib(self) -> ffi::GtkFontLevel {
4934 match self {
4935 Self::Family => ffi::GTK_FONT_LEVEL_FAMILY,
4936 Self::Face => ffi::GTK_FONT_LEVEL_FACE,
4937 Self::Font => ffi::GTK_FONT_LEVEL_FONT,
4938 Self::Features => ffi::GTK_FONT_LEVEL_FEATURES,
4939 Self::__Unknown(value) => value,
4940 }
4941 }
4942}
4943
4944#[cfg(feature = "v4_10")]
4945#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
4946#[doc(hidden)]
4947impl FromGlib<ffi::GtkFontLevel> for FontLevel {
4948 #[inline]
4949 unsafe fn from_glib(value: ffi::GtkFontLevel) -> Self {
4950 skip_assert_initialized!();
4951
4952 match value {
4953 ffi::GTK_FONT_LEVEL_FAMILY => Self::Family,
4954 ffi::GTK_FONT_LEVEL_FACE => Self::Face,
4955 ffi::GTK_FONT_LEVEL_FONT => Self::Font,
4956 ffi::GTK_FONT_LEVEL_FEATURES => Self::Features,
4957 value => Self::__Unknown(value),
4958 }
4959 }
4960}
4961
4962#[cfg(feature = "v4_10")]
4963#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
4964impl StaticType for FontLevel {
4965 #[inline]
4966 #[doc(alias = "gtk_font_level_get_type")]
4967 fn static_type() -> glib::Type {
4968 unsafe { from_glib(ffi::gtk_font_level_get_type()) }
4969 }
4970}
4971
4972#[cfg(feature = "v4_10")]
4973#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
4974impl glib::HasParamSpec for FontLevel {
4975 type ParamSpec = glib::ParamSpecEnum;
4976 type SetValue = Self;
4977 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
4978
4979 fn param_spec_builder() -> Self::BuilderFn {
4980 Self::ParamSpec::builder_with_default
4981 }
4982}
4983
4984#[cfg(feature = "v4_10")]
4985#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
4986impl glib::value::ValueType for FontLevel {
4987 type Type = Self;
4988}
4989
4990#[cfg(feature = "v4_10")]
4991#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
4992unsafe impl<'a> glib::value::FromValue<'a> for FontLevel {
4993 type Checker = glib::value::GenericValueTypeChecker<Self>;
4994
4995 #[inline]
4996 unsafe fn from_value(value: &'a glib::Value) -> Self {
4997 skip_assert_initialized!();
4998 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
4999 }
5000}
5001
5002#[cfg(feature = "v4_10")]
5003#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
5004impl ToValue for FontLevel {
5005 #[inline]
5006 fn to_value(&self) -> glib::Value {
5007 let mut value = glib::Value::for_value_type::<Self>();
5008 unsafe {
5009 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
5010 }
5011 value
5012 }
5013
5014 #[inline]
5015 fn value_type(&self) -> glib::Type {
5016 Self::static_type()
5017 }
5018}
5019
5020#[cfg(feature = "v4_10")]
5021#[cfg_attr(docsrs, doc(cfg(feature = "v4_10")))]
5022impl From<FontLevel> for glib::Value {
5023 #[inline]
5024 fn from(v: FontLevel) -> Self {
5025 skip_assert_initialized!();
5026 ToValue::to_value(&v)
5027 }
5028}
5029
5030#[cfg(feature = "v4_16")]
5031#[cfg_attr(docsrs, doc(cfg(feature = "v4_16")))]
5032#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
5033#[non_exhaustive]
5034#[doc(alias = "GtkFontRendering")]
5035pub enum FontRendering {
5036 #[doc(alias = "GTK_FONT_RENDERING_AUTOMATIC")]
5037 Automatic,
5038 #[doc(alias = "GTK_FONT_RENDERING_MANUAL")]
5039 Manual,
5040 #[doc(hidden)]
5041 __Unknown(i32),
5042}
5043
5044#[cfg(feature = "v4_16")]
5045#[cfg_attr(docsrs, doc(cfg(feature = "v4_16")))]
5046#[doc(hidden)]
5047impl IntoGlib for FontRendering {
5048 type GlibType = ffi::GtkFontRendering;
5049
5050 #[inline]
5051 fn into_glib(self) -> ffi::GtkFontRendering {
5052 match self {
5053 Self::Automatic => ffi::GTK_FONT_RENDERING_AUTOMATIC,
5054 Self::Manual => ffi::GTK_FONT_RENDERING_MANUAL,
5055 Self::__Unknown(value) => value,
5056 }
5057 }
5058}
5059
5060#[cfg(feature = "v4_16")]
5061#[cfg_attr(docsrs, doc(cfg(feature = "v4_16")))]
5062#[doc(hidden)]
5063impl FromGlib<ffi::GtkFontRendering> for FontRendering {
5064 #[inline]
5065 unsafe fn from_glib(value: ffi::GtkFontRendering) -> Self {
5066 skip_assert_initialized!();
5067
5068 match value {
5069 ffi::GTK_FONT_RENDERING_AUTOMATIC => Self::Automatic,
5070 ffi::GTK_FONT_RENDERING_MANUAL => Self::Manual,
5071 value => Self::__Unknown(value),
5072 }
5073 }
5074}
5075
5076#[cfg(feature = "v4_16")]
5077#[cfg_attr(docsrs, doc(cfg(feature = "v4_16")))]
5078impl StaticType for FontRendering {
5079 #[inline]
5080 #[doc(alias = "gtk_font_rendering_get_type")]
5081 fn static_type() -> glib::Type {
5082 unsafe { from_glib(ffi::gtk_font_rendering_get_type()) }
5083 }
5084}
5085
5086#[cfg(feature = "v4_16")]
5087#[cfg_attr(docsrs, doc(cfg(feature = "v4_16")))]
5088impl glib::HasParamSpec for FontRendering {
5089 type ParamSpec = glib::ParamSpecEnum;
5090 type SetValue = Self;
5091 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
5092
5093 fn param_spec_builder() -> Self::BuilderFn {
5094 Self::ParamSpec::builder_with_default
5095 }
5096}
5097
5098#[cfg(feature = "v4_16")]
5099#[cfg_attr(docsrs, doc(cfg(feature = "v4_16")))]
5100impl glib::value::ValueType for FontRendering {
5101 type Type = Self;
5102}
5103
5104#[cfg(feature = "v4_16")]
5105#[cfg_attr(docsrs, doc(cfg(feature = "v4_16")))]
5106unsafe impl<'a> glib::value::FromValue<'a> for FontRendering {
5107 type Checker = glib::value::GenericValueTypeChecker<Self>;
5108
5109 #[inline]
5110 unsafe fn from_value(value: &'a glib::Value) -> Self {
5111 skip_assert_initialized!();
5112 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
5113 }
5114}
5115
5116#[cfg(feature = "v4_16")]
5117#[cfg_attr(docsrs, doc(cfg(feature = "v4_16")))]
5118impl ToValue for FontRendering {
5119 #[inline]
5120 fn to_value(&self) -> glib::Value {
5121 let mut value = glib::Value::for_value_type::<Self>();
5122 unsafe {
5123 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
5124 }
5125 value
5126 }
5127
5128 #[inline]
5129 fn value_type(&self) -> glib::Type {
5130 Self::static_type()
5131 }
5132}
5133
5134#[cfg(feature = "v4_16")]
5135#[cfg_attr(docsrs, doc(cfg(feature = "v4_16")))]
5136impl From<FontRendering> for glib::Value {
5137 #[inline]
5138 fn from(v: FontRendering) -> Self {
5139 skip_assert_initialized!();
5140 ToValue::to_value(&v)
5141 }
5142}
5143
5144#[cfg(feature = "v4_14")]
5145#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
5146#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
5147#[non_exhaustive]
5148#[doc(alias = "GtkGraphicsOffloadEnabled")]
5149pub enum GraphicsOffloadEnabled {
5150 #[doc(alias = "GTK_GRAPHICS_OFFLOAD_ENABLED")]
5151 Enabled,
5152 #[doc(alias = "GTK_GRAPHICS_OFFLOAD_DISABLED")]
5153 Disabled,
5154 #[doc(hidden)]
5155 __Unknown(i32),
5156}
5157
5158#[cfg(feature = "v4_14")]
5159#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
5160#[doc(hidden)]
5161impl IntoGlib for GraphicsOffloadEnabled {
5162 type GlibType = ffi::GtkGraphicsOffloadEnabled;
5163
5164 #[inline]
5165 fn into_glib(self) -> ffi::GtkGraphicsOffloadEnabled {
5166 match self {
5167 Self::Enabled => ffi::GTK_GRAPHICS_OFFLOAD_ENABLED,
5168 Self::Disabled => ffi::GTK_GRAPHICS_OFFLOAD_DISABLED,
5169 Self::__Unknown(value) => value,
5170 }
5171 }
5172}
5173
5174#[cfg(feature = "v4_14")]
5175#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
5176#[doc(hidden)]
5177impl FromGlib<ffi::GtkGraphicsOffloadEnabled> for GraphicsOffloadEnabled {
5178 #[inline]
5179 unsafe fn from_glib(value: ffi::GtkGraphicsOffloadEnabled) -> Self {
5180 skip_assert_initialized!();
5181
5182 match value {
5183 ffi::GTK_GRAPHICS_OFFLOAD_ENABLED => Self::Enabled,
5184 ffi::GTK_GRAPHICS_OFFLOAD_DISABLED => Self::Disabled,
5185 value => Self::__Unknown(value),
5186 }
5187 }
5188}
5189
5190#[cfg(feature = "v4_14")]
5191#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
5192impl StaticType for GraphicsOffloadEnabled {
5193 #[inline]
5194 #[doc(alias = "gtk_graphics_offload_enabled_get_type")]
5195 fn static_type() -> glib::Type {
5196 unsafe { from_glib(ffi::gtk_graphics_offload_enabled_get_type()) }
5197 }
5198}
5199
5200#[cfg(feature = "v4_14")]
5201#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
5202impl glib::HasParamSpec for GraphicsOffloadEnabled {
5203 type ParamSpec = glib::ParamSpecEnum;
5204 type SetValue = Self;
5205 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
5206
5207 fn param_spec_builder() -> Self::BuilderFn {
5208 Self::ParamSpec::builder_with_default
5209 }
5210}
5211
5212#[cfg(feature = "v4_14")]
5213#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
5214impl glib::value::ValueType for GraphicsOffloadEnabled {
5215 type Type = Self;
5216}
5217
5218#[cfg(feature = "v4_14")]
5219#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
5220unsafe impl<'a> glib::value::FromValue<'a> for GraphicsOffloadEnabled {
5221 type Checker = glib::value::GenericValueTypeChecker<Self>;
5222
5223 #[inline]
5224 unsafe fn from_value(value: &'a glib::Value) -> Self {
5225 skip_assert_initialized!();
5226 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
5227 }
5228}
5229
5230#[cfg(feature = "v4_14")]
5231#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
5232impl ToValue for GraphicsOffloadEnabled {
5233 #[inline]
5234 fn to_value(&self) -> glib::Value {
5235 let mut value = glib::Value::for_value_type::<Self>();
5236 unsafe {
5237 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
5238 }
5239 value
5240 }
5241
5242 #[inline]
5243 fn value_type(&self) -> glib::Type {
5244 Self::static_type()
5245 }
5246}
5247
5248#[cfg(feature = "v4_14")]
5249#[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
5250impl From<GraphicsOffloadEnabled> for glib::Value {
5251 #[inline]
5252 fn from(v: GraphicsOffloadEnabled) -> Self {
5253 skip_assert_initialized!();
5254 ToValue::to_value(&v)
5255 }
5256}
5257
5258#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
5259#[non_exhaustive]
5260#[doc(alias = "GtkIconSize")]
5261pub enum IconSize {
5262 #[doc(alias = "GTK_ICON_SIZE_INHERIT")]
5263 Inherit,
5264 #[doc(alias = "GTK_ICON_SIZE_NORMAL")]
5265 Normal,
5266 #[doc(alias = "GTK_ICON_SIZE_LARGE")]
5267 Large,
5268 #[doc(hidden)]
5269 __Unknown(i32),
5270}
5271
5272#[doc(hidden)]
5273impl IntoGlib for IconSize {
5274 type GlibType = ffi::GtkIconSize;
5275
5276 #[inline]
5277 fn into_glib(self) -> ffi::GtkIconSize {
5278 match self {
5279 Self::Inherit => ffi::GTK_ICON_SIZE_INHERIT,
5280 Self::Normal => ffi::GTK_ICON_SIZE_NORMAL,
5281 Self::Large => ffi::GTK_ICON_SIZE_LARGE,
5282 Self::__Unknown(value) => value,
5283 }
5284 }
5285}
5286
5287#[doc(hidden)]
5288impl FromGlib<ffi::GtkIconSize> for IconSize {
5289 #[inline]
5290 unsafe fn from_glib(value: ffi::GtkIconSize) -> Self {
5291 skip_assert_initialized!();
5292
5293 match value {
5294 ffi::GTK_ICON_SIZE_INHERIT => Self::Inherit,
5295 ffi::GTK_ICON_SIZE_NORMAL => Self::Normal,
5296 ffi::GTK_ICON_SIZE_LARGE => Self::Large,
5297 value => Self::__Unknown(value),
5298 }
5299 }
5300}
5301
5302impl StaticType for IconSize {
5303 #[inline]
5304 #[doc(alias = "gtk_icon_size_get_type")]
5305 fn static_type() -> glib::Type {
5306 unsafe { from_glib(ffi::gtk_icon_size_get_type()) }
5307 }
5308}
5309
5310impl glib::HasParamSpec for IconSize {
5311 type ParamSpec = glib::ParamSpecEnum;
5312 type SetValue = Self;
5313 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
5314
5315 fn param_spec_builder() -> Self::BuilderFn {
5316 Self::ParamSpec::builder_with_default
5317 }
5318}
5319
5320impl glib::value::ValueType for IconSize {
5321 type Type = Self;
5322}
5323
5324unsafe impl<'a> glib::value::FromValue<'a> for IconSize {
5325 type Checker = glib::value::GenericValueTypeChecker<Self>;
5326
5327 #[inline]
5328 unsafe fn from_value(value: &'a glib::Value) -> Self {
5329 skip_assert_initialized!();
5330 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
5331 }
5332}
5333
5334impl ToValue for IconSize {
5335 #[inline]
5336 fn to_value(&self) -> glib::Value {
5337 let mut value = glib::Value::for_value_type::<Self>();
5338 unsafe {
5339 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
5340 }
5341 value
5342 }
5343
5344 #[inline]
5345 fn value_type(&self) -> glib::Type {
5346 Self::static_type()
5347 }
5348}
5349
5350impl From<IconSize> for glib::Value {
5351 #[inline]
5352 fn from(v: IconSize) -> Self {
5353 skip_assert_initialized!();
5354 ToValue::to_value(&v)
5355 }
5356}
5357
5358#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
5359#[non_exhaustive]
5360#[doc(alias = "GtkIconThemeError")]
5361pub enum IconThemeError {
5362 #[doc(alias = "GTK_ICON_THEME_NOT_FOUND")]
5363 NotFound,
5364 #[doc(alias = "GTK_ICON_THEME_FAILED")]
5365 Failed,
5366 #[doc(hidden)]
5367 __Unknown(i32),
5368}
5369
5370#[doc(hidden)]
5371impl IntoGlib for IconThemeError {
5372 type GlibType = ffi::GtkIconThemeError;
5373
5374 #[inline]
5375 fn into_glib(self) -> ffi::GtkIconThemeError {
5376 match self {
5377 Self::NotFound => ffi::GTK_ICON_THEME_NOT_FOUND,
5378 Self::Failed => ffi::GTK_ICON_THEME_FAILED,
5379 Self::__Unknown(value) => value,
5380 }
5381 }
5382}
5383
5384#[doc(hidden)]
5385impl FromGlib<ffi::GtkIconThemeError> for IconThemeError {
5386 #[inline]
5387 unsafe fn from_glib(value: ffi::GtkIconThemeError) -> Self {
5388 skip_assert_initialized!();
5389
5390 match value {
5391 ffi::GTK_ICON_THEME_NOT_FOUND => Self::NotFound,
5392 ffi::GTK_ICON_THEME_FAILED => Self::Failed,
5393 value => Self::__Unknown(value),
5394 }
5395 }
5396}
5397
5398impl glib::error::ErrorDomain for IconThemeError {
5399 #[inline]
5400 fn domain() -> glib::Quark {
5401 skip_assert_initialized!();
5402
5403 unsafe { from_glib(ffi::gtk_icon_theme_error_quark()) }
5404 }
5405
5406 #[inline]
5407 fn code(self) -> i32 {
5408 self.into_glib()
5409 }
5410
5411 #[inline]
5412 #[allow(clippy::match_single_binding)]
5413 fn from(code: i32) -> Option<Self> {
5414 skip_assert_initialized!();
5415 match unsafe { from_glib(code) } {
5416 Self::__Unknown(_) => Some(Self::Failed),
5417 value => Some(value),
5418 }
5419 }
5420}
5421
5422impl StaticType for IconThemeError {
5423 #[inline]
5424 #[doc(alias = "gtk_icon_theme_error_get_type")]
5425 fn static_type() -> glib::Type {
5426 unsafe { from_glib(ffi::gtk_icon_theme_error_get_type()) }
5427 }
5428}
5429
5430impl glib::HasParamSpec for IconThemeError {
5431 type ParamSpec = glib::ParamSpecEnum;
5432 type SetValue = Self;
5433 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
5434
5435 fn param_spec_builder() -> Self::BuilderFn {
5436 Self::ParamSpec::builder_with_default
5437 }
5438}
5439
5440impl glib::value::ValueType for IconThemeError {
5441 type Type = Self;
5442}
5443
5444unsafe impl<'a> glib::value::FromValue<'a> for IconThemeError {
5445 type Checker = glib::value::GenericValueTypeChecker<Self>;
5446
5447 #[inline]
5448 unsafe fn from_value(value: &'a glib::Value) -> Self {
5449 skip_assert_initialized!();
5450 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
5451 }
5452}
5453
5454impl ToValue for IconThemeError {
5455 #[inline]
5456 fn to_value(&self) -> glib::Value {
5457 let mut value = glib::Value::for_value_type::<Self>();
5458 unsafe {
5459 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
5460 }
5461 value
5462 }
5463
5464 #[inline]
5465 fn value_type(&self) -> glib::Type {
5466 Self::static_type()
5467 }
5468}
5469
5470impl From<IconThemeError> for glib::Value {
5471 #[inline]
5472 fn from(v: IconThemeError) -> Self {
5473 skip_assert_initialized!();
5474 ToValue::to_value(&v)
5475 }
5476}
5477
5478#[cfg_attr(feature = "v4_20", deprecated = "Since 4.20")]
5479#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
5480#[non_exhaustive]
5481#[doc(alias = "GtkIconViewDropPosition")]
5482pub enum IconViewDropPosition {
5483 #[doc(alias = "GTK_ICON_VIEW_NO_DROP")]
5484 NoDrop,
5485 #[doc(alias = "GTK_ICON_VIEW_DROP_INTO")]
5486 DropInto,
5487 #[doc(alias = "GTK_ICON_VIEW_DROP_LEFT")]
5488 DropLeft,
5489 #[doc(alias = "GTK_ICON_VIEW_DROP_RIGHT")]
5490 DropRight,
5491 #[doc(alias = "GTK_ICON_VIEW_DROP_ABOVE")]
5492 DropAbove,
5493 #[doc(alias = "GTK_ICON_VIEW_DROP_BELOW")]
5494 DropBelow,
5495 #[doc(hidden)]
5496 __Unknown(i32),
5497}
5498
5499#[allow(deprecated)]
5500#[doc(hidden)]
5501impl IntoGlib for IconViewDropPosition {
5502 type GlibType = ffi::GtkIconViewDropPosition;
5503
5504 #[inline]
5505 fn into_glib(self) -> ffi::GtkIconViewDropPosition {
5506 match self {
5507 Self::NoDrop => ffi::GTK_ICON_VIEW_NO_DROP,
5508 Self::DropInto => ffi::GTK_ICON_VIEW_DROP_INTO,
5509 Self::DropLeft => ffi::GTK_ICON_VIEW_DROP_LEFT,
5510 Self::DropRight => ffi::GTK_ICON_VIEW_DROP_RIGHT,
5511 Self::DropAbove => ffi::GTK_ICON_VIEW_DROP_ABOVE,
5512 Self::DropBelow => ffi::GTK_ICON_VIEW_DROP_BELOW,
5513 Self::__Unknown(value) => value,
5514 }
5515 }
5516}
5517
5518#[allow(deprecated)]
5519#[doc(hidden)]
5520impl FromGlib<ffi::GtkIconViewDropPosition> for IconViewDropPosition {
5521 #[inline]
5522 unsafe fn from_glib(value: ffi::GtkIconViewDropPosition) -> Self {
5523 skip_assert_initialized!();
5524
5525 match value {
5526 ffi::GTK_ICON_VIEW_NO_DROP => Self::NoDrop,
5527 ffi::GTK_ICON_VIEW_DROP_INTO => Self::DropInto,
5528 ffi::GTK_ICON_VIEW_DROP_LEFT => Self::DropLeft,
5529 ffi::GTK_ICON_VIEW_DROP_RIGHT => Self::DropRight,
5530 ffi::GTK_ICON_VIEW_DROP_ABOVE => Self::DropAbove,
5531 ffi::GTK_ICON_VIEW_DROP_BELOW => Self::DropBelow,
5532 value => Self::__Unknown(value),
5533 }
5534 }
5535}
5536
5537#[allow(deprecated)]
5538impl StaticType for IconViewDropPosition {
5539 #[inline]
5540 #[doc(alias = "gtk_icon_view_drop_position_get_type")]
5541 fn static_type() -> glib::Type {
5542 unsafe { from_glib(ffi::gtk_icon_view_drop_position_get_type()) }
5543 }
5544}
5545
5546#[allow(deprecated)]
5547impl glib::HasParamSpec for IconViewDropPosition {
5548 type ParamSpec = glib::ParamSpecEnum;
5549 type SetValue = Self;
5550 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
5551
5552 fn param_spec_builder() -> Self::BuilderFn {
5553 Self::ParamSpec::builder_with_default
5554 }
5555}
5556
5557#[allow(deprecated)]
5558impl glib::value::ValueType for IconViewDropPosition {
5559 type Type = Self;
5560}
5561
5562#[allow(deprecated)]
5563unsafe impl<'a> glib::value::FromValue<'a> for IconViewDropPosition {
5564 type Checker = glib::value::GenericValueTypeChecker<Self>;
5565
5566 #[inline]
5567 unsafe fn from_value(value: &'a glib::Value) -> Self {
5568 skip_assert_initialized!();
5569 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
5570 }
5571}
5572
5573#[allow(deprecated)]
5574impl ToValue for IconViewDropPosition {
5575 #[inline]
5576 fn to_value(&self) -> glib::Value {
5577 let mut value = glib::Value::for_value_type::<Self>();
5578 unsafe {
5579 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
5580 }
5581 value
5582 }
5583
5584 #[inline]
5585 fn value_type(&self) -> glib::Type {
5586 Self::static_type()
5587 }
5588}
5589
5590#[allow(deprecated)]
5591impl From<IconViewDropPosition> for glib::Value {
5592 #[inline]
5593 fn from(v: IconViewDropPosition) -> Self {
5594 skip_assert_initialized!();
5595 ToValue::to_value(&v)
5596 }
5597}
5598
5599#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
5600#[non_exhaustive]
5601#[doc(alias = "GtkImageType")]
5602pub enum ImageType {
5603 #[doc(alias = "GTK_IMAGE_EMPTY")]
5604 Empty,
5605 #[doc(alias = "GTK_IMAGE_ICON_NAME")]
5606 IconName,
5607 #[doc(alias = "GTK_IMAGE_GICON")]
5608 Gicon,
5609 #[doc(alias = "GTK_IMAGE_PAINTABLE")]
5610 Paintable,
5611 #[doc(hidden)]
5612 __Unknown(i32),
5613}
5614
5615#[doc(hidden)]
5616impl IntoGlib for ImageType {
5617 type GlibType = ffi::GtkImageType;
5618
5619 #[inline]
5620 fn into_glib(self) -> ffi::GtkImageType {
5621 match self {
5622 Self::Empty => ffi::GTK_IMAGE_EMPTY,
5623 Self::IconName => ffi::GTK_IMAGE_ICON_NAME,
5624 Self::Gicon => ffi::GTK_IMAGE_GICON,
5625 Self::Paintable => ffi::GTK_IMAGE_PAINTABLE,
5626 Self::__Unknown(value) => value,
5627 }
5628 }
5629}
5630
5631#[doc(hidden)]
5632impl FromGlib<ffi::GtkImageType> for ImageType {
5633 #[inline]
5634 unsafe fn from_glib(value: ffi::GtkImageType) -> Self {
5635 skip_assert_initialized!();
5636
5637 match value {
5638 ffi::GTK_IMAGE_EMPTY => Self::Empty,
5639 ffi::GTK_IMAGE_ICON_NAME => Self::IconName,
5640 ffi::GTK_IMAGE_GICON => Self::Gicon,
5641 ffi::GTK_IMAGE_PAINTABLE => Self::Paintable,
5642 value => Self::__Unknown(value),
5643 }
5644 }
5645}
5646
5647impl StaticType for ImageType {
5648 #[inline]
5649 #[doc(alias = "gtk_image_type_get_type")]
5650 fn static_type() -> glib::Type {
5651 unsafe { from_glib(ffi::gtk_image_type_get_type()) }
5652 }
5653}
5654
5655impl glib::HasParamSpec for ImageType {
5656 type ParamSpec = glib::ParamSpecEnum;
5657 type SetValue = Self;
5658 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
5659
5660 fn param_spec_builder() -> Self::BuilderFn {
5661 Self::ParamSpec::builder_with_default
5662 }
5663}
5664
5665impl glib::value::ValueType for ImageType {
5666 type Type = Self;
5667}
5668
5669unsafe impl<'a> glib::value::FromValue<'a> for ImageType {
5670 type Checker = glib::value::GenericValueTypeChecker<Self>;
5671
5672 #[inline]
5673 unsafe fn from_value(value: &'a glib::Value) -> Self {
5674 skip_assert_initialized!();
5675 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
5676 }
5677}
5678
5679impl ToValue for ImageType {
5680 #[inline]
5681 fn to_value(&self) -> glib::Value {
5682 let mut value = glib::Value::for_value_type::<Self>();
5683 unsafe {
5684 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
5685 }
5686 value
5687 }
5688
5689 #[inline]
5690 fn value_type(&self) -> glib::Type {
5691 Self::static_type()
5692 }
5693}
5694
5695impl From<ImageType> for glib::Value {
5696 #[inline]
5697 fn from(v: ImageType) -> Self {
5698 skip_assert_initialized!();
5699 ToValue::to_value(&v)
5700 }
5701}
5702
5703#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
5704#[non_exhaustive]
5705#[doc(alias = "GtkInputPurpose")]
5706pub enum InputPurpose {
5707 #[doc(alias = "GTK_INPUT_PURPOSE_FREE_FORM")]
5708 FreeForm,
5709 #[doc(alias = "GTK_INPUT_PURPOSE_ALPHA")]
5710 Alpha,
5711 #[doc(alias = "GTK_INPUT_PURPOSE_DIGITS")]
5712 Digits,
5713 #[doc(alias = "GTK_INPUT_PURPOSE_NUMBER")]
5714 Number,
5715 #[doc(alias = "GTK_INPUT_PURPOSE_PHONE")]
5716 Phone,
5717 #[doc(alias = "GTK_INPUT_PURPOSE_URL")]
5718 Url,
5719 #[doc(alias = "GTK_INPUT_PURPOSE_EMAIL")]
5720 Email,
5721 #[doc(alias = "GTK_INPUT_PURPOSE_NAME")]
5722 Name,
5723 #[doc(alias = "GTK_INPUT_PURPOSE_PASSWORD")]
5724 Password,
5725 #[doc(alias = "GTK_INPUT_PURPOSE_PIN")]
5726 Pin,
5727 #[doc(alias = "GTK_INPUT_PURPOSE_TERMINAL")]
5728 Terminal,
5729 #[doc(hidden)]
5730 __Unknown(i32),
5731}
5732
5733#[doc(hidden)]
5734impl IntoGlib for InputPurpose {
5735 type GlibType = ffi::GtkInputPurpose;
5736
5737 #[inline]
5738 fn into_glib(self) -> ffi::GtkInputPurpose {
5739 match self {
5740 Self::FreeForm => ffi::GTK_INPUT_PURPOSE_FREE_FORM,
5741 Self::Alpha => ffi::GTK_INPUT_PURPOSE_ALPHA,
5742 Self::Digits => ffi::GTK_INPUT_PURPOSE_DIGITS,
5743 Self::Number => ffi::GTK_INPUT_PURPOSE_NUMBER,
5744 Self::Phone => ffi::GTK_INPUT_PURPOSE_PHONE,
5745 Self::Url => ffi::GTK_INPUT_PURPOSE_URL,
5746 Self::Email => ffi::GTK_INPUT_PURPOSE_EMAIL,
5747 Self::Name => ffi::GTK_INPUT_PURPOSE_NAME,
5748 Self::Password => ffi::GTK_INPUT_PURPOSE_PASSWORD,
5749 Self::Pin => ffi::GTK_INPUT_PURPOSE_PIN,
5750 Self::Terminal => ffi::GTK_INPUT_PURPOSE_TERMINAL,
5751 Self::__Unknown(value) => value,
5752 }
5753 }
5754}
5755
5756#[doc(hidden)]
5757impl FromGlib<ffi::GtkInputPurpose> for InputPurpose {
5758 #[inline]
5759 unsafe fn from_glib(value: ffi::GtkInputPurpose) -> Self {
5760 skip_assert_initialized!();
5761
5762 match value {
5763 ffi::GTK_INPUT_PURPOSE_FREE_FORM => Self::FreeForm,
5764 ffi::GTK_INPUT_PURPOSE_ALPHA => Self::Alpha,
5765 ffi::GTK_INPUT_PURPOSE_DIGITS => Self::Digits,
5766 ffi::GTK_INPUT_PURPOSE_NUMBER => Self::Number,
5767 ffi::GTK_INPUT_PURPOSE_PHONE => Self::Phone,
5768 ffi::GTK_INPUT_PURPOSE_URL => Self::Url,
5769 ffi::GTK_INPUT_PURPOSE_EMAIL => Self::Email,
5770 ffi::GTK_INPUT_PURPOSE_NAME => Self::Name,
5771 ffi::GTK_INPUT_PURPOSE_PASSWORD => Self::Password,
5772 ffi::GTK_INPUT_PURPOSE_PIN => Self::Pin,
5773 ffi::GTK_INPUT_PURPOSE_TERMINAL => Self::Terminal,
5774 value => Self::__Unknown(value),
5775 }
5776 }
5777}
5778
5779impl StaticType for InputPurpose {
5780 #[inline]
5781 #[doc(alias = "gtk_input_purpose_get_type")]
5782 fn static_type() -> glib::Type {
5783 unsafe { from_glib(ffi::gtk_input_purpose_get_type()) }
5784 }
5785}
5786
5787impl glib::HasParamSpec for InputPurpose {
5788 type ParamSpec = glib::ParamSpecEnum;
5789 type SetValue = Self;
5790 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
5791
5792 fn param_spec_builder() -> Self::BuilderFn {
5793 Self::ParamSpec::builder_with_default
5794 }
5795}
5796
5797impl glib::value::ValueType for InputPurpose {
5798 type Type = Self;
5799}
5800
5801unsafe impl<'a> glib::value::FromValue<'a> for InputPurpose {
5802 type Checker = glib::value::GenericValueTypeChecker<Self>;
5803
5804 #[inline]
5805 unsafe fn from_value(value: &'a glib::Value) -> Self {
5806 skip_assert_initialized!();
5807 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
5808 }
5809}
5810
5811impl ToValue for InputPurpose {
5812 #[inline]
5813 fn to_value(&self) -> glib::Value {
5814 let mut value = glib::Value::for_value_type::<Self>();
5815 unsafe {
5816 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
5817 }
5818 value
5819 }
5820
5821 #[inline]
5822 fn value_type(&self) -> glib::Type {
5823 Self::static_type()
5824 }
5825}
5826
5827impl From<InputPurpose> for glib::Value {
5828 #[inline]
5829 fn from(v: InputPurpose) -> Self {
5830 skip_assert_initialized!();
5831 ToValue::to_value(&v)
5832 }
5833}
5834
5835#[cfg(feature = "v4_8")]
5836#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
5837#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
5838#[non_exhaustive]
5839#[doc(alias = "GtkInscriptionOverflow")]
5840pub enum InscriptionOverflow {
5841 #[doc(alias = "GTK_INSCRIPTION_OVERFLOW_CLIP")]
5842 Clip,
5843 #[doc(alias = "GTK_INSCRIPTION_OVERFLOW_ELLIPSIZE_START")]
5844 EllipsizeStart,
5845 #[doc(alias = "GTK_INSCRIPTION_OVERFLOW_ELLIPSIZE_MIDDLE")]
5846 EllipsizeMiddle,
5847 #[doc(alias = "GTK_INSCRIPTION_OVERFLOW_ELLIPSIZE_END")]
5848 EllipsizeEnd,
5849 #[doc(hidden)]
5850 __Unknown(i32),
5851}
5852
5853#[cfg(feature = "v4_8")]
5854#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
5855#[doc(hidden)]
5856impl IntoGlib for InscriptionOverflow {
5857 type GlibType = ffi::GtkInscriptionOverflow;
5858
5859 #[inline]
5860 fn into_glib(self) -> ffi::GtkInscriptionOverflow {
5861 match self {
5862 Self::Clip => ffi::GTK_INSCRIPTION_OVERFLOW_CLIP,
5863 Self::EllipsizeStart => ffi::GTK_INSCRIPTION_OVERFLOW_ELLIPSIZE_START,
5864 Self::EllipsizeMiddle => ffi::GTK_INSCRIPTION_OVERFLOW_ELLIPSIZE_MIDDLE,
5865 Self::EllipsizeEnd => ffi::GTK_INSCRIPTION_OVERFLOW_ELLIPSIZE_END,
5866 Self::__Unknown(value) => value,
5867 }
5868 }
5869}
5870
5871#[cfg(feature = "v4_8")]
5872#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
5873#[doc(hidden)]
5874impl FromGlib<ffi::GtkInscriptionOverflow> for InscriptionOverflow {
5875 #[inline]
5876 unsafe fn from_glib(value: ffi::GtkInscriptionOverflow) -> Self {
5877 skip_assert_initialized!();
5878
5879 match value {
5880 ffi::GTK_INSCRIPTION_OVERFLOW_CLIP => Self::Clip,
5881 ffi::GTK_INSCRIPTION_OVERFLOW_ELLIPSIZE_START => Self::EllipsizeStart,
5882 ffi::GTK_INSCRIPTION_OVERFLOW_ELLIPSIZE_MIDDLE => Self::EllipsizeMiddle,
5883 ffi::GTK_INSCRIPTION_OVERFLOW_ELLIPSIZE_END => Self::EllipsizeEnd,
5884 value => Self::__Unknown(value),
5885 }
5886 }
5887}
5888
5889#[cfg(feature = "v4_8")]
5890#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
5891impl StaticType for InscriptionOverflow {
5892 #[inline]
5893 #[doc(alias = "gtk_inscription_overflow_get_type")]
5894 fn static_type() -> glib::Type {
5895 unsafe { from_glib(ffi::gtk_inscription_overflow_get_type()) }
5896 }
5897}
5898
5899#[cfg(feature = "v4_8")]
5900#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
5901impl glib::HasParamSpec for InscriptionOverflow {
5902 type ParamSpec = glib::ParamSpecEnum;
5903 type SetValue = Self;
5904 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
5905
5906 fn param_spec_builder() -> Self::BuilderFn {
5907 Self::ParamSpec::builder_with_default
5908 }
5909}
5910
5911#[cfg(feature = "v4_8")]
5912#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
5913impl glib::value::ValueType for InscriptionOverflow {
5914 type Type = Self;
5915}
5916
5917#[cfg(feature = "v4_8")]
5918#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
5919unsafe impl<'a> glib::value::FromValue<'a> for InscriptionOverflow {
5920 type Checker = glib::value::GenericValueTypeChecker<Self>;
5921
5922 #[inline]
5923 unsafe fn from_value(value: &'a glib::Value) -> Self {
5924 skip_assert_initialized!();
5925 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
5926 }
5927}
5928
5929#[cfg(feature = "v4_8")]
5930#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
5931impl ToValue for InscriptionOverflow {
5932 #[inline]
5933 fn to_value(&self) -> glib::Value {
5934 let mut value = glib::Value::for_value_type::<Self>();
5935 unsafe {
5936 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
5937 }
5938 value
5939 }
5940
5941 #[inline]
5942 fn value_type(&self) -> glib::Type {
5943 Self::static_type()
5944 }
5945}
5946
5947#[cfg(feature = "v4_8")]
5948#[cfg_attr(docsrs, doc(cfg(feature = "v4_8")))]
5949impl From<InscriptionOverflow> for glib::Value {
5950 #[inline]
5951 fn from(v: InscriptionOverflow) -> Self {
5952 skip_assert_initialized!();
5953 ToValue::to_value(&v)
5954 }
5955}
5956
5957#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
5958#[non_exhaustive]
5959#[doc(alias = "GtkJustification")]
5960pub enum Justification {
5961 #[doc(alias = "GTK_JUSTIFY_LEFT")]
5962 Left,
5963 #[doc(alias = "GTK_JUSTIFY_RIGHT")]
5964 Right,
5965 #[doc(alias = "GTK_JUSTIFY_CENTER")]
5966 Center,
5967 #[doc(alias = "GTK_JUSTIFY_FILL")]
5968 Fill,
5969 #[doc(hidden)]
5970 __Unknown(i32),
5971}
5972
5973#[doc(hidden)]
5974impl IntoGlib for Justification {
5975 type GlibType = ffi::GtkJustification;
5976
5977 #[inline]
5978 fn into_glib(self) -> ffi::GtkJustification {
5979 match self {
5980 Self::Left => ffi::GTK_JUSTIFY_LEFT,
5981 Self::Right => ffi::GTK_JUSTIFY_RIGHT,
5982 Self::Center => ffi::GTK_JUSTIFY_CENTER,
5983 Self::Fill => ffi::GTK_JUSTIFY_FILL,
5984 Self::__Unknown(value) => value,
5985 }
5986 }
5987}
5988
5989#[doc(hidden)]
5990impl FromGlib<ffi::GtkJustification> for Justification {
5991 #[inline]
5992 unsafe fn from_glib(value: ffi::GtkJustification) -> Self {
5993 skip_assert_initialized!();
5994
5995 match value {
5996 ffi::GTK_JUSTIFY_LEFT => Self::Left,
5997 ffi::GTK_JUSTIFY_RIGHT => Self::Right,
5998 ffi::GTK_JUSTIFY_CENTER => Self::Center,
5999 ffi::GTK_JUSTIFY_FILL => Self::Fill,
6000 value => Self::__Unknown(value),
6001 }
6002 }
6003}
6004
6005impl StaticType for Justification {
6006 #[inline]
6007 #[doc(alias = "gtk_justification_get_type")]
6008 fn static_type() -> glib::Type {
6009 unsafe { from_glib(ffi::gtk_justification_get_type()) }
6010 }
6011}
6012
6013impl glib::HasParamSpec for Justification {
6014 type ParamSpec = glib::ParamSpecEnum;
6015 type SetValue = Self;
6016 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
6017
6018 fn param_spec_builder() -> Self::BuilderFn {
6019 Self::ParamSpec::builder_with_default
6020 }
6021}
6022
6023impl glib::value::ValueType for Justification {
6024 type Type = Self;
6025}
6026
6027unsafe impl<'a> glib::value::FromValue<'a> for Justification {
6028 type Checker = glib::value::GenericValueTypeChecker<Self>;
6029
6030 #[inline]
6031 unsafe fn from_value(value: &'a glib::Value) -> Self {
6032 skip_assert_initialized!();
6033 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
6034 }
6035}
6036
6037impl ToValue for Justification {
6038 #[inline]
6039 fn to_value(&self) -> glib::Value {
6040 let mut value = glib::Value::for_value_type::<Self>();
6041 unsafe {
6042 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
6043 }
6044 value
6045 }
6046
6047 #[inline]
6048 fn value_type(&self) -> glib::Type {
6049 Self::static_type()
6050 }
6051}
6052
6053impl From<Justification> for glib::Value {
6054 #[inline]
6055 fn from(v: Justification) -> Self {
6056 skip_assert_initialized!();
6057 ToValue::to_value(&v)
6058 }
6059}
6060
6061#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
6062#[non_exhaustive]
6063#[doc(alias = "GtkLevelBarMode")]
6064pub enum LevelBarMode {
6065 #[doc(alias = "GTK_LEVEL_BAR_MODE_CONTINUOUS")]
6066 Continuous,
6067 #[doc(alias = "GTK_LEVEL_BAR_MODE_DISCRETE")]
6068 Discrete,
6069 #[doc(hidden)]
6070 __Unknown(i32),
6071}
6072
6073#[doc(hidden)]
6074impl IntoGlib for LevelBarMode {
6075 type GlibType = ffi::GtkLevelBarMode;
6076
6077 #[inline]
6078 fn into_glib(self) -> ffi::GtkLevelBarMode {
6079 match self {
6080 Self::Continuous => ffi::GTK_LEVEL_BAR_MODE_CONTINUOUS,
6081 Self::Discrete => ffi::GTK_LEVEL_BAR_MODE_DISCRETE,
6082 Self::__Unknown(value) => value,
6083 }
6084 }
6085}
6086
6087#[doc(hidden)]
6088impl FromGlib<ffi::GtkLevelBarMode> for LevelBarMode {
6089 #[inline]
6090 unsafe fn from_glib(value: ffi::GtkLevelBarMode) -> Self {
6091 skip_assert_initialized!();
6092
6093 match value {
6094 ffi::GTK_LEVEL_BAR_MODE_CONTINUOUS => Self::Continuous,
6095 ffi::GTK_LEVEL_BAR_MODE_DISCRETE => Self::Discrete,
6096 value => Self::__Unknown(value),
6097 }
6098 }
6099}
6100
6101impl StaticType for LevelBarMode {
6102 #[inline]
6103 #[doc(alias = "gtk_level_bar_mode_get_type")]
6104 fn static_type() -> glib::Type {
6105 unsafe { from_glib(ffi::gtk_level_bar_mode_get_type()) }
6106 }
6107}
6108
6109impl glib::HasParamSpec for LevelBarMode {
6110 type ParamSpec = glib::ParamSpecEnum;
6111 type SetValue = Self;
6112 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
6113
6114 fn param_spec_builder() -> Self::BuilderFn {
6115 Self::ParamSpec::builder_with_default
6116 }
6117}
6118
6119impl glib::value::ValueType for LevelBarMode {
6120 type Type = Self;
6121}
6122
6123unsafe impl<'a> glib::value::FromValue<'a> for LevelBarMode {
6124 type Checker = glib::value::GenericValueTypeChecker<Self>;
6125
6126 #[inline]
6127 unsafe fn from_value(value: &'a glib::Value) -> Self {
6128 skip_assert_initialized!();
6129 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
6130 }
6131}
6132
6133impl ToValue for LevelBarMode {
6134 #[inline]
6135 fn to_value(&self) -> glib::Value {
6136 let mut value = glib::Value::for_value_type::<Self>();
6137 unsafe {
6138 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
6139 }
6140 value
6141 }
6142
6143 #[inline]
6144 fn value_type(&self) -> glib::Type {
6145 Self::static_type()
6146 }
6147}
6148
6149impl From<LevelBarMode> for glib::Value {
6150 #[inline]
6151 fn from(v: LevelBarMode) -> Self {
6152 skip_assert_initialized!();
6153 ToValue::to_value(&v)
6154 }
6155}
6156
6157#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
6158#[non_exhaustive]
6159#[doc(alias = "GtkLicense")]
6160pub enum License {
6161 #[doc(alias = "GTK_LICENSE_UNKNOWN")]
6162 Unknown,
6163 #[doc(alias = "GTK_LICENSE_CUSTOM")]
6164 Custom,
6165 #[doc(alias = "GTK_LICENSE_GPL_2_0")]
6166 Gpl20,
6167 #[doc(alias = "GTK_LICENSE_GPL_3_0")]
6168 Gpl30,
6169 #[doc(alias = "GTK_LICENSE_LGPL_2_1")]
6170 Lgpl21,
6171 #[doc(alias = "GTK_LICENSE_LGPL_3_0")]
6172 Lgpl30,
6173 #[doc(alias = "GTK_LICENSE_BSD")]
6174 Bsd,
6175 #[doc(alias = "GTK_LICENSE_MIT_X11")]
6176 MitX11,
6177 #[doc(alias = "GTK_LICENSE_ARTISTIC")]
6178 Artistic,
6179 #[doc(alias = "GTK_LICENSE_GPL_2_0_ONLY")]
6180 Gpl20Only,
6181 #[doc(alias = "GTK_LICENSE_GPL_3_0_ONLY")]
6182 Gpl30Only,
6183 #[doc(alias = "GTK_LICENSE_LGPL_2_1_ONLY")]
6184 Lgpl21Only,
6185 #[doc(alias = "GTK_LICENSE_LGPL_3_0_ONLY")]
6186 Lgpl30Only,
6187 #[doc(alias = "GTK_LICENSE_AGPL_3_0")]
6188 Agpl30,
6189 #[doc(alias = "GTK_LICENSE_AGPL_3_0_ONLY")]
6190 Agpl30Only,
6191 #[doc(alias = "GTK_LICENSE_BSD_3")]
6192 Bsd3,
6193 #[doc(alias = "GTK_LICENSE_APACHE_2_0")]
6194 Apache20,
6195 #[doc(alias = "GTK_LICENSE_MPL_2_0")]
6196 Mpl20,
6197 #[cfg(feature = "v4_14")]
6198 #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
6199 #[doc(alias = "GTK_LICENSE_0BSD")]
6200 _0bsd,
6201 #[doc(hidden)]
6202 __Unknown(i32),
6203}
6204
6205#[doc(hidden)]
6206impl IntoGlib for License {
6207 type GlibType = ffi::GtkLicense;
6208
6209 fn into_glib(self) -> ffi::GtkLicense {
6210 match self {
6211 Self::Unknown => ffi::GTK_LICENSE_UNKNOWN,
6212 Self::Custom => ffi::GTK_LICENSE_CUSTOM,
6213 Self::Gpl20 => ffi::GTK_LICENSE_GPL_2_0,
6214 Self::Gpl30 => ffi::GTK_LICENSE_GPL_3_0,
6215 Self::Lgpl21 => ffi::GTK_LICENSE_LGPL_2_1,
6216 Self::Lgpl30 => ffi::GTK_LICENSE_LGPL_3_0,
6217 Self::Bsd => ffi::GTK_LICENSE_BSD,
6218 Self::MitX11 => ffi::GTK_LICENSE_MIT_X11,
6219 Self::Artistic => ffi::GTK_LICENSE_ARTISTIC,
6220 Self::Gpl20Only => ffi::GTK_LICENSE_GPL_2_0_ONLY,
6221 Self::Gpl30Only => ffi::GTK_LICENSE_GPL_3_0_ONLY,
6222 Self::Lgpl21Only => ffi::GTK_LICENSE_LGPL_2_1_ONLY,
6223 Self::Lgpl30Only => ffi::GTK_LICENSE_LGPL_3_0_ONLY,
6224 Self::Agpl30 => ffi::GTK_LICENSE_AGPL_3_0,
6225 Self::Agpl30Only => ffi::GTK_LICENSE_AGPL_3_0_ONLY,
6226 Self::Bsd3 => ffi::GTK_LICENSE_BSD_3,
6227 Self::Apache20 => ffi::GTK_LICENSE_APACHE_2_0,
6228 Self::Mpl20 => ffi::GTK_LICENSE_MPL_2_0,
6229 #[cfg(feature = "v4_14")]
6230 Self::_0bsd => ffi::GTK_LICENSE_0BSD,
6231 Self::__Unknown(value) => value,
6232 }
6233 }
6234}
6235
6236#[doc(hidden)]
6237impl FromGlib<ffi::GtkLicense> for License {
6238 unsafe fn from_glib(value: ffi::GtkLicense) -> Self {
6239 skip_assert_initialized!();
6240
6241 match value {
6242 ffi::GTK_LICENSE_UNKNOWN => Self::Unknown,
6243 ffi::GTK_LICENSE_CUSTOM => Self::Custom,
6244 ffi::GTK_LICENSE_GPL_2_0 => Self::Gpl20,
6245 ffi::GTK_LICENSE_GPL_3_0 => Self::Gpl30,
6246 ffi::GTK_LICENSE_LGPL_2_1 => Self::Lgpl21,
6247 ffi::GTK_LICENSE_LGPL_3_0 => Self::Lgpl30,
6248 ffi::GTK_LICENSE_BSD => Self::Bsd,
6249 ffi::GTK_LICENSE_MIT_X11 => Self::MitX11,
6250 ffi::GTK_LICENSE_ARTISTIC => Self::Artistic,
6251 ffi::GTK_LICENSE_GPL_2_0_ONLY => Self::Gpl20Only,
6252 ffi::GTK_LICENSE_GPL_3_0_ONLY => Self::Gpl30Only,
6253 ffi::GTK_LICENSE_LGPL_2_1_ONLY => Self::Lgpl21Only,
6254 ffi::GTK_LICENSE_LGPL_3_0_ONLY => Self::Lgpl30Only,
6255 ffi::GTK_LICENSE_AGPL_3_0 => Self::Agpl30,
6256 ffi::GTK_LICENSE_AGPL_3_0_ONLY => Self::Agpl30Only,
6257 ffi::GTK_LICENSE_BSD_3 => Self::Bsd3,
6258 ffi::GTK_LICENSE_APACHE_2_0 => Self::Apache20,
6259 ffi::GTK_LICENSE_MPL_2_0 => Self::Mpl20,
6260 #[cfg(feature = "v4_14")]
6261 ffi::GTK_LICENSE_0BSD => Self::_0bsd,
6262 value => Self::__Unknown(value),
6263 }
6264 }
6265}
6266
6267impl StaticType for License {
6268 #[inline]
6269 #[doc(alias = "gtk_license_get_type")]
6270 fn static_type() -> glib::Type {
6271 unsafe { from_glib(ffi::gtk_license_get_type()) }
6272 }
6273}
6274
6275impl glib::HasParamSpec for License {
6276 type ParamSpec = glib::ParamSpecEnum;
6277 type SetValue = Self;
6278 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
6279
6280 fn param_spec_builder() -> Self::BuilderFn {
6281 Self::ParamSpec::builder_with_default
6282 }
6283}
6284
6285impl glib::value::ValueType for License {
6286 type Type = Self;
6287}
6288
6289unsafe impl<'a> glib::value::FromValue<'a> for License {
6290 type Checker = glib::value::GenericValueTypeChecker<Self>;
6291
6292 #[inline]
6293 unsafe fn from_value(value: &'a glib::Value) -> Self {
6294 skip_assert_initialized!();
6295 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
6296 }
6297}
6298
6299impl ToValue for License {
6300 #[inline]
6301 fn to_value(&self) -> glib::Value {
6302 let mut value = glib::Value::for_value_type::<Self>();
6303 unsafe {
6304 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
6305 }
6306 value
6307 }
6308
6309 #[inline]
6310 fn value_type(&self) -> glib::Type {
6311 Self::static_type()
6312 }
6313}
6314
6315impl From<License> for glib::Value {
6316 #[inline]
6317 fn from(v: License) -> Self {
6318 skip_assert_initialized!();
6319 ToValue::to_value(&v)
6320 }
6321}
6322
6323#[cfg(feature = "v4_12")]
6324#[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
6325#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
6326#[non_exhaustive]
6327#[doc(alias = "GtkListTabBehavior")]
6328pub enum ListTabBehavior {
6329 #[doc(alias = "GTK_LIST_TAB_ALL")]
6330 All,
6331 #[doc(alias = "GTK_LIST_TAB_ITEM")]
6332 Item,
6333 #[doc(alias = "GTK_LIST_TAB_CELL")]
6334 Cell,
6335 #[doc(hidden)]
6336 __Unknown(i32),
6337}
6338
6339#[cfg(feature = "v4_12")]
6340#[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
6341#[doc(hidden)]
6342impl IntoGlib for ListTabBehavior {
6343 type GlibType = ffi::GtkListTabBehavior;
6344
6345 #[inline]
6346 fn into_glib(self) -> ffi::GtkListTabBehavior {
6347 match self {
6348 Self::All => ffi::GTK_LIST_TAB_ALL,
6349 Self::Item => ffi::GTK_LIST_TAB_ITEM,
6350 Self::Cell => ffi::GTK_LIST_TAB_CELL,
6351 Self::__Unknown(value) => value,
6352 }
6353 }
6354}
6355
6356#[cfg(feature = "v4_12")]
6357#[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
6358#[doc(hidden)]
6359impl FromGlib<ffi::GtkListTabBehavior> for ListTabBehavior {
6360 #[inline]
6361 unsafe fn from_glib(value: ffi::GtkListTabBehavior) -> Self {
6362 skip_assert_initialized!();
6363
6364 match value {
6365 ffi::GTK_LIST_TAB_ALL => Self::All,
6366 ffi::GTK_LIST_TAB_ITEM => Self::Item,
6367 ffi::GTK_LIST_TAB_CELL => Self::Cell,
6368 value => Self::__Unknown(value),
6369 }
6370 }
6371}
6372
6373#[cfg(feature = "v4_12")]
6374#[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
6375impl StaticType for ListTabBehavior {
6376 #[inline]
6377 #[doc(alias = "gtk_list_tab_behavior_get_type")]
6378 fn static_type() -> glib::Type {
6379 unsafe { from_glib(ffi::gtk_list_tab_behavior_get_type()) }
6380 }
6381}
6382
6383#[cfg(feature = "v4_12")]
6384#[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
6385impl glib::HasParamSpec for ListTabBehavior {
6386 type ParamSpec = glib::ParamSpecEnum;
6387 type SetValue = Self;
6388 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
6389
6390 fn param_spec_builder() -> Self::BuilderFn {
6391 Self::ParamSpec::builder_with_default
6392 }
6393}
6394
6395#[cfg(feature = "v4_12")]
6396#[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
6397impl glib::value::ValueType for ListTabBehavior {
6398 type Type = Self;
6399}
6400
6401#[cfg(feature = "v4_12")]
6402#[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
6403unsafe impl<'a> glib::value::FromValue<'a> for ListTabBehavior {
6404 type Checker = glib::value::GenericValueTypeChecker<Self>;
6405
6406 #[inline]
6407 unsafe fn from_value(value: &'a glib::Value) -> Self {
6408 skip_assert_initialized!();
6409 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
6410 }
6411}
6412
6413#[cfg(feature = "v4_12")]
6414#[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
6415impl ToValue for ListTabBehavior {
6416 #[inline]
6417 fn to_value(&self) -> glib::Value {
6418 let mut value = glib::Value::for_value_type::<Self>();
6419 unsafe {
6420 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
6421 }
6422 value
6423 }
6424
6425 #[inline]
6426 fn value_type(&self) -> glib::Type {
6427 Self::static_type()
6428 }
6429}
6430
6431#[cfg(feature = "v4_12")]
6432#[cfg_attr(docsrs, doc(cfg(feature = "v4_12")))]
6433impl From<ListTabBehavior> for glib::Value {
6434 #[inline]
6435 fn from(v: ListTabBehavior) -> Self {
6436 skip_assert_initialized!();
6437 ToValue::to_value(&v)
6438 }
6439}
6440
6441#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
6442#[non_exhaustive]
6443#[doc(alias = "GtkMessageType")]
6444pub enum MessageType {
6445 #[doc(alias = "GTK_MESSAGE_INFO")]
6446 Info,
6447 #[doc(alias = "GTK_MESSAGE_WARNING")]
6448 Warning,
6449 #[doc(alias = "GTK_MESSAGE_QUESTION")]
6450 Question,
6451 #[doc(alias = "GTK_MESSAGE_ERROR")]
6452 Error,
6453 #[doc(alias = "GTK_MESSAGE_OTHER")]
6454 Other,
6455 #[doc(hidden)]
6456 __Unknown(i32),
6457}
6458
6459#[doc(hidden)]
6460impl IntoGlib for MessageType {
6461 type GlibType = ffi::GtkMessageType;
6462
6463 #[inline]
6464 fn into_glib(self) -> ffi::GtkMessageType {
6465 match self {
6466 Self::Info => ffi::GTK_MESSAGE_INFO,
6467 Self::Warning => ffi::GTK_MESSAGE_WARNING,
6468 Self::Question => ffi::GTK_MESSAGE_QUESTION,
6469 Self::Error => ffi::GTK_MESSAGE_ERROR,
6470 Self::Other => ffi::GTK_MESSAGE_OTHER,
6471 Self::__Unknown(value) => value,
6472 }
6473 }
6474}
6475
6476#[doc(hidden)]
6477impl FromGlib<ffi::GtkMessageType> for MessageType {
6478 #[inline]
6479 unsafe fn from_glib(value: ffi::GtkMessageType) -> Self {
6480 skip_assert_initialized!();
6481
6482 match value {
6483 ffi::GTK_MESSAGE_INFO => Self::Info,
6484 ffi::GTK_MESSAGE_WARNING => Self::Warning,
6485 ffi::GTK_MESSAGE_QUESTION => Self::Question,
6486 ffi::GTK_MESSAGE_ERROR => Self::Error,
6487 ffi::GTK_MESSAGE_OTHER => Self::Other,
6488 value => Self::__Unknown(value),
6489 }
6490 }
6491}
6492
6493impl StaticType for MessageType {
6494 #[inline]
6495 #[doc(alias = "gtk_message_type_get_type")]
6496 fn static_type() -> glib::Type {
6497 unsafe { from_glib(ffi::gtk_message_type_get_type()) }
6498 }
6499}
6500
6501impl glib::HasParamSpec for MessageType {
6502 type ParamSpec = glib::ParamSpecEnum;
6503 type SetValue = Self;
6504 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
6505
6506 fn param_spec_builder() -> Self::BuilderFn {
6507 Self::ParamSpec::builder_with_default
6508 }
6509}
6510
6511impl glib::value::ValueType for MessageType {
6512 type Type = Self;
6513}
6514
6515unsafe impl<'a> glib::value::FromValue<'a> for MessageType {
6516 type Checker = glib::value::GenericValueTypeChecker<Self>;
6517
6518 #[inline]
6519 unsafe fn from_value(value: &'a glib::Value) -> Self {
6520 skip_assert_initialized!();
6521 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
6522 }
6523}
6524
6525impl ToValue for MessageType {
6526 #[inline]
6527 fn to_value(&self) -> glib::Value {
6528 let mut value = glib::Value::for_value_type::<Self>();
6529 unsafe {
6530 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
6531 }
6532 value
6533 }
6534
6535 #[inline]
6536 fn value_type(&self) -> glib::Type {
6537 Self::static_type()
6538 }
6539}
6540
6541impl From<MessageType> for glib::Value {
6542 #[inline]
6543 fn from(v: MessageType) -> Self {
6544 skip_assert_initialized!();
6545 ToValue::to_value(&v)
6546 }
6547}
6548
6549#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
6550#[non_exhaustive]
6551#[doc(alias = "GtkMovementStep")]
6552pub enum MovementStep {
6553 #[doc(alias = "GTK_MOVEMENT_LOGICAL_POSITIONS")]
6554 LogicalPositions,
6555 #[doc(alias = "GTK_MOVEMENT_VISUAL_POSITIONS")]
6556 VisualPositions,
6557 #[doc(alias = "GTK_MOVEMENT_WORDS")]
6558 Words,
6559 #[doc(alias = "GTK_MOVEMENT_DISPLAY_LINES")]
6560 DisplayLines,
6561 #[doc(alias = "GTK_MOVEMENT_DISPLAY_LINE_ENDS")]
6562 DisplayLineEnds,
6563 #[doc(alias = "GTK_MOVEMENT_PARAGRAPHS")]
6564 Paragraphs,
6565 #[doc(alias = "GTK_MOVEMENT_PARAGRAPH_ENDS")]
6566 ParagraphEnds,
6567 #[doc(alias = "GTK_MOVEMENT_PAGES")]
6568 Pages,
6569 #[doc(alias = "GTK_MOVEMENT_BUFFER_ENDS")]
6570 BufferEnds,
6571 #[doc(alias = "GTK_MOVEMENT_HORIZONTAL_PAGES")]
6572 HorizontalPages,
6573 #[doc(hidden)]
6574 __Unknown(i32),
6575}
6576
6577#[doc(hidden)]
6578impl IntoGlib for MovementStep {
6579 type GlibType = ffi::GtkMovementStep;
6580
6581 #[inline]
6582 fn into_glib(self) -> ffi::GtkMovementStep {
6583 match self {
6584 Self::LogicalPositions => ffi::GTK_MOVEMENT_LOGICAL_POSITIONS,
6585 Self::VisualPositions => ffi::GTK_MOVEMENT_VISUAL_POSITIONS,
6586 Self::Words => ffi::GTK_MOVEMENT_WORDS,
6587 Self::DisplayLines => ffi::GTK_MOVEMENT_DISPLAY_LINES,
6588 Self::DisplayLineEnds => ffi::GTK_MOVEMENT_DISPLAY_LINE_ENDS,
6589 Self::Paragraphs => ffi::GTK_MOVEMENT_PARAGRAPHS,
6590 Self::ParagraphEnds => ffi::GTK_MOVEMENT_PARAGRAPH_ENDS,
6591 Self::Pages => ffi::GTK_MOVEMENT_PAGES,
6592 Self::BufferEnds => ffi::GTK_MOVEMENT_BUFFER_ENDS,
6593 Self::HorizontalPages => ffi::GTK_MOVEMENT_HORIZONTAL_PAGES,
6594 Self::__Unknown(value) => value,
6595 }
6596 }
6597}
6598
6599#[doc(hidden)]
6600impl FromGlib<ffi::GtkMovementStep> for MovementStep {
6601 #[inline]
6602 unsafe fn from_glib(value: ffi::GtkMovementStep) -> Self {
6603 skip_assert_initialized!();
6604
6605 match value {
6606 ffi::GTK_MOVEMENT_LOGICAL_POSITIONS => Self::LogicalPositions,
6607 ffi::GTK_MOVEMENT_VISUAL_POSITIONS => Self::VisualPositions,
6608 ffi::GTK_MOVEMENT_WORDS => Self::Words,
6609 ffi::GTK_MOVEMENT_DISPLAY_LINES => Self::DisplayLines,
6610 ffi::GTK_MOVEMENT_DISPLAY_LINE_ENDS => Self::DisplayLineEnds,
6611 ffi::GTK_MOVEMENT_PARAGRAPHS => Self::Paragraphs,
6612 ffi::GTK_MOVEMENT_PARAGRAPH_ENDS => Self::ParagraphEnds,
6613 ffi::GTK_MOVEMENT_PAGES => Self::Pages,
6614 ffi::GTK_MOVEMENT_BUFFER_ENDS => Self::BufferEnds,
6615 ffi::GTK_MOVEMENT_HORIZONTAL_PAGES => Self::HorizontalPages,
6616 value => Self::__Unknown(value),
6617 }
6618 }
6619}
6620
6621impl StaticType for MovementStep {
6622 #[inline]
6623 #[doc(alias = "gtk_movement_step_get_type")]
6624 fn static_type() -> glib::Type {
6625 unsafe { from_glib(ffi::gtk_movement_step_get_type()) }
6626 }
6627}
6628
6629impl glib::HasParamSpec for MovementStep {
6630 type ParamSpec = glib::ParamSpecEnum;
6631 type SetValue = Self;
6632 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
6633
6634 fn param_spec_builder() -> Self::BuilderFn {
6635 Self::ParamSpec::builder_with_default
6636 }
6637}
6638
6639impl glib::value::ValueType for MovementStep {
6640 type Type = Self;
6641}
6642
6643unsafe impl<'a> glib::value::FromValue<'a> for MovementStep {
6644 type Checker = glib::value::GenericValueTypeChecker<Self>;
6645
6646 #[inline]
6647 unsafe fn from_value(value: &'a glib::Value) -> Self {
6648 skip_assert_initialized!();
6649 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
6650 }
6651}
6652
6653impl ToValue for MovementStep {
6654 #[inline]
6655 fn to_value(&self) -> glib::Value {
6656 let mut value = glib::Value::for_value_type::<Self>();
6657 unsafe {
6658 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
6659 }
6660 value
6661 }
6662
6663 #[inline]
6664 fn value_type(&self) -> glib::Type {
6665 Self::static_type()
6666 }
6667}
6668
6669impl From<MovementStep> for glib::Value {
6670 #[inline]
6671 fn from(v: MovementStep) -> Self {
6672 skip_assert_initialized!();
6673 ToValue::to_value(&v)
6674 }
6675}
6676
6677#[cfg(feature = "v4_6")]
6678#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
6679#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
6680#[non_exhaustive]
6681#[doc(alias = "GtkNaturalWrapMode")]
6682pub enum NaturalWrapMode {
6683 #[doc(alias = "GTK_NATURAL_WRAP_INHERIT")]
6684 Inherit,
6685 #[doc(alias = "GTK_NATURAL_WRAP_NONE")]
6686 None,
6687 #[doc(alias = "GTK_NATURAL_WRAP_WORD")]
6688 Word,
6689 #[doc(hidden)]
6690 __Unknown(i32),
6691}
6692
6693#[cfg(feature = "v4_6")]
6694#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
6695#[doc(hidden)]
6696impl IntoGlib for NaturalWrapMode {
6697 type GlibType = ffi::GtkNaturalWrapMode;
6698
6699 #[inline]
6700 fn into_glib(self) -> ffi::GtkNaturalWrapMode {
6701 match self {
6702 Self::Inherit => ffi::GTK_NATURAL_WRAP_INHERIT,
6703 Self::None => ffi::GTK_NATURAL_WRAP_NONE,
6704 Self::Word => ffi::GTK_NATURAL_WRAP_WORD,
6705 Self::__Unknown(value) => value,
6706 }
6707 }
6708}
6709
6710#[cfg(feature = "v4_6")]
6711#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
6712#[doc(hidden)]
6713impl FromGlib<ffi::GtkNaturalWrapMode> for NaturalWrapMode {
6714 #[inline]
6715 unsafe fn from_glib(value: ffi::GtkNaturalWrapMode) -> Self {
6716 skip_assert_initialized!();
6717
6718 match value {
6719 ffi::GTK_NATURAL_WRAP_INHERIT => Self::Inherit,
6720 ffi::GTK_NATURAL_WRAP_NONE => Self::None,
6721 ffi::GTK_NATURAL_WRAP_WORD => Self::Word,
6722 value => Self::__Unknown(value),
6723 }
6724 }
6725}
6726
6727#[cfg(feature = "v4_6")]
6728#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
6729impl StaticType for NaturalWrapMode {
6730 #[inline]
6731 #[doc(alias = "gtk_natural_wrap_mode_get_type")]
6732 fn static_type() -> glib::Type {
6733 unsafe { from_glib(ffi::gtk_natural_wrap_mode_get_type()) }
6734 }
6735}
6736
6737#[cfg(feature = "v4_6")]
6738#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
6739impl glib::HasParamSpec for NaturalWrapMode {
6740 type ParamSpec = glib::ParamSpecEnum;
6741 type SetValue = Self;
6742 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
6743
6744 fn param_spec_builder() -> Self::BuilderFn {
6745 Self::ParamSpec::builder_with_default
6746 }
6747}
6748
6749#[cfg(feature = "v4_6")]
6750#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
6751impl glib::value::ValueType for NaturalWrapMode {
6752 type Type = Self;
6753}
6754
6755#[cfg(feature = "v4_6")]
6756#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
6757unsafe impl<'a> glib::value::FromValue<'a> for NaturalWrapMode {
6758 type Checker = glib::value::GenericValueTypeChecker<Self>;
6759
6760 #[inline]
6761 unsafe fn from_value(value: &'a glib::Value) -> Self {
6762 skip_assert_initialized!();
6763 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
6764 }
6765}
6766
6767#[cfg(feature = "v4_6")]
6768#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
6769impl ToValue for NaturalWrapMode {
6770 #[inline]
6771 fn to_value(&self) -> glib::Value {
6772 let mut value = glib::Value::for_value_type::<Self>();
6773 unsafe {
6774 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
6775 }
6776 value
6777 }
6778
6779 #[inline]
6780 fn value_type(&self) -> glib::Type {
6781 Self::static_type()
6782 }
6783}
6784
6785#[cfg(feature = "v4_6")]
6786#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
6787impl From<NaturalWrapMode> for glib::Value {
6788 #[inline]
6789 fn from(v: NaturalWrapMode) -> Self {
6790 skip_assert_initialized!();
6791 ToValue::to_value(&v)
6792 }
6793}
6794
6795#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
6796#[non_exhaustive]
6797#[doc(alias = "GtkNotebookTab")]
6798pub enum NotebookTab {
6799 #[doc(alias = "GTK_NOTEBOOK_TAB_FIRST")]
6800 First,
6801 #[doc(alias = "GTK_NOTEBOOK_TAB_LAST")]
6802 Last,
6803 #[doc(hidden)]
6804 __Unknown(i32),
6805}
6806
6807#[doc(hidden)]
6808impl IntoGlib for NotebookTab {
6809 type GlibType = ffi::GtkNotebookTab;
6810
6811 #[inline]
6812 fn into_glib(self) -> ffi::GtkNotebookTab {
6813 match self {
6814 Self::First => ffi::GTK_NOTEBOOK_TAB_FIRST,
6815 Self::Last => ffi::GTK_NOTEBOOK_TAB_LAST,
6816 Self::__Unknown(value) => value,
6817 }
6818 }
6819}
6820
6821#[doc(hidden)]
6822impl FromGlib<ffi::GtkNotebookTab> for NotebookTab {
6823 #[inline]
6824 unsafe fn from_glib(value: ffi::GtkNotebookTab) -> Self {
6825 skip_assert_initialized!();
6826
6827 match value {
6828 ffi::GTK_NOTEBOOK_TAB_FIRST => Self::First,
6829 ffi::GTK_NOTEBOOK_TAB_LAST => Self::Last,
6830 value => Self::__Unknown(value),
6831 }
6832 }
6833}
6834
6835impl StaticType for NotebookTab {
6836 #[inline]
6837 #[doc(alias = "gtk_notebook_tab_get_type")]
6838 fn static_type() -> glib::Type {
6839 unsafe { from_glib(ffi::gtk_notebook_tab_get_type()) }
6840 }
6841}
6842
6843impl glib::HasParamSpec for NotebookTab {
6844 type ParamSpec = glib::ParamSpecEnum;
6845 type SetValue = Self;
6846 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
6847
6848 fn param_spec_builder() -> Self::BuilderFn {
6849 Self::ParamSpec::builder_with_default
6850 }
6851}
6852
6853impl glib::value::ValueType for NotebookTab {
6854 type Type = Self;
6855}
6856
6857unsafe impl<'a> glib::value::FromValue<'a> for NotebookTab {
6858 type Checker = glib::value::GenericValueTypeChecker<Self>;
6859
6860 #[inline]
6861 unsafe fn from_value(value: &'a glib::Value) -> Self {
6862 skip_assert_initialized!();
6863 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
6864 }
6865}
6866
6867impl ToValue for NotebookTab {
6868 #[inline]
6869 fn to_value(&self) -> glib::Value {
6870 let mut value = glib::Value::for_value_type::<Self>();
6871 unsafe {
6872 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
6873 }
6874 value
6875 }
6876
6877 #[inline]
6878 fn value_type(&self) -> glib::Type {
6879 Self::static_type()
6880 }
6881}
6882
6883impl From<NotebookTab> for glib::Value {
6884 #[inline]
6885 fn from(v: NotebookTab) -> Self {
6886 skip_assert_initialized!();
6887 ToValue::to_value(&v)
6888 }
6889}
6890
6891#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
6892#[non_exhaustive]
6893#[doc(alias = "GtkNumberUpLayout")]
6894pub enum NumberUpLayout {
6895 #[doc(alias = "GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_TOP_TO_BOTTOM")]
6896 Lrtb,
6897 #[doc(alias = "GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_BOTTOM_TO_TOP")]
6898 Lrbt,
6899 #[doc(alias = "GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_TOP_TO_BOTTOM")]
6900 Rltb,
6901 #[doc(alias = "GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_BOTTOM_TO_TOP")]
6902 Rlbt,
6903 #[doc(alias = "GTK_NUMBER_UP_LAYOUT_TOP_TO_BOTTOM_LEFT_TO_RIGHT")]
6904 Tblr,
6905 #[doc(alias = "GTK_NUMBER_UP_LAYOUT_TOP_TO_BOTTOM_RIGHT_TO_LEFT")]
6906 Tbrl,
6907 #[doc(alias = "GTK_NUMBER_UP_LAYOUT_BOTTOM_TO_TOP_LEFT_TO_RIGHT")]
6908 Btlr,
6909 #[doc(alias = "GTK_NUMBER_UP_LAYOUT_BOTTOM_TO_TOP_RIGHT_TO_LEFT")]
6910 Btrl,
6911 #[doc(hidden)]
6912 __Unknown(i32),
6913}
6914
6915#[doc(hidden)]
6916impl IntoGlib for NumberUpLayout {
6917 type GlibType = ffi::GtkNumberUpLayout;
6918
6919 #[inline]
6920 fn into_glib(self) -> ffi::GtkNumberUpLayout {
6921 match self {
6922 Self::Lrtb => ffi::GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_TOP_TO_BOTTOM,
6923 Self::Lrbt => ffi::GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_BOTTOM_TO_TOP,
6924 Self::Rltb => ffi::GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_TOP_TO_BOTTOM,
6925 Self::Rlbt => ffi::GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_BOTTOM_TO_TOP,
6926 Self::Tblr => ffi::GTK_NUMBER_UP_LAYOUT_TOP_TO_BOTTOM_LEFT_TO_RIGHT,
6927 Self::Tbrl => ffi::GTK_NUMBER_UP_LAYOUT_TOP_TO_BOTTOM_RIGHT_TO_LEFT,
6928 Self::Btlr => ffi::GTK_NUMBER_UP_LAYOUT_BOTTOM_TO_TOP_LEFT_TO_RIGHT,
6929 Self::Btrl => ffi::GTK_NUMBER_UP_LAYOUT_BOTTOM_TO_TOP_RIGHT_TO_LEFT,
6930 Self::__Unknown(value) => value,
6931 }
6932 }
6933}
6934
6935#[doc(hidden)]
6936impl FromGlib<ffi::GtkNumberUpLayout> for NumberUpLayout {
6937 #[inline]
6938 unsafe fn from_glib(value: ffi::GtkNumberUpLayout) -> Self {
6939 skip_assert_initialized!();
6940
6941 match value {
6942 ffi::GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_TOP_TO_BOTTOM => Self::Lrtb,
6943 ffi::GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_BOTTOM_TO_TOP => Self::Lrbt,
6944 ffi::GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_TOP_TO_BOTTOM => Self::Rltb,
6945 ffi::GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_BOTTOM_TO_TOP => Self::Rlbt,
6946 ffi::GTK_NUMBER_UP_LAYOUT_TOP_TO_BOTTOM_LEFT_TO_RIGHT => Self::Tblr,
6947 ffi::GTK_NUMBER_UP_LAYOUT_TOP_TO_BOTTOM_RIGHT_TO_LEFT => Self::Tbrl,
6948 ffi::GTK_NUMBER_UP_LAYOUT_BOTTOM_TO_TOP_LEFT_TO_RIGHT => Self::Btlr,
6949 ffi::GTK_NUMBER_UP_LAYOUT_BOTTOM_TO_TOP_RIGHT_TO_LEFT => Self::Btrl,
6950 value => Self::__Unknown(value),
6951 }
6952 }
6953}
6954
6955impl StaticType for NumberUpLayout {
6956 #[inline]
6957 #[doc(alias = "gtk_number_up_layout_get_type")]
6958 fn static_type() -> glib::Type {
6959 unsafe { from_glib(ffi::gtk_number_up_layout_get_type()) }
6960 }
6961}
6962
6963impl glib::HasParamSpec for NumberUpLayout {
6964 type ParamSpec = glib::ParamSpecEnum;
6965 type SetValue = Self;
6966 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
6967
6968 fn param_spec_builder() -> Self::BuilderFn {
6969 Self::ParamSpec::builder_with_default
6970 }
6971}
6972
6973impl glib::value::ValueType for NumberUpLayout {
6974 type Type = Self;
6975}
6976
6977unsafe impl<'a> glib::value::FromValue<'a> for NumberUpLayout {
6978 type Checker = glib::value::GenericValueTypeChecker<Self>;
6979
6980 #[inline]
6981 unsafe fn from_value(value: &'a glib::Value) -> Self {
6982 skip_assert_initialized!();
6983 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
6984 }
6985}
6986
6987impl ToValue for NumberUpLayout {
6988 #[inline]
6989 fn to_value(&self) -> glib::Value {
6990 let mut value = glib::Value::for_value_type::<Self>();
6991 unsafe {
6992 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
6993 }
6994 value
6995 }
6996
6997 #[inline]
6998 fn value_type(&self) -> glib::Type {
6999 Self::static_type()
7000 }
7001}
7002
7003impl From<NumberUpLayout> for glib::Value {
7004 #[inline]
7005 fn from(v: NumberUpLayout) -> Self {
7006 skip_assert_initialized!();
7007 ToValue::to_value(&v)
7008 }
7009}
7010
7011#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
7012#[non_exhaustive]
7013#[doc(alias = "GtkOrdering")]
7014pub enum Ordering {
7015 #[doc(alias = "GTK_ORDERING_SMALLER")]
7016 Smaller,
7017 #[doc(alias = "GTK_ORDERING_EQUAL")]
7018 Equal,
7019 #[doc(alias = "GTK_ORDERING_LARGER")]
7020 Larger,
7021 #[doc(hidden)]
7022 __Unknown(i32),
7023}
7024
7025#[doc(hidden)]
7026impl IntoGlib for Ordering {
7027 type GlibType = ffi::GtkOrdering;
7028
7029 #[inline]
7030 fn into_glib(self) -> ffi::GtkOrdering {
7031 match self {
7032 Self::Smaller => ffi::GTK_ORDERING_SMALLER,
7033 Self::Equal => ffi::GTK_ORDERING_EQUAL,
7034 Self::Larger => ffi::GTK_ORDERING_LARGER,
7035 Self::__Unknown(value) => value,
7036 }
7037 }
7038}
7039
7040#[doc(hidden)]
7041impl FromGlib<ffi::GtkOrdering> for Ordering {
7042 #[inline]
7043 unsafe fn from_glib(value: ffi::GtkOrdering) -> Self {
7044 skip_assert_initialized!();
7045
7046 match value {
7047 ffi::GTK_ORDERING_SMALLER => Self::Smaller,
7048 ffi::GTK_ORDERING_EQUAL => Self::Equal,
7049 ffi::GTK_ORDERING_LARGER => Self::Larger,
7050 value => Self::__Unknown(value),
7051 }
7052 }
7053}
7054
7055impl StaticType for Ordering {
7056 #[inline]
7057 #[doc(alias = "gtk_ordering_get_type")]
7058 fn static_type() -> glib::Type {
7059 unsafe { from_glib(ffi::gtk_ordering_get_type()) }
7060 }
7061}
7062
7063impl glib::HasParamSpec for Ordering {
7064 type ParamSpec = glib::ParamSpecEnum;
7065 type SetValue = Self;
7066 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
7067
7068 fn param_spec_builder() -> Self::BuilderFn {
7069 Self::ParamSpec::builder_with_default
7070 }
7071}
7072
7073impl glib::value::ValueType for Ordering {
7074 type Type = Self;
7075}
7076
7077unsafe impl<'a> glib::value::FromValue<'a> for Ordering {
7078 type Checker = glib::value::GenericValueTypeChecker<Self>;
7079
7080 #[inline]
7081 unsafe fn from_value(value: &'a glib::Value) -> Self {
7082 skip_assert_initialized!();
7083 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
7084 }
7085}
7086
7087impl ToValue for Ordering {
7088 #[inline]
7089 fn to_value(&self) -> glib::Value {
7090 let mut value = glib::Value::for_value_type::<Self>();
7091 unsafe {
7092 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
7093 }
7094 value
7095 }
7096
7097 #[inline]
7098 fn value_type(&self) -> glib::Type {
7099 Self::static_type()
7100 }
7101}
7102
7103impl From<Ordering> for glib::Value {
7104 #[inline]
7105 fn from(v: Ordering) -> Self {
7106 skip_assert_initialized!();
7107 ToValue::to_value(&v)
7108 }
7109}
7110
7111#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
7112#[non_exhaustive]
7113#[doc(alias = "GtkOrientation")]
7114pub enum Orientation {
7115 #[doc(alias = "GTK_ORIENTATION_HORIZONTAL")]
7116 Horizontal,
7117 #[doc(alias = "GTK_ORIENTATION_VERTICAL")]
7118 Vertical,
7119 #[doc(hidden)]
7120 __Unknown(i32),
7121}
7122
7123#[doc(hidden)]
7124impl IntoGlib for Orientation {
7125 type GlibType = ffi::GtkOrientation;
7126
7127 #[inline]
7128 fn into_glib(self) -> ffi::GtkOrientation {
7129 match self {
7130 Self::Horizontal => ffi::GTK_ORIENTATION_HORIZONTAL,
7131 Self::Vertical => ffi::GTK_ORIENTATION_VERTICAL,
7132 Self::__Unknown(value) => value,
7133 }
7134 }
7135}
7136
7137#[doc(hidden)]
7138impl FromGlib<ffi::GtkOrientation> for Orientation {
7139 #[inline]
7140 unsafe fn from_glib(value: ffi::GtkOrientation) -> Self {
7141 skip_assert_initialized!();
7142
7143 match value {
7144 ffi::GTK_ORIENTATION_HORIZONTAL => Self::Horizontal,
7145 ffi::GTK_ORIENTATION_VERTICAL => Self::Vertical,
7146 value => Self::__Unknown(value),
7147 }
7148 }
7149}
7150
7151impl StaticType for Orientation {
7152 #[inline]
7153 #[doc(alias = "gtk_orientation_get_type")]
7154 fn static_type() -> glib::Type {
7155 unsafe { from_glib(ffi::gtk_orientation_get_type()) }
7156 }
7157}
7158
7159impl glib::HasParamSpec for Orientation {
7160 type ParamSpec = glib::ParamSpecEnum;
7161 type SetValue = Self;
7162 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
7163
7164 fn param_spec_builder() -> Self::BuilderFn {
7165 Self::ParamSpec::builder_with_default
7166 }
7167}
7168
7169impl glib::value::ValueType for Orientation {
7170 type Type = Self;
7171}
7172
7173unsafe impl<'a> glib::value::FromValue<'a> for Orientation {
7174 type Checker = glib::value::GenericValueTypeChecker<Self>;
7175
7176 #[inline]
7177 unsafe fn from_value(value: &'a glib::Value) -> Self {
7178 skip_assert_initialized!();
7179 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
7180 }
7181}
7182
7183impl ToValue for Orientation {
7184 #[inline]
7185 fn to_value(&self) -> glib::Value {
7186 let mut value = glib::Value::for_value_type::<Self>();
7187 unsafe {
7188 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
7189 }
7190 value
7191 }
7192
7193 #[inline]
7194 fn value_type(&self) -> glib::Type {
7195 Self::static_type()
7196 }
7197}
7198
7199impl From<Orientation> for glib::Value {
7200 #[inline]
7201 fn from(v: Orientation) -> Self {
7202 skip_assert_initialized!();
7203 ToValue::to_value(&v)
7204 }
7205}
7206
7207#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
7208#[non_exhaustive]
7209#[doc(alias = "GtkOverflow")]
7210pub enum Overflow {
7211 #[doc(alias = "GTK_OVERFLOW_VISIBLE")]
7212 Visible,
7213 #[doc(alias = "GTK_OVERFLOW_HIDDEN")]
7214 Hidden,
7215 #[doc(hidden)]
7216 __Unknown(i32),
7217}
7218
7219#[doc(hidden)]
7220impl IntoGlib for Overflow {
7221 type GlibType = ffi::GtkOverflow;
7222
7223 #[inline]
7224 fn into_glib(self) -> ffi::GtkOverflow {
7225 match self {
7226 Self::Visible => ffi::GTK_OVERFLOW_VISIBLE,
7227 Self::Hidden => ffi::GTK_OVERFLOW_HIDDEN,
7228 Self::__Unknown(value) => value,
7229 }
7230 }
7231}
7232
7233#[doc(hidden)]
7234impl FromGlib<ffi::GtkOverflow> for Overflow {
7235 #[inline]
7236 unsafe fn from_glib(value: ffi::GtkOverflow) -> Self {
7237 skip_assert_initialized!();
7238
7239 match value {
7240 ffi::GTK_OVERFLOW_VISIBLE => Self::Visible,
7241 ffi::GTK_OVERFLOW_HIDDEN => Self::Hidden,
7242 value => Self::__Unknown(value),
7243 }
7244 }
7245}
7246
7247impl StaticType for Overflow {
7248 #[inline]
7249 #[doc(alias = "gtk_overflow_get_type")]
7250 fn static_type() -> glib::Type {
7251 unsafe { from_glib(ffi::gtk_overflow_get_type()) }
7252 }
7253}
7254
7255impl glib::HasParamSpec for Overflow {
7256 type ParamSpec = glib::ParamSpecEnum;
7257 type SetValue = Self;
7258 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
7259
7260 fn param_spec_builder() -> Self::BuilderFn {
7261 Self::ParamSpec::builder_with_default
7262 }
7263}
7264
7265impl glib::value::ValueType for Overflow {
7266 type Type = Self;
7267}
7268
7269unsafe impl<'a> glib::value::FromValue<'a> for Overflow {
7270 type Checker = glib::value::GenericValueTypeChecker<Self>;
7271
7272 #[inline]
7273 unsafe fn from_value(value: &'a glib::Value) -> Self {
7274 skip_assert_initialized!();
7275 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
7276 }
7277}
7278
7279impl ToValue for Overflow {
7280 #[inline]
7281 fn to_value(&self) -> glib::Value {
7282 let mut value = glib::Value::for_value_type::<Self>();
7283 unsafe {
7284 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
7285 }
7286 value
7287 }
7288
7289 #[inline]
7290 fn value_type(&self) -> glib::Type {
7291 Self::static_type()
7292 }
7293}
7294
7295impl From<Overflow> for glib::Value {
7296 #[inline]
7297 fn from(v: Overflow) -> Self {
7298 skip_assert_initialized!();
7299 ToValue::to_value(&v)
7300 }
7301}
7302
7303#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
7304#[non_exhaustive]
7305#[doc(alias = "GtkPackType")]
7306pub enum PackType {
7307 #[doc(alias = "GTK_PACK_START")]
7308 Start,
7309 #[doc(alias = "GTK_PACK_END")]
7310 End,
7311 #[doc(hidden)]
7312 __Unknown(i32),
7313}
7314
7315#[doc(hidden)]
7316impl IntoGlib for PackType {
7317 type GlibType = ffi::GtkPackType;
7318
7319 #[inline]
7320 fn into_glib(self) -> ffi::GtkPackType {
7321 match self {
7322 Self::Start => ffi::GTK_PACK_START,
7323 Self::End => ffi::GTK_PACK_END,
7324 Self::__Unknown(value) => value,
7325 }
7326 }
7327}
7328
7329#[doc(hidden)]
7330impl FromGlib<ffi::GtkPackType> for PackType {
7331 #[inline]
7332 unsafe fn from_glib(value: ffi::GtkPackType) -> Self {
7333 skip_assert_initialized!();
7334
7335 match value {
7336 ffi::GTK_PACK_START => Self::Start,
7337 ffi::GTK_PACK_END => Self::End,
7338 value => Self::__Unknown(value),
7339 }
7340 }
7341}
7342
7343impl StaticType for PackType {
7344 #[inline]
7345 #[doc(alias = "gtk_pack_type_get_type")]
7346 fn static_type() -> glib::Type {
7347 unsafe { from_glib(ffi::gtk_pack_type_get_type()) }
7348 }
7349}
7350
7351impl glib::HasParamSpec for PackType {
7352 type ParamSpec = glib::ParamSpecEnum;
7353 type SetValue = Self;
7354 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
7355
7356 fn param_spec_builder() -> Self::BuilderFn {
7357 Self::ParamSpec::builder_with_default
7358 }
7359}
7360
7361impl glib::value::ValueType for PackType {
7362 type Type = Self;
7363}
7364
7365unsafe impl<'a> glib::value::FromValue<'a> for PackType {
7366 type Checker = glib::value::GenericValueTypeChecker<Self>;
7367
7368 #[inline]
7369 unsafe fn from_value(value: &'a glib::Value) -> Self {
7370 skip_assert_initialized!();
7371 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
7372 }
7373}
7374
7375impl ToValue for PackType {
7376 #[inline]
7377 fn to_value(&self) -> glib::Value {
7378 let mut value = glib::Value::for_value_type::<Self>();
7379 unsafe {
7380 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
7381 }
7382 value
7383 }
7384
7385 #[inline]
7386 fn value_type(&self) -> glib::Type {
7387 Self::static_type()
7388 }
7389}
7390
7391impl From<PackType> for glib::Value {
7392 #[inline]
7393 fn from(v: PackType) -> Self {
7394 skip_assert_initialized!();
7395 ToValue::to_value(&v)
7396 }
7397}
7398
7399#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
7400#[non_exhaustive]
7401#[doc(alias = "GtkPadActionType")]
7402pub enum PadActionType {
7403 #[doc(alias = "GTK_PAD_ACTION_BUTTON")]
7404 Button,
7405 #[doc(alias = "GTK_PAD_ACTION_RING")]
7406 Ring,
7407 #[doc(alias = "GTK_PAD_ACTION_STRIP")]
7408 Strip,
7409 #[doc(alias = "GTK_PAD_ACTION_DIAL")]
7410 Dial,
7411 #[doc(hidden)]
7412 __Unknown(i32),
7413}
7414
7415#[doc(hidden)]
7416impl IntoGlib for PadActionType {
7417 type GlibType = ffi::GtkPadActionType;
7418
7419 #[inline]
7420 fn into_glib(self) -> ffi::GtkPadActionType {
7421 match self {
7422 Self::Button => ffi::GTK_PAD_ACTION_BUTTON,
7423 Self::Ring => ffi::GTK_PAD_ACTION_RING,
7424 Self::Strip => ffi::GTK_PAD_ACTION_STRIP,
7425 Self::Dial => ffi::GTK_PAD_ACTION_DIAL,
7426 Self::__Unknown(value) => value,
7427 }
7428 }
7429}
7430
7431#[doc(hidden)]
7432impl FromGlib<ffi::GtkPadActionType> for PadActionType {
7433 #[inline]
7434 unsafe fn from_glib(value: ffi::GtkPadActionType) -> Self {
7435 skip_assert_initialized!();
7436
7437 match value {
7438 ffi::GTK_PAD_ACTION_BUTTON => Self::Button,
7439 ffi::GTK_PAD_ACTION_RING => Self::Ring,
7440 ffi::GTK_PAD_ACTION_STRIP => Self::Strip,
7441 ffi::GTK_PAD_ACTION_DIAL => Self::Dial,
7442 value => Self::__Unknown(value),
7443 }
7444 }
7445}
7446
7447impl StaticType for PadActionType {
7448 #[inline]
7449 #[doc(alias = "gtk_pad_action_type_get_type")]
7450 fn static_type() -> glib::Type {
7451 unsafe { from_glib(ffi::gtk_pad_action_type_get_type()) }
7452 }
7453}
7454
7455impl glib::HasParamSpec for PadActionType {
7456 type ParamSpec = glib::ParamSpecEnum;
7457 type SetValue = Self;
7458 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
7459
7460 fn param_spec_builder() -> Self::BuilderFn {
7461 Self::ParamSpec::builder_with_default
7462 }
7463}
7464
7465impl glib::value::ValueType for PadActionType {
7466 type Type = Self;
7467}
7468
7469unsafe impl<'a> glib::value::FromValue<'a> for PadActionType {
7470 type Checker = glib::value::GenericValueTypeChecker<Self>;
7471
7472 #[inline]
7473 unsafe fn from_value(value: &'a glib::Value) -> Self {
7474 skip_assert_initialized!();
7475 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
7476 }
7477}
7478
7479impl ToValue for PadActionType {
7480 #[inline]
7481 fn to_value(&self) -> glib::Value {
7482 let mut value = glib::Value::for_value_type::<Self>();
7483 unsafe {
7484 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
7485 }
7486 value
7487 }
7488
7489 #[inline]
7490 fn value_type(&self) -> glib::Type {
7491 Self::static_type()
7492 }
7493}
7494
7495impl From<PadActionType> for glib::Value {
7496 #[inline]
7497 fn from(v: PadActionType) -> Self {
7498 skip_assert_initialized!();
7499 ToValue::to_value(&v)
7500 }
7501}
7502
7503#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
7504#[non_exhaustive]
7505#[doc(alias = "GtkPageOrientation")]
7506pub enum PageOrientation {
7507 #[doc(alias = "GTK_PAGE_ORIENTATION_PORTRAIT")]
7508 Portrait,
7509 #[doc(alias = "GTK_PAGE_ORIENTATION_LANDSCAPE")]
7510 Landscape,
7511 #[doc(alias = "GTK_PAGE_ORIENTATION_REVERSE_PORTRAIT")]
7512 ReversePortrait,
7513 #[doc(alias = "GTK_PAGE_ORIENTATION_REVERSE_LANDSCAPE")]
7514 ReverseLandscape,
7515 #[doc(hidden)]
7516 __Unknown(i32),
7517}
7518
7519#[doc(hidden)]
7520impl IntoGlib for PageOrientation {
7521 type GlibType = ffi::GtkPageOrientation;
7522
7523 #[inline]
7524 fn into_glib(self) -> ffi::GtkPageOrientation {
7525 match self {
7526 Self::Portrait => ffi::GTK_PAGE_ORIENTATION_PORTRAIT,
7527 Self::Landscape => ffi::GTK_PAGE_ORIENTATION_LANDSCAPE,
7528 Self::ReversePortrait => ffi::GTK_PAGE_ORIENTATION_REVERSE_PORTRAIT,
7529 Self::ReverseLandscape => ffi::GTK_PAGE_ORIENTATION_REVERSE_LANDSCAPE,
7530 Self::__Unknown(value) => value,
7531 }
7532 }
7533}
7534
7535#[doc(hidden)]
7536impl FromGlib<ffi::GtkPageOrientation> for PageOrientation {
7537 #[inline]
7538 unsafe fn from_glib(value: ffi::GtkPageOrientation) -> Self {
7539 skip_assert_initialized!();
7540
7541 match value {
7542 ffi::GTK_PAGE_ORIENTATION_PORTRAIT => Self::Portrait,
7543 ffi::GTK_PAGE_ORIENTATION_LANDSCAPE => Self::Landscape,
7544 ffi::GTK_PAGE_ORIENTATION_REVERSE_PORTRAIT => Self::ReversePortrait,
7545 ffi::GTK_PAGE_ORIENTATION_REVERSE_LANDSCAPE => Self::ReverseLandscape,
7546 value => Self::__Unknown(value),
7547 }
7548 }
7549}
7550
7551impl StaticType for PageOrientation {
7552 #[inline]
7553 #[doc(alias = "gtk_page_orientation_get_type")]
7554 fn static_type() -> glib::Type {
7555 unsafe { from_glib(ffi::gtk_page_orientation_get_type()) }
7556 }
7557}
7558
7559impl glib::HasParamSpec for PageOrientation {
7560 type ParamSpec = glib::ParamSpecEnum;
7561 type SetValue = Self;
7562 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
7563
7564 fn param_spec_builder() -> Self::BuilderFn {
7565 Self::ParamSpec::builder_with_default
7566 }
7567}
7568
7569impl glib::value::ValueType for PageOrientation {
7570 type Type = Self;
7571}
7572
7573unsafe impl<'a> glib::value::FromValue<'a> for PageOrientation {
7574 type Checker = glib::value::GenericValueTypeChecker<Self>;
7575
7576 #[inline]
7577 unsafe fn from_value(value: &'a glib::Value) -> Self {
7578 skip_assert_initialized!();
7579 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
7580 }
7581}
7582
7583impl ToValue for PageOrientation {
7584 #[inline]
7585 fn to_value(&self) -> glib::Value {
7586 let mut value = glib::Value::for_value_type::<Self>();
7587 unsafe {
7588 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
7589 }
7590 value
7591 }
7592
7593 #[inline]
7594 fn value_type(&self) -> glib::Type {
7595 Self::static_type()
7596 }
7597}
7598
7599impl From<PageOrientation> for glib::Value {
7600 #[inline]
7601 fn from(v: PageOrientation) -> Self {
7602 skip_assert_initialized!();
7603 ToValue::to_value(&v)
7604 }
7605}
7606
7607#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
7608#[non_exhaustive]
7609#[doc(alias = "GtkPageSet")]
7610pub enum PageSet {
7611 #[doc(alias = "GTK_PAGE_SET_ALL")]
7612 All,
7613 #[doc(alias = "GTK_PAGE_SET_EVEN")]
7614 Even,
7615 #[doc(alias = "GTK_PAGE_SET_ODD")]
7616 Odd,
7617 #[doc(hidden)]
7618 __Unknown(i32),
7619}
7620
7621#[doc(hidden)]
7622impl IntoGlib for PageSet {
7623 type GlibType = ffi::GtkPageSet;
7624
7625 #[inline]
7626 fn into_glib(self) -> ffi::GtkPageSet {
7627 match self {
7628 Self::All => ffi::GTK_PAGE_SET_ALL,
7629 Self::Even => ffi::GTK_PAGE_SET_EVEN,
7630 Self::Odd => ffi::GTK_PAGE_SET_ODD,
7631 Self::__Unknown(value) => value,
7632 }
7633 }
7634}
7635
7636#[doc(hidden)]
7637impl FromGlib<ffi::GtkPageSet> for PageSet {
7638 #[inline]
7639 unsafe fn from_glib(value: ffi::GtkPageSet) -> Self {
7640 skip_assert_initialized!();
7641
7642 match value {
7643 ffi::GTK_PAGE_SET_ALL => Self::All,
7644 ffi::GTK_PAGE_SET_EVEN => Self::Even,
7645 ffi::GTK_PAGE_SET_ODD => Self::Odd,
7646 value => Self::__Unknown(value),
7647 }
7648 }
7649}
7650
7651impl StaticType for PageSet {
7652 #[inline]
7653 #[doc(alias = "gtk_page_set_get_type")]
7654 fn static_type() -> glib::Type {
7655 unsafe { from_glib(ffi::gtk_page_set_get_type()) }
7656 }
7657}
7658
7659impl glib::HasParamSpec for PageSet {
7660 type ParamSpec = glib::ParamSpecEnum;
7661 type SetValue = Self;
7662 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
7663
7664 fn param_spec_builder() -> Self::BuilderFn {
7665 Self::ParamSpec::builder_with_default
7666 }
7667}
7668
7669impl glib::value::ValueType for PageSet {
7670 type Type = Self;
7671}
7672
7673unsafe impl<'a> glib::value::FromValue<'a> for PageSet {
7674 type Checker = glib::value::GenericValueTypeChecker<Self>;
7675
7676 #[inline]
7677 unsafe fn from_value(value: &'a glib::Value) -> Self {
7678 skip_assert_initialized!();
7679 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
7680 }
7681}
7682
7683impl ToValue for PageSet {
7684 #[inline]
7685 fn to_value(&self) -> glib::Value {
7686 let mut value = glib::Value::for_value_type::<Self>();
7687 unsafe {
7688 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
7689 }
7690 value
7691 }
7692
7693 #[inline]
7694 fn value_type(&self) -> glib::Type {
7695 Self::static_type()
7696 }
7697}
7698
7699impl From<PageSet> for glib::Value {
7700 #[inline]
7701 fn from(v: PageSet) -> Self {
7702 skip_assert_initialized!();
7703 ToValue::to_value(&v)
7704 }
7705}
7706
7707#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
7708#[non_exhaustive]
7709#[doc(alias = "GtkPanDirection")]
7710pub enum PanDirection {
7711 #[doc(alias = "GTK_PAN_DIRECTION_LEFT")]
7712 Left,
7713 #[doc(alias = "GTK_PAN_DIRECTION_RIGHT")]
7714 Right,
7715 #[doc(alias = "GTK_PAN_DIRECTION_UP")]
7716 Up,
7717 #[doc(alias = "GTK_PAN_DIRECTION_DOWN")]
7718 Down,
7719 #[doc(hidden)]
7720 __Unknown(i32),
7721}
7722
7723#[doc(hidden)]
7724impl IntoGlib for PanDirection {
7725 type GlibType = ffi::GtkPanDirection;
7726
7727 #[inline]
7728 fn into_glib(self) -> ffi::GtkPanDirection {
7729 match self {
7730 Self::Left => ffi::GTK_PAN_DIRECTION_LEFT,
7731 Self::Right => ffi::GTK_PAN_DIRECTION_RIGHT,
7732 Self::Up => ffi::GTK_PAN_DIRECTION_UP,
7733 Self::Down => ffi::GTK_PAN_DIRECTION_DOWN,
7734 Self::__Unknown(value) => value,
7735 }
7736 }
7737}
7738
7739#[doc(hidden)]
7740impl FromGlib<ffi::GtkPanDirection> for PanDirection {
7741 #[inline]
7742 unsafe fn from_glib(value: ffi::GtkPanDirection) -> Self {
7743 skip_assert_initialized!();
7744
7745 match value {
7746 ffi::GTK_PAN_DIRECTION_LEFT => Self::Left,
7747 ffi::GTK_PAN_DIRECTION_RIGHT => Self::Right,
7748 ffi::GTK_PAN_DIRECTION_UP => Self::Up,
7749 ffi::GTK_PAN_DIRECTION_DOWN => Self::Down,
7750 value => Self::__Unknown(value),
7751 }
7752 }
7753}
7754
7755impl StaticType for PanDirection {
7756 #[inline]
7757 #[doc(alias = "gtk_pan_direction_get_type")]
7758 fn static_type() -> glib::Type {
7759 unsafe { from_glib(ffi::gtk_pan_direction_get_type()) }
7760 }
7761}
7762
7763impl glib::HasParamSpec for PanDirection {
7764 type ParamSpec = glib::ParamSpecEnum;
7765 type SetValue = Self;
7766 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
7767
7768 fn param_spec_builder() -> Self::BuilderFn {
7769 Self::ParamSpec::builder_with_default
7770 }
7771}
7772
7773impl glib::value::ValueType for PanDirection {
7774 type Type = Self;
7775}
7776
7777unsafe impl<'a> glib::value::FromValue<'a> for PanDirection {
7778 type Checker = glib::value::GenericValueTypeChecker<Self>;
7779
7780 #[inline]
7781 unsafe fn from_value(value: &'a glib::Value) -> Self {
7782 skip_assert_initialized!();
7783 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
7784 }
7785}
7786
7787impl ToValue for PanDirection {
7788 #[inline]
7789 fn to_value(&self) -> glib::Value {
7790 let mut value = glib::Value::for_value_type::<Self>();
7791 unsafe {
7792 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
7793 }
7794 value
7795 }
7796
7797 #[inline]
7798 fn value_type(&self) -> glib::Type {
7799 Self::static_type()
7800 }
7801}
7802
7803impl From<PanDirection> for glib::Value {
7804 #[inline]
7805 fn from(v: PanDirection) -> Self {
7806 skip_assert_initialized!();
7807 ToValue::to_value(&v)
7808 }
7809}
7810
7811#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
7812#[non_exhaustive]
7813#[doc(alias = "GtkPolicyType")]
7814pub enum PolicyType {
7815 #[doc(alias = "GTK_POLICY_ALWAYS")]
7816 Always,
7817 #[doc(alias = "GTK_POLICY_AUTOMATIC")]
7818 Automatic,
7819 #[doc(alias = "GTK_POLICY_NEVER")]
7820 Never,
7821 #[doc(alias = "GTK_POLICY_EXTERNAL")]
7822 External,
7823 #[doc(hidden)]
7824 __Unknown(i32),
7825}
7826
7827#[doc(hidden)]
7828impl IntoGlib for PolicyType {
7829 type GlibType = ffi::GtkPolicyType;
7830
7831 #[inline]
7832 fn into_glib(self) -> ffi::GtkPolicyType {
7833 match self {
7834 Self::Always => ffi::GTK_POLICY_ALWAYS,
7835 Self::Automatic => ffi::GTK_POLICY_AUTOMATIC,
7836 Self::Never => ffi::GTK_POLICY_NEVER,
7837 Self::External => ffi::GTK_POLICY_EXTERNAL,
7838 Self::__Unknown(value) => value,
7839 }
7840 }
7841}
7842
7843#[doc(hidden)]
7844impl FromGlib<ffi::GtkPolicyType> for PolicyType {
7845 #[inline]
7846 unsafe fn from_glib(value: ffi::GtkPolicyType) -> Self {
7847 skip_assert_initialized!();
7848
7849 match value {
7850 ffi::GTK_POLICY_ALWAYS => Self::Always,
7851 ffi::GTK_POLICY_AUTOMATIC => Self::Automatic,
7852 ffi::GTK_POLICY_NEVER => Self::Never,
7853 ffi::GTK_POLICY_EXTERNAL => Self::External,
7854 value => Self::__Unknown(value),
7855 }
7856 }
7857}
7858
7859impl StaticType for PolicyType {
7860 #[inline]
7861 #[doc(alias = "gtk_policy_type_get_type")]
7862 fn static_type() -> glib::Type {
7863 unsafe { from_glib(ffi::gtk_policy_type_get_type()) }
7864 }
7865}
7866
7867impl glib::HasParamSpec for PolicyType {
7868 type ParamSpec = glib::ParamSpecEnum;
7869 type SetValue = Self;
7870 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
7871
7872 fn param_spec_builder() -> Self::BuilderFn {
7873 Self::ParamSpec::builder_with_default
7874 }
7875}
7876
7877impl glib::value::ValueType for PolicyType {
7878 type Type = Self;
7879}
7880
7881unsafe impl<'a> glib::value::FromValue<'a> for PolicyType {
7882 type Checker = glib::value::GenericValueTypeChecker<Self>;
7883
7884 #[inline]
7885 unsafe fn from_value(value: &'a glib::Value) -> Self {
7886 skip_assert_initialized!();
7887 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
7888 }
7889}
7890
7891impl ToValue for PolicyType {
7892 #[inline]
7893 fn to_value(&self) -> glib::Value {
7894 let mut value = glib::Value::for_value_type::<Self>();
7895 unsafe {
7896 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
7897 }
7898 value
7899 }
7900
7901 #[inline]
7902 fn value_type(&self) -> glib::Type {
7903 Self::static_type()
7904 }
7905}
7906
7907impl From<PolicyType> for glib::Value {
7908 #[inline]
7909 fn from(v: PolicyType) -> Self {
7910 skip_assert_initialized!();
7911 ToValue::to_value(&v)
7912 }
7913}
7914
7915#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
7916#[non_exhaustive]
7917#[doc(alias = "GtkPositionType")]
7918pub enum PositionType {
7919 #[doc(alias = "GTK_POS_LEFT")]
7920 Left,
7921 #[doc(alias = "GTK_POS_RIGHT")]
7922 Right,
7923 #[doc(alias = "GTK_POS_TOP")]
7924 Top,
7925 #[doc(alias = "GTK_POS_BOTTOM")]
7926 Bottom,
7927 #[doc(hidden)]
7928 __Unknown(i32),
7929}
7930
7931#[doc(hidden)]
7932impl IntoGlib for PositionType {
7933 type GlibType = ffi::GtkPositionType;
7934
7935 #[inline]
7936 fn into_glib(self) -> ffi::GtkPositionType {
7937 match self {
7938 Self::Left => ffi::GTK_POS_LEFT,
7939 Self::Right => ffi::GTK_POS_RIGHT,
7940 Self::Top => ffi::GTK_POS_TOP,
7941 Self::Bottom => ffi::GTK_POS_BOTTOM,
7942 Self::__Unknown(value) => value,
7943 }
7944 }
7945}
7946
7947#[doc(hidden)]
7948impl FromGlib<ffi::GtkPositionType> for PositionType {
7949 #[inline]
7950 unsafe fn from_glib(value: ffi::GtkPositionType) -> Self {
7951 skip_assert_initialized!();
7952
7953 match value {
7954 ffi::GTK_POS_LEFT => Self::Left,
7955 ffi::GTK_POS_RIGHT => Self::Right,
7956 ffi::GTK_POS_TOP => Self::Top,
7957 ffi::GTK_POS_BOTTOM => Self::Bottom,
7958 value => Self::__Unknown(value),
7959 }
7960 }
7961}
7962
7963impl StaticType for PositionType {
7964 #[inline]
7965 #[doc(alias = "gtk_position_type_get_type")]
7966 fn static_type() -> glib::Type {
7967 unsafe { from_glib(ffi::gtk_position_type_get_type()) }
7968 }
7969}
7970
7971impl glib::HasParamSpec for PositionType {
7972 type ParamSpec = glib::ParamSpecEnum;
7973 type SetValue = Self;
7974 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
7975
7976 fn param_spec_builder() -> Self::BuilderFn {
7977 Self::ParamSpec::builder_with_default
7978 }
7979}
7980
7981impl glib::value::ValueType for PositionType {
7982 type Type = Self;
7983}
7984
7985unsafe impl<'a> glib::value::FromValue<'a> for PositionType {
7986 type Checker = glib::value::GenericValueTypeChecker<Self>;
7987
7988 #[inline]
7989 unsafe fn from_value(value: &'a glib::Value) -> Self {
7990 skip_assert_initialized!();
7991 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
7992 }
7993}
7994
7995impl ToValue for PositionType {
7996 #[inline]
7997 fn to_value(&self) -> glib::Value {
7998 let mut value = glib::Value::for_value_type::<Self>();
7999 unsafe {
8000 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
8001 }
8002 value
8003 }
8004
8005 #[inline]
8006 fn value_type(&self) -> glib::Type {
8007 Self::static_type()
8008 }
8009}
8010
8011impl From<PositionType> for glib::Value {
8012 #[inline]
8013 fn from(v: PositionType) -> Self {
8014 skip_assert_initialized!();
8015 ToValue::to_value(&v)
8016 }
8017}
8018
8019#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
8020#[non_exhaustive]
8021#[doc(alias = "GtkPrintDuplex")]
8022pub enum PrintDuplex {
8023 #[doc(alias = "GTK_PRINT_DUPLEX_SIMPLEX")]
8024 Simplex,
8025 #[doc(alias = "GTK_PRINT_DUPLEX_HORIZONTAL")]
8026 Horizontal,
8027 #[doc(alias = "GTK_PRINT_DUPLEX_VERTICAL")]
8028 Vertical,
8029 #[doc(hidden)]
8030 __Unknown(i32),
8031}
8032
8033#[doc(hidden)]
8034impl IntoGlib for PrintDuplex {
8035 type GlibType = ffi::GtkPrintDuplex;
8036
8037 #[inline]
8038 fn into_glib(self) -> ffi::GtkPrintDuplex {
8039 match self {
8040 Self::Simplex => ffi::GTK_PRINT_DUPLEX_SIMPLEX,
8041 Self::Horizontal => ffi::GTK_PRINT_DUPLEX_HORIZONTAL,
8042 Self::Vertical => ffi::GTK_PRINT_DUPLEX_VERTICAL,
8043 Self::__Unknown(value) => value,
8044 }
8045 }
8046}
8047
8048#[doc(hidden)]
8049impl FromGlib<ffi::GtkPrintDuplex> for PrintDuplex {
8050 #[inline]
8051 unsafe fn from_glib(value: ffi::GtkPrintDuplex) -> Self {
8052 skip_assert_initialized!();
8053
8054 match value {
8055 ffi::GTK_PRINT_DUPLEX_SIMPLEX => Self::Simplex,
8056 ffi::GTK_PRINT_DUPLEX_HORIZONTAL => Self::Horizontal,
8057 ffi::GTK_PRINT_DUPLEX_VERTICAL => Self::Vertical,
8058 value => Self::__Unknown(value),
8059 }
8060 }
8061}
8062
8063impl StaticType for PrintDuplex {
8064 #[inline]
8065 #[doc(alias = "gtk_print_duplex_get_type")]
8066 fn static_type() -> glib::Type {
8067 unsafe { from_glib(ffi::gtk_print_duplex_get_type()) }
8068 }
8069}
8070
8071impl glib::HasParamSpec for PrintDuplex {
8072 type ParamSpec = glib::ParamSpecEnum;
8073 type SetValue = Self;
8074 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
8075
8076 fn param_spec_builder() -> Self::BuilderFn {
8077 Self::ParamSpec::builder_with_default
8078 }
8079}
8080
8081impl glib::value::ValueType for PrintDuplex {
8082 type Type = Self;
8083}
8084
8085unsafe impl<'a> glib::value::FromValue<'a> for PrintDuplex {
8086 type Checker = glib::value::GenericValueTypeChecker<Self>;
8087
8088 #[inline]
8089 unsafe fn from_value(value: &'a glib::Value) -> Self {
8090 skip_assert_initialized!();
8091 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
8092 }
8093}
8094
8095impl ToValue for PrintDuplex {
8096 #[inline]
8097 fn to_value(&self) -> glib::Value {
8098 let mut value = glib::Value::for_value_type::<Self>();
8099 unsafe {
8100 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
8101 }
8102 value
8103 }
8104
8105 #[inline]
8106 fn value_type(&self) -> glib::Type {
8107 Self::static_type()
8108 }
8109}
8110
8111impl From<PrintDuplex> for glib::Value {
8112 #[inline]
8113 fn from(v: PrintDuplex) -> Self {
8114 skip_assert_initialized!();
8115 ToValue::to_value(&v)
8116 }
8117}
8118
8119#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
8120#[non_exhaustive]
8121#[doc(alias = "GtkPrintError")]
8122pub enum PrintError {
8123 #[doc(alias = "GTK_PRINT_ERROR_GENERAL")]
8124 General,
8125 #[doc(alias = "GTK_PRINT_ERROR_INTERNAL_ERROR")]
8126 InternalError,
8127 #[doc(alias = "GTK_PRINT_ERROR_NOMEM")]
8128 Nomem,
8129 #[doc(alias = "GTK_PRINT_ERROR_INVALID_FILE")]
8130 InvalidFile,
8131 #[doc(hidden)]
8132 __Unknown(i32),
8133}
8134
8135#[doc(hidden)]
8136impl IntoGlib for PrintError {
8137 type GlibType = ffi::GtkPrintError;
8138
8139 #[inline]
8140 fn into_glib(self) -> ffi::GtkPrintError {
8141 match self {
8142 Self::General => ffi::GTK_PRINT_ERROR_GENERAL,
8143 Self::InternalError => ffi::GTK_PRINT_ERROR_INTERNAL_ERROR,
8144 Self::Nomem => ffi::GTK_PRINT_ERROR_NOMEM,
8145 Self::InvalidFile => ffi::GTK_PRINT_ERROR_INVALID_FILE,
8146 Self::__Unknown(value) => value,
8147 }
8148 }
8149}
8150
8151#[doc(hidden)]
8152impl FromGlib<ffi::GtkPrintError> for PrintError {
8153 #[inline]
8154 unsafe fn from_glib(value: ffi::GtkPrintError) -> Self {
8155 skip_assert_initialized!();
8156
8157 match value {
8158 ffi::GTK_PRINT_ERROR_GENERAL => Self::General,
8159 ffi::GTK_PRINT_ERROR_INTERNAL_ERROR => Self::InternalError,
8160 ffi::GTK_PRINT_ERROR_NOMEM => Self::Nomem,
8161 ffi::GTK_PRINT_ERROR_INVALID_FILE => Self::InvalidFile,
8162 value => Self::__Unknown(value),
8163 }
8164 }
8165}
8166
8167impl glib::error::ErrorDomain for PrintError {
8168 #[inline]
8169 fn domain() -> glib::Quark {
8170 skip_assert_initialized!();
8171
8172 unsafe { from_glib(ffi::gtk_print_error_quark()) }
8173 }
8174
8175 #[inline]
8176 fn code(self) -> i32 {
8177 self.into_glib()
8178 }
8179
8180 #[inline]
8181 #[allow(clippy::match_single_binding)]
8182 fn from(code: i32) -> Option<Self> {
8183 skip_assert_initialized!();
8184 match unsafe { from_glib(code) } {
8185 value => Some(value),
8186 }
8187 }
8188}
8189
8190impl StaticType for PrintError {
8191 #[inline]
8192 #[doc(alias = "gtk_print_error_get_type")]
8193 fn static_type() -> glib::Type {
8194 unsafe { from_glib(ffi::gtk_print_error_get_type()) }
8195 }
8196}
8197
8198impl glib::HasParamSpec for PrintError {
8199 type ParamSpec = glib::ParamSpecEnum;
8200 type SetValue = Self;
8201 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
8202
8203 fn param_spec_builder() -> Self::BuilderFn {
8204 Self::ParamSpec::builder_with_default
8205 }
8206}
8207
8208impl glib::value::ValueType for PrintError {
8209 type Type = Self;
8210}
8211
8212unsafe impl<'a> glib::value::FromValue<'a> for PrintError {
8213 type Checker = glib::value::GenericValueTypeChecker<Self>;
8214
8215 #[inline]
8216 unsafe fn from_value(value: &'a glib::Value) -> Self {
8217 skip_assert_initialized!();
8218 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
8219 }
8220}
8221
8222impl ToValue for PrintError {
8223 #[inline]
8224 fn to_value(&self) -> glib::Value {
8225 let mut value = glib::Value::for_value_type::<Self>();
8226 unsafe {
8227 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
8228 }
8229 value
8230 }
8231
8232 #[inline]
8233 fn value_type(&self) -> glib::Type {
8234 Self::static_type()
8235 }
8236}
8237
8238impl From<PrintError> for glib::Value {
8239 #[inline]
8240 fn from(v: PrintError) -> Self {
8241 skip_assert_initialized!();
8242 ToValue::to_value(&v)
8243 }
8244}
8245
8246#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
8247#[non_exhaustive]
8248#[doc(alias = "GtkPrintOperationAction")]
8249pub enum PrintOperationAction {
8250 #[doc(alias = "GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG")]
8251 PrintDialog,
8252 #[doc(alias = "GTK_PRINT_OPERATION_ACTION_PRINT")]
8253 Print,
8254 #[doc(alias = "GTK_PRINT_OPERATION_ACTION_PREVIEW")]
8255 Preview,
8256 #[doc(alias = "GTK_PRINT_OPERATION_ACTION_EXPORT")]
8257 Export,
8258 #[doc(hidden)]
8259 __Unknown(i32),
8260}
8261
8262#[doc(hidden)]
8263impl IntoGlib for PrintOperationAction {
8264 type GlibType = ffi::GtkPrintOperationAction;
8265
8266 #[inline]
8267 fn into_glib(self) -> ffi::GtkPrintOperationAction {
8268 match self {
8269 Self::PrintDialog => ffi::GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG,
8270 Self::Print => ffi::GTK_PRINT_OPERATION_ACTION_PRINT,
8271 Self::Preview => ffi::GTK_PRINT_OPERATION_ACTION_PREVIEW,
8272 Self::Export => ffi::GTK_PRINT_OPERATION_ACTION_EXPORT,
8273 Self::__Unknown(value) => value,
8274 }
8275 }
8276}
8277
8278#[doc(hidden)]
8279impl FromGlib<ffi::GtkPrintOperationAction> for PrintOperationAction {
8280 #[inline]
8281 unsafe fn from_glib(value: ffi::GtkPrintOperationAction) -> Self {
8282 skip_assert_initialized!();
8283
8284 match value {
8285 ffi::GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG => Self::PrintDialog,
8286 ffi::GTK_PRINT_OPERATION_ACTION_PRINT => Self::Print,
8287 ffi::GTK_PRINT_OPERATION_ACTION_PREVIEW => Self::Preview,
8288 ffi::GTK_PRINT_OPERATION_ACTION_EXPORT => Self::Export,
8289 value => Self::__Unknown(value),
8290 }
8291 }
8292}
8293
8294impl StaticType for PrintOperationAction {
8295 #[inline]
8296 #[doc(alias = "gtk_print_operation_action_get_type")]
8297 fn static_type() -> glib::Type {
8298 unsafe { from_glib(ffi::gtk_print_operation_action_get_type()) }
8299 }
8300}
8301
8302impl glib::HasParamSpec for PrintOperationAction {
8303 type ParamSpec = glib::ParamSpecEnum;
8304 type SetValue = Self;
8305 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
8306
8307 fn param_spec_builder() -> Self::BuilderFn {
8308 Self::ParamSpec::builder_with_default
8309 }
8310}
8311
8312impl glib::value::ValueType for PrintOperationAction {
8313 type Type = Self;
8314}
8315
8316unsafe impl<'a> glib::value::FromValue<'a> for PrintOperationAction {
8317 type Checker = glib::value::GenericValueTypeChecker<Self>;
8318
8319 #[inline]
8320 unsafe fn from_value(value: &'a glib::Value) -> Self {
8321 skip_assert_initialized!();
8322 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
8323 }
8324}
8325
8326impl ToValue for PrintOperationAction {
8327 #[inline]
8328 fn to_value(&self) -> glib::Value {
8329 let mut value = glib::Value::for_value_type::<Self>();
8330 unsafe {
8331 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
8332 }
8333 value
8334 }
8335
8336 #[inline]
8337 fn value_type(&self) -> glib::Type {
8338 Self::static_type()
8339 }
8340}
8341
8342impl From<PrintOperationAction> for glib::Value {
8343 #[inline]
8344 fn from(v: PrintOperationAction) -> Self {
8345 skip_assert_initialized!();
8346 ToValue::to_value(&v)
8347 }
8348}
8349
8350#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
8351#[non_exhaustive]
8352#[doc(alias = "GtkPrintOperationResult")]
8353pub enum PrintOperationResult {
8354 #[doc(alias = "GTK_PRINT_OPERATION_RESULT_ERROR")]
8355 Error,
8356 #[doc(alias = "GTK_PRINT_OPERATION_RESULT_APPLY")]
8357 Apply,
8358 #[doc(alias = "GTK_PRINT_OPERATION_RESULT_CANCEL")]
8359 Cancel,
8360 #[doc(alias = "GTK_PRINT_OPERATION_RESULT_IN_PROGRESS")]
8361 InProgress,
8362 #[doc(hidden)]
8363 __Unknown(i32),
8364}
8365
8366#[doc(hidden)]
8367impl IntoGlib for PrintOperationResult {
8368 type GlibType = ffi::GtkPrintOperationResult;
8369
8370 #[inline]
8371 fn into_glib(self) -> ffi::GtkPrintOperationResult {
8372 match self {
8373 Self::Error => ffi::GTK_PRINT_OPERATION_RESULT_ERROR,
8374 Self::Apply => ffi::GTK_PRINT_OPERATION_RESULT_APPLY,
8375 Self::Cancel => ffi::GTK_PRINT_OPERATION_RESULT_CANCEL,
8376 Self::InProgress => ffi::GTK_PRINT_OPERATION_RESULT_IN_PROGRESS,
8377 Self::__Unknown(value) => value,
8378 }
8379 }
8380}
8381
8382#[doc(hidden)]
8383impl FromGlib<ffi::GtkPrintOperationResult> for PrintOperationResult {
8384 #[inline]
8385 unsafe fn from_glib(value: ffi::GtkPrintOperationResult) -> Self {
8386 skip_assert_initialized!();
8387
8388 match value {
8389 ffi::GTK_PRINT_OPERATION_RESULT_ERROR => Self::Error,
8390 ffi::GTK_PRINT_OPERATION_RESULT_APPLY => Self::Apply,
8391 ffi::GTK_PRINT_OPERATION_RESULT_CANCEL => Self::Cancel,
8392 ffi::GTK_PRINT_OPERATION_RESULT_IN_PROGRESS => Self::InProgress,
8393 value => Self::__Unknown(value),
8394 }
8395 }
8396}
8397
8398impl StaticType for PrintOperationResult {
8399 #[inline]
8400 #[doc(alias = "gtk_print_operation_result_get_type")]
8401 fn static_type() -> glib::Type {
8402 unsafe { from_glib(ffi::gtk_print_operation_result_get_type()) }
8403 }
8404}
8405
8406impl glib::HasParamSpec for PrintOperationResult {
8407 type ParamSpec = glib::ParamSpecEnum;
8408 type SetValue = Self;
8409 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
8410
8411 fn param_spec_builder() -> Self::BuilderFn {
8412 Self::ParamSpec::builder_with_default
8413 }
8414}
8415
8416impl glib::value::ValueType for PrintOperationResult {
8417 type Type = Self;
8418}
8419
8420unsafe impl<'a> glib::value::FromValue<'a> for PrintOperationResult {
8421 type Checker = glib::value::GenericValueTypeChecker<Self>;
8422
8423 #[inline]
8424 unsafe fn from_value(value: &'a glib::Value) -> Self {
8425 skip_assert_initialized!();
8426 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
8427 }
8428}
8429
8430impl ToValue for PrintOperationResult {
8431 #[inline]
8432 fn to_value(&self) -> glib::Value {
8433 let mut value = glib::Value::for_value_type::<Self>();
8434 unsafe {
8435 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
8436 }
8437 value
8438 }
8439
8440 #[inline]
8441 fn value_type(&self) -> glib::Type {
8442 Self::static_type()
8443 }
8444}
8445
8446impl From<PrintOperationResult> for glib::Value {
8447 #[inline]
8448 fn from(v: PrintOperationResult) -> Self {
8449 skip_assert_initialized!();
8450 ToValue::to_value(&v)
8451 }
8452}
8453
8454#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
8455#[non_exhaustive]
8456#[doc(alias = "GtkPrintPages")]
8457pub enum PrintPages {
8458 #[doc(alias = "GTK_PRINT_PAGES_ALL")]
8459 All,
8460 #[doc(alias = "GTK_PRINT_PAGES_CURRENT")]
8461 Current,
8462 #[doc(alias = "GTK_PRINT_PAGES_RANGES")]
8463 Ranges,
8464 #[doc(alias = "GTK_PRINT_PAGES_SELECTION")]
8465 Selection,
8466 #[doc(hidden)]
8467 __Unknown(i32),
8468}
8469
8470#[doc(hidden)]
8471impl IntoGlib for PrintPages {
8472 type GlibType = ffi::GtkPrintPages;
8473
8474 #[inline]
8475 fn into_glib(self) -> ffi::GtkPrintPages {
8476 match self {
8477 Self::All => ffi::GTK_PRINT_PAGES_ALL,
8478 Self::Current => ffi::GTK_PRINT_PAGES_CURRENT,
8479 Self::Ranges => ffi::GTK_PRINT_PAGES_RANGES,
8480 Self::Selection => ffi::GTK_PRINT_PAGES_SELECTION,
8481 Self::__Unknown(value) => value,
8482 }
8483 }
8484}
8485
8486#[doc(hidden)]
8487impl FromGlib<ffi::GtkPrintPages> for PrintPages {
8488 #[inline]
8489 unsafe fn from_glib(value: ffi::GtkPrintPages) -> Self {
8490 skip_assert_initialized!();
8491
8492 match value {
8493 ffi::GTK_PRINT_PAGES_ALL => Self::All,
8494 ffi::GTK_PRINT_PAGES_CURRENT => Self::Current,
8495 ffi::GTK_PRINT_PAGES_RANGES => Self::Ranges,
8496 ffi::GTK_PRINT_PAGES_SELECTION => Self::Selection,
8497 value => Self::__Unknown(value),
8498 }
8499 }
8500}
8501
8502impl StaticType for PrintPages {
8503 #[inline]
8504 #[doc(alias = "gtk_print_pages_get_type")]
8505 fn static_type() -> glib::Type {
8506 unsafe { from_glib(ffi::gtk_print_pages_get_type()) }
8507 }
8508}
8509
8510impl glib::HasParamSpec for PrintPages {
8511 type ParamSpec = glib::ParamSpecEnum;
8512 type SetValue = Self;
8513 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
8514
8515 fn param_spec_builder() -> Self::BuilderFn {
8516 Self::ParamSpec::builder_with_default
8517 }
8518}
8519
8520impl glib::value::ValueType for PrintPages {
8521 type Type = Self;
8522}
8523
8524unsafe impl<'a> glib::value::FromValue<'a> for PrintPages {
8525 type Checker = glib::value::GenericValueTypeChecker<Self>;
8526
8527 #[inline]
8528 unsafe fn from_value(value: &'a glib::Value) -> Self {
8529 skip_assert_initialized!();
8530 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
8531 }
8532}
8533
8534impl ToValue for PrintPages {
8535 #[inline]
8536 fn to_value(&self) -> glib::Value {
8537 let mut value = glib::Value::for_value_type::<Self>();
8538 unsafe {
8539 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
8540 }
8541 value
8542 }
8543
8544 #[inline]
8545 fn value_type(&self) -> glib::Type {
8546 Self::static_type()
8547 }
8548}
8549
8550impl From<PrintPages> for glib::Value {
8551 #[inline]
8552 fn from(v: PrintPages) -> Self {
8553 skip_assert_initialized!();
8554 ToValue::to_value(&v)
8555 }
8556}
8557
8558#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
8559#[non_exhaustive]
8560#[doc(alias = "GtkPrintQuality")]
8561pub enum PrintQuality {
8562 #[doc(alias = "GTK_PRINT_QUALITY_LOW")]
8563 Low,
8564 #[doc(alias = "GTK_PRINT_QUALITY_NORMAL")]
8565 Normal,
8566 #[doc(alias = "GTK_PRINT_QUALITY_HIGH")]
8567 High,
8568 #[doc(alias = "GTK_PRINT_QUALITY_DRAFT")]
8569 Draft,
8570 #[doc(hidden)]
8571 __Unknown(i32),
8572}
8573
8574#[doc(hidden)]
8575impl IntoGlib for PrintQuality {
8576 type GlibType = ffi::GtkPrintQuality;
8577
8578 #[inline]
8579 fn into_glib(self) -> ffi::GtkPrintQuality {
8580 match self {
8581 Self::Low => ffi::GTK_PRINT_QUALITY_LOW,
8582 Self::Normal => ffi::GTK_PRINT_QUALITY_NORMAL,
8583 Self::High => ffi::GTK_PRINT_QUALITY_HIGH,
8584 Self::Draft => ffi::GTK_PRINT_QUALITY_DRAFT,
8585 Self::__Unknown(value) => value,
8586 }
8587 }
8588}
8589
8590#[doc(hidden)]
8591impl FromGlib<ffi::GtkPrintQuality> for PrintQuality {
8592 #[inline]
8593 unsafe fn from_glib(value: ffi::GtkPrintQuality) -> Self {
8594 skip_assert_initialized!();
8595
8596 match value {
8597 ffi::GTK_PRINT_QUALITY_LOW => Self::Low,
8598 ffi::GTK_PRINT_QUALITY_NORMAL => Self::Normal,
8599 ffi::GTK_PRINT_QUALITY_HIGH => Self::High,
8600 ffi::GTK_PRINT_QUALITY_DRAFT => Self::Draft,
8601 value => Self::__Unknown(value),
8602 }
8603 }
8604}
8605
8606impl StaticType for PrintQuality {
8607 #[inline]
8608 #[doc(alias = "gtk_print_quality_get_type")]
8609 fn static_type() -> glib::Type {
8610 unsafe { from_glib(ffi::gtk_print_quality_get_type()) }
8611 }
8612}
8613
8614impl glib::HasParamSpec for PrintQuality {
8615 type ParamSpec = glib::ParamSpecEnum;
8616 type SetValue = Self;
8617 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
8618
8619 fn param_spec_builder() -> Self::BuilderFn {
8620 Self::ParamSpec::builder_with_default
8621 }
8622}
8623
8624impl glib::value::ValueType for PrintQuality {
8625 type Type = Self;
8626}
8627
8628unsafe impl<'a> glib::value::FromValue<'a> for PrintQuality {
8629 type Checker = glib::value::GenericValueTypeChecker<Self>;
8630
8631 #[inline]
8632 unsafe fn from_value(value: &'a glib::Value) -> Self {
8633 skip_assert_initialized!();
8634 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
8635 }
8636}
8637
8638impl ToValue for PrintQuality {
8639 #[inline]
8640 fn to_value(&self) -> glib::Value {
8641 let mut value = glib::Value::for_value_type::<Self>();
8642 unsafe {
8643 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
8644 }
8645 value
8646 }
8647
8648 #[inline]
8649 fn value_type(&self) -> glib::Type {
8650 Self::static_type()
8651 }
8652}
8653
8654impl From<PrintQuality> for glib::Value {
8655 #[inline]
8656 fn from(v: PrintQuality) -> Self {
8657 skip_assert_initialized!();
8658 ToValue::to_value(&v)
8659 }
8660}
8661
8662#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
8663#[non_exhaustive]
8664#[doc(alias = "GtkPrintStatus")]
8665pub enum PrintStatus {
8666 #[doc(alias = "GTK_PRINT_STATUS_INITIAL")]
8667 Initial,
8668 #[doc(alias = "GTK_PRINT_STATUS_PREPARING")]
8669 Preparing,
8670 #[doc(alias = "GTK_PRINT_STATUS_GENERATING_DATA")]
8671 GeneratingData,
8672 #[doc(alias = "GTK_PRINT_STATUS_SENDING_DATA")]
8673 SendingData,
8674 #[doc(alias = "GTK_PRINT_STATUS_PENDING")]
8675 Pending,
8676 #[doc(alias = "GTK_PRINT_STATUS_PENDING_ISSUE")]
8677 PendingIssue,
8678 #[doc(alias = "GTK_PRINT_STATUS_PRINTING")]
8679 Printing,
8680 #[doc(alias = "GTK_PRINT_STATUS_FINISHED")]
8681 Finished,
8682 #[doc(alias = "GTK_PRINT_STATUS_FINISHED_ABORTED")]
8683 FinishedAborted,
8684 #[doc(hidden)]
8685 __Unknown(i32),
8686}
8687
8688#[doc(hidden)]
8689impl IntoGlib for PrintStatus {
8690 type GlibType = ffi::GtkPrintStatus;
8691
8692 #[inline]
8693 fn into_glib(self) -> ffi::GtkPrintStatus {
8694 match self {
8695 Self::Initial => ffi::GTK_PRINT_STATUS_INITIAL,
8696 Self::Preparing => ffi::GTK_PRINT_STATUS_PREPARING,
8697 Self::GeneratingData => ffi::GTK_PRINT_STATUS_GENERATING_DATA,
8698 Self::SendingData => ffi::GTK_PRINT_STATUS_SENDING_DATA,
8699 Self::Pending => ffi::GTK_PRINT_STATUS_PENDING,
8700 Self::PendingIssue => ffi::GTK_PRINT_STATUS_PENDING_ISSUE,
8701 Self::Printing => ffi::GTK_PRINT_STATUS_PRINTING,
8702 Self::Finished => ffi::GTK_PRINT_STATUS_FINISHED,
8703 Self::FinishedAborted => ffi::GTK_PRINT_STATUS_FINISHED_ABORTED,
8704 Self::__Unknown(value) => value,
8705 }
8706 }
8707}
8708
8709#[doc(hidden)]
8710impl FromGlib<ffi::GtkPrintStatus> for PrintStatus {
8711 #[inline]
8712 unsafe fn from_glib(value: ffi::GtkPrintStatus) -> Self {
8713 skip_assert_initialized!();
8714
8715 match value {
8716 ffi::GTK_PRINT_STATUS_INITIAL => Self::Initial,
8717 ffi::GTK_PRINT_STATUS_PREPARING => Self::Preparing,
8718 ffi::GTK_PRINT_STATUS_GENERATING_DATA => Self::GeneratingData,
8719 ffi::GTK_PRINT_STATUS_SENDING_DATA => Self::SendingData,
8720 ffi::GTK_PRINT_STATUS_PENDING => Self::Pending,
8721 ffi::GTK_PRINT_STATUS_PENDING_ISSUE => Self::PendingIssue,
8722 ffi::GTK_PRINT_STATUS_PRINTING => Self::Printing,
8723 ffi::GTK_PRINT_STATUS_FINISHED => Self::Finished,
8724 ffi::GTK_PRINT_STATUS_FINISHED_ABORTED => Self::FinishedAborted,
8725 value => Self::__Unknown(value),
8726 }
8727 }
8728}
8729
8730impl StaticType for PrintStatus {
8731 #[inline]
8732 #[doc(alias = "gtk_print_status_get_type")]
8733 fn static_type() -> glib::Type {
8734 unsafe { from_glib(ffi::gtk_print_status_get_type()) }
8735 }
8736}
8737
8738impl glib::HasParamSpec for PrintStatus {
8739 type ParamSpec = glib::ParamSpecEnum;
8740 type SetValue = Self;
8741 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
8742
8743 fn param_spec_builder() -> Self::BuilderFn {
8744 Self::ParamSpec::builder_with_default
8745 }
8746}
8747
8748impl glib::value::ValueType for PrintStatus {
8749 type Type = Self;
8750}
8751
8752unsafe impl<'a> glib::value::FromValue<'a> for PrintStatus {
8753 type Checker = glib::value::GenericValueTypeChecker<Self>;
8754
8755 #[inline]
8756 unsafe fn from_value(value: &'a glib::Value) -> Self {
8757 skip_assert_initialized!();
8758 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
8759 }
8760}
8761
8762impl ToValue for PrintStatus {
8763 #[inline]
8764 fn to_value(&self) -> glib::Value {
8765 let mut value = glib::Value::for_value_type::<Self>();
8766 unsafe {
8767 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
8768 }
8769 value
8770 }
8771
8772 #[inline]
8773 fn value_type(&self) -> glib::Type {
8774 Self::static_type()
8775 }
8776}
8777
8778impl From<PrintStatus> for glib::Value {
8779 #[inline]
8780 fn from(v: PrintStatus) -> Self {
8781 skip_assert_initialized!();
8782 ToValue::to_value(&v)
8783 }
8784}
8785
8786#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
8787#[non_exhaustive]
8788#[doc(alias = "GtkPropagationLimit")]
8789pub enum PropagationLimit {
8790 #[doc(alias = "GTK_LIMIT_NONE")]
8791 None,
8792 #[doc(alias = "GTK_LIMIT_SAME_NATIVE")]
8793 SameNative,
8794 #[doc(hidden)]
8795 __Unknown(i32),
8796}
8797
8798#[doc(hidden)]
8799impl IntoGlib for PropagationLimit {
8800 type GlibType = ffi::GtkPropagationLimit;
8801
8802 #[inline]
8803 fn into_glib(self) -> ffi::GtkPropagationLimit {
8804 match self {
8805 Self::None => ffi::GTK_LIMIT_NONE,
8806 Self::SameNative => ffi::GTK_LIMIT_SAME_NATIVE,
8807 Self::__Unknown(value) => value,
8808 }
8809 }
8810}
8811
8812#[doc(hidden)]
8813impl FromGlib<ffi::GtkPropagationLimit> for PropagationLimit {
8814 #[inline]
8815 unsafe fn from_glib(value: ffi::GtkPropagationLimit) -> Self {
8816 skip_assert_initialized!();
8817
8818 match value {
8819 ffi::GTK_LIMIT_NONE => Self::None,
8820 ffi::GTK_LIMIT_SAME_NATIVE => Self::SameNative,
8821 value => Self::__Unknown(value),
8822 }
8823 }
8824}
8825
8826impl StaticType for PropagationLimit {
8827 #[inline]
8828 #[doc(alias = "gtk_propagation_limit_get_type")]
8829 fn static_type() -> glib::Type {
8830 unsafe { from_glib(ffi::gtk_propagation_limit_get_type()) }
8831 }
8832}
8833
8834impl glib::HasParamSpec for PropagationLimit {
8835 type ParamSpec = glib::ParamSpecEnum;
8836 type SetValue = Self;
8837 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
8838
8839 fn param_spec_builder() -> Self::BuilderFn {
8840 Self::ParamSpec::builder_with_default
8841 }
8842}
8843
8844impl glib::value::ValueType for PropagationLimit {
8845 type Type = Self;
8846}
8847
8848unsafe impl<'a> glib::value::FromValue<'a> for PropagationLimit {
8849 type Checker = glib::value::GenericValueTypeChecker<Self>;
8850
8851 #[inline]
8852 unsafe fn from_value(value: &'a glib::Value) -> Self {
8853 skip_assert_initialized!();
8854 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
8855 }
8856}
8857
8858impl ToValue for PropagationLimit {
8859 #[inline]
8860 fn to_value(&self) -> glib::Value {
8861 let mut value = glib::Value::for_value_type::<Self>();
8862 unsafe {
8863 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
8864 }
8865 value
8866 }
8867
8868 #[inline]
8869 fn value_type(&self) -> glib::Type {
8870 Self::static_type()
8871 }
8872}
8873
8874impl From<PropagationLimit> for glib::Value {
8875 #[inline]
8876 fn from(v: PropagationLimit) -> Self {
8877 skip_assert_initialized!();
8878 ToValue::to_value(&v)
8879 }
8880}
8881
8882#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
8883#[non_exhaustive]
8884#[doc(alias = "GtkPropagationPhase")]
8885pub enum PropagationPhase {
8886 #[doc(alias = "GTK_PHASE_NONE")]
8887 None,
8888 #[doc(alias = "GTK_PHASE_CAPTURE")]
8889 Capture,
8890 #[doc(alias = "GTK_PHASE_BUBBLE")]
8891 Bubble,
8892 #[doc(alias = "GTK_PHASE_TARGET")]
8893 Target,
8894 #[doc(hidden)]
8895 __Unknown(i32),
8896}
8897
8898#[doc(hidden)]
8899impl IntoGlib for PropagationPhase {
8900 type GlibType = ffi::GtkPropagationPhase;
8901
8902 #[inline]
8903 fn into_glib(self) -> ffi::GtkPropagationPhase {
8904 match self {
8905 Self::None => ffi::GTK_PHASE_NONE,
8906 Self::Capture => ffi::GTK_PHASE_CAPTURE,
8907 Self::Bubble => ffi::GTK_PHASE_BUBBLE,
8908 Self::Target => ffi::GTK_PHASE_TARGET,
8909 Self::__Unknown(value) => value,
8910 }
8911 }
8912}
8913
8914#[doc(hidden)]
8915impl FromGlib<ffi::GtkPropagationPhase> for PropagationPhase {
8916 #[inline]
8917 unsafe fn from_glib(value: ffi::GtkPropagationPhase) -> Self {
8918 skip_assert_initialized!();
8919
8920 match value {
8921 ffi::GTK_PHASE_NONE => Self::None,
8922 ffi::GTK_PHASE_CAPTURE => Self::Capture,
8923 ffi::GTK_PHASE_BUBBLE => Self::Bubble,
8924 ffi::GTK_PHASE_TARGET => Self::Target,
8925 value => Self::__Unknown(value),
8926 }
8927 }
8928}
8929
8930impl StaticType for PropagationPhase {
8931 #[inline]
8932 #[doc(alias = "gtk_propagation_phase_get_type")]
8933 fn static_type() -> glib::Type {
8934 unsafe { from_glib(ffi::gtk_propagation_phase_get_type()) }
8935 }
8936}
8937
8938impl glib::HasParamSpec for PropagationPhase {
8939 type ParamSpec = glib::ParamSpecEnum;
8940 type SetValue = Self;
8941 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
8942
8943 fn param_spec_builder() -> Self::BuilderFn {
8944 Self::ParamSpec::builder_with_default
8945 }
8946}
8947
8948impl glib::value::ValueType for PropagationPhase {
8949 type Type = Self;
8950}
8951
8952unsafe impl<'a> glib::value::FromValue<'a> for PropagationPhase {
8953 type Checker = glib::value::GenericValueTypeChecker<Self>;
8954
8955 #[inline]
8956 unsafe fn from_value(value: &'a glib::Value) -> Self {
8957 skip_assert_initialized!();
8958 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
8959 }
8960}
8961
8962impl ToValue for PropagationPhase {
8963 #[inline]
8964 fn to_value(&self) -> glib::Value {
8965 let mut value = glib::Value::for_value_type::<Self>();
8966 unsafe {
8967 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
8968 }
8969 value
8970 }
8971
8972 #[inline]
8973 fn value_type(&self) -> glib::Type {
8974 Self::static_type()
8975 }
8976}
8977
8978impl From<PropagationPhase> for glib::Value {
8979 #[inline]
8980 fn from(v: PropagationPhase) -> Self {
8981 skip_assert_initialized!();
8982 ToValue::to_value(&v)
8983 }
8984}
8985
8986#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
8987#[non_exhaustive]
8988#[doc(alias = "GtkRecentManagerError")]
8989pub enum RecentManagerError {
8990 #[doc(alias = "GTK_RECENT_MANAGER_ERROR_NOT_FOUND")]
8991 NotFound,
8992 #[doc(alias = "GTK_RECENT_MANAGER_ERROR_INVALID_URI")]
8993 InvalidUri,
8994 #[doc(alias = "GTK_RECENT_MANAGER_ERROR_INVALID_ENCODING")]
8995 InvalidEncoding,
8996 #[doc(alias = "GTK_RECENT_MANAGER_ERROR_NOT_REGISTERED")]
8997 NotRegistered,
8998 #[doc(alias = "GTK_RECENT_MANAGER_ERROR_READ")]
8999 Read,
9000 #[doc(alias = "GTK_RECENT_MANAGER_ERROR_WRITE")]
9001 Write,
9002 #[doc(alias = "GTK_RECENT_MANAGER_ERROR_UNKNOWN")]
9003 Unknown,
9004 #[doc(hidden)]
9005 __Unknown(i32),
9006}
9007
9008#[doc(hidden)]
9009impl IntoGlib for RecentManagerError {
9010 type GlibType = ffi::GtkRecentManagerError;
9011
9012 #[inline]
9013 fn into_glib(self) -> ffi::GtkRecentManagerError {
9014 match self {
9015 Self::NotFound => ffi::GTK_RECENT_MANAGER_ERROR_NOT_FOUND,
9016 Self::InvalidUri => ffi::GTK_RECENT_MANAGER_ERROR_INVALID_URI,
9017 Self::InvalidEncoding => ffi::GTK_RECENT_MANAGER_ERROR_INVALID_ENCODING,
9018 Self::NotRegistered => ffi::GTK_RECENT_MANAGER_ERROR_NOT_REGISTERED,
9019 Self::Read => ffi::GTK_RECENT_MANAGER_ERROR_READ,
9020 Self::Write => ffi::GTK_RECENT_MANAGER_ERROR_WRITE,
9021 Self::Unknown => ffi::GTK_RECENT_MANAGER_ERROR_UNKNOWN,
9022 Self::__Unknown(value) => value,
9023 }
9024 }
9025}
9026
9027#[doc(hidden)]
9028impl FromGlib<ffi::GtkRecentManagerError> for RecentManagerError {
9029 #[inline]
9030 unsafe fn from_glib(value: ffi::GtkRecentManagerError) -> Self {
9031 skip_assert_initialized!();
9032
9033 match value {
9034 ffi::GTK_RECENT_MANAGER_ERROR_NOT_FOUND => Self::NotFound,
9035 ffi::GTK_RECENT_MANAGER_ERROR_INVALID_URI => Self::InvalidUri,
9036 ffi::GTK_RECENT_MANAGER_ERROR_INVALID_ENCODING => Self::InvalidEncoding,
9037 ffi::GTK_RECENT_MANAGER_ERROR_NOT_REGISTERED => Self::NotRegistered,
9038 ffi::GTK_RECENT_MANAGER_ERROR_READ => Self::Read,
9039 ffi::GTK_RECENT_MANAGER_ERROR_WRITE => Self::Write,
9040 ffi::GTK_RECENT_MANAGER_ERROR_UNKNOWN => Self::Unknown,
9041 value => Self::__Unknown(value),
9042 }
9043 }
9044}
9045
9046impl glib::error::ErrorDomain for RecentManagerError {
9047 #[inline]
9048 fn domain() -> glib::Quark {
9049 skip_assert_initialized!();
9050
9051 unsafe { from_glib(ffi::gtk_recent_manager_error_quark()) }
9052 }
9053
9054 #[inline]
9055 fn code(self) -> i32 {
9056 self.into_glib()
9057 }
9058
9059 #[inline]
9060 #[allow(clippy::match_single_binding)]
9061 fn from(code: i32) -> Option<Self> {
9062 skip_assert_initialized!();
9063 match unsafe { from_glib(code) } {
9064 value => Some(value),
9065 }
9066 }
9067}
9068
9069impl StaticType for RecentManagerError {
9070 #[inline]
9071 #[doc(alias = "gtk_recent_manager_error_get_type")]
9072 fn static_type() -> glib::Type {
9073 unsafe { from_glib(ffi::gtk_recent_manager_error_get_type()) }
9074 }
9075}
9076
9077impl glib::HasParamSpec for RecentManagerError {
9078 type ParamSpec = glib::ParamSpecEnum;
9079 type SetValue = Self;
9080 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
9081
9082 fn param_spec_builder() -> Self::BuilderFn {
9083 Self::ParamSpec::builder_with_default
9084 }
9085}
9086
9087impl glib::value::ValueType for RecentManagerError {
9088 type Type = Self;
9089}
9090
9091unsafe impl<'a> glib::value::FromValue<'a> for RecentManagerError {
9092 type Checker = glib::value::GenericValueTypeChecker<Self>;
9093
9094 #[inline]
9095 unsafe fn from_value(value: &'a glib::Value) -> Self {
9096 skip_assert_initialized!();
9097 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
9098 }
9099}
9100
9101impl ToValue for RecentManagerError {
9102 #[inline]
9103 fn to_value(&self) -> glib::Value {
9104 let mut value = glib::Value::for_value_type::<Self>();
9105 unsafe {
9106 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
9107 }
9108 value
9109 }
9110
9111 #[inline]
9112 fn value_type(&self) -> glib::Type {
9113 Self::static_type()
9114 }
9115}
9116
9117impl From<RecentManagerError> for glib::Value {
9118 #[inline]
9119 fn from(v: RecentManagerError) -> Self {
9120 skip_assert_initialized!();
9121 ToValue::to_value(&v)
9122 }
9123}
9124
9125#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
9126#[non_exhaustive]
9127#[doc(alias = "GtkRevealerTransitionType")]
9128pub enum RevealerTransitionType {
9129 #[doc(alias = "GTK_REVEALER_TRANSITION_TYPE_NONE")]
9130 None,
9131 #[doc(alias = "GTK_REVEALER_TRANSITION_TYPE_CROSSFADE")]
9132 Crossfade,
9133 #[doc(alias = "GTK_REVEALER_TRANSITION_TYPE_SLIDE_RIGHT")]
9134 SlideRight,
9135 #[doc(alias = "GTK_REVEALER_TRANSITION_TYPE_SLIDE_LEFT")]
9136 SlideLeft,
9137 #[doc(alias = "GTK_REVEALER_TRANSITION_TYPE_SLIDE_UP")]
9138 SlideUp,
9139 #[doc(alias = "GTK_REVEALER_TRANSITION_TYPE_SLIDE_DOWN")]
9140 SlideDown,
9141 #[doc(alias = "GTK_REVEALER_TRANSITION_TYPE_SWING_RIGHT")]
9142 SwingRight,
9143 #[doc(alias = "GTK_REVEALER_TRANSITION_TYPE_SWING_LEFT")]
9144 SwingLeft,
9145 #[doc(alias = "GTK_REVEALER_TRANSITION_TYPE_SWING_UP")]
9146 SwingUp,
9147 #[doc(alias = "GTK_REVEALER_TRANSITION_TYPE_SWING_DOWN")]
9148 SwingDown,
9149 #[doc(hidden)]
9150 __Unknown(i32),
9151}
9152
9153#[doc(hidden)]
9154impl IntoGlib for RevealerTransitionType {
9155 type GlibType = ffi::GtkRevealerTransitionType;
9156
9157 #[inline]
9158 fn into_glib(self) -> ffi::GtkRevealerTransitionType {
9159 match self {
9160 Self::None => ffi::GTK_REVEALER_TRANSITION_TYPE_NONE,
9161 Self::Crossfade => ffi::GTK_REVEALER_TRANSITION_TYPE_CROSSFADE,
9162 Self::SlideRight => ffi::GTK_REVEALER_TRANSITION_TYPE_SLIDE_RIGHT,
9163 Self::SlideLeft => ffi::GTK_REVEALER_TRANSITION_TYPE_SLIDE_LEFT,
9164 Self::SlideUp => ffi::GTK_REVEALER_TRANSITION_TYPE_SLIDE_UP,
9165 Self::SlideDown => ffi::GTK_REVEALER_TRANSITION_TYPE_SLIDE_DOWN,
9166 Self::SwingRight => ffi::GTK_REVEALER_TRANSITION_TYPE_SWING_RIGHT,
9167 Self::SwingLeft => ffi::GTK_REVEALER_TRANSITION_TYPE_SWING_LEFT,
9168 Self::SwingUp => ffi::GTK_REVEALER_TRANSITION_TYPE_SWING_UP,
9169 Self::SwingDown => ffi::GTK_REVEALER_TRANSITION_TYPE_SWING_DOWN,
9170 Self::__Unknown(value) => value,
9171 }
9172 }
9173}
9174
9175#[doc(hidden)]
9176impl FromGlib<ffi::GtkRevealerTransitionType> for RevealerTransitionType {
9177 #[inline]
9178 unsafe fn from_glib(value: ffi::GtkRevealerTransitionType) -> Self {
9179 skip_assert_initialized!();
9180
9181 match value {
9182 ffi::GTK_REVEALER_TRANSITION_TYPE_NONE => Self::None,
9183 ffi::GTK_REVEALER_TRANSITION_TYPE_CROSSFADE => Self::Crossfade,
9184 ffi::GTK_REVEALER_TRANSITION_TYPE_SLIDE_RIGHT => Self::SlideRight,
9185 ffi::GTK_REVEALER_TRANSITION_TYPE_SLIDE_LEFT => Self::SlideLeft,
9186 ffi::GTK_REVEALER_TRANSITION_TYPE_SLIDE_UP => Self::SlideUp,
9187 ffi::GTK_REVEALER_TRANSITION_TYPE_SLIDE_DOWN => Self::SlideDown,
9188 ffi::GTK_REVEALER_TRANSITION_TYPE_SWING_RIGHT => Self::SwingRight,
9189 ffi::GTK_REVEALER_TRANSITION_TYPE_SWING_LEFT => Self::SwingLeft,
9190 ffi::GTK_REVEALER_TRANSITION_TYPE_SWING_UP => Self::SwingUp,
9191 ffi::GTK_REVEALER_TRANSITION_TYPE_SWING_DOWN => Self::SwingDown,
9192 value => Self::__Unknown(value),
9193 }
9194 }
9195}
9196
9197impl StaticType for RevealerTransitionType {
9198 #[inline]
9199 #[doc(alias = "gtk_revealer_transition_type_get_type")]
9200 fn static_type() -> glib::Type {
9201 unsafe { from_glib(ffi::gtk_revealer_transition_type_get_type()) }
9202 }
9203}
9204
9205impl glib::HasParamSpec for RevealerTransitionType {
9206 type ParamSpec = glib::ParamSpecEnum;
9207 type SetValue = Self;
9208 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
9209
9210 fn param_spec_builder() -> Self::BuilderFn {
9211 Self::ParamSpec::builder_with_default
9212 }
9213}
9214
9215impl glib::value::ValueType for RevealerTransitionType {
9216 type Type = Self;
9217}
9218
9219unsafe impl<'a> glib::value::FromValue<'a> for RevealerTransitionType {
9220 type Checker = glib::value::GenericValueTypeChecker<Self>;
9221
9222 #[inline]
9223 unsafe fn from_value(value: &'a glib::Value) -> Self {
9224 skip_assert_initialized!();
9225 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
9226 }
9227}
9228
9229impl ToValue for RevealerTransitionType {
9230 #[inline]
9231 fn to_value(&self) -> glib::Value {
9232 let mut value = glib::Value::for_value_type::<Self>();
9233 unsafe {
9234 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
9235 }
9236 value
9237 }
9238
9239 #[inline]
9240 fn value_type(&self) -> glib::Type {
9241 Self::static_type()
9242 }
9243}
9244
9245impl From<RevealerTransitionType> for glib::Value {
9246 #[inline]
9247 fn from(v: RevealerTransitionType) -> Self {
9248 skip_assert_initialized!();
9249 ToValue::to_value(&v)
9250 }
9251}
9252
9253#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
9254#[non_exhaustive]
9255#[doc(alias = "GtkScrollStep")]
9256pub enum ScrollStep {
9257 #[doc(alias = "GTK_SCROLL_STEPS")]
9258 Steps,
9259 #[doc(alias = "GTK_SCROLL_PAGES")]
9260 Pages,
9261 #[doc(alias = "GTK_SCROLL_ENDS")]
9262 Ends,
9263 #[doc(alias = "GTK_SCROLL_HORIZONTAL_STEPS")]
9264 HorizontalSteps,
9265 #[doc(alias = "GTK_SCROLL_HORIZONTAL_PAGES")]
9266 HorizontalPages,
9267 #[doc(alias = "GTK_SCROLL_HORIZONTAL_ENDS")]
9268 HorizontalEnds,
9269 #[doc(hidden)]
9270 __Unknown(i32),
9271}
9272
9273#[doc(hidden)]
9274impl IntoGlib for ScrollStep {
9275 type GlibType = ffi::GtkScrollStep;
9276
9277 #[inline]
9278 fn into_glib(self) -> ffi::GtkScrollStep {
9279 match self {
9280 Self::Steps => ffi::GTK_SCROLL_STEPS,
9281 Self::Pages => ffi::GTK_SCROLL_PAGES,
9282 Self::Ends => ffi::GTK_SCROLL_ENDS,
9283 Self::HorizontalSteps => ffi::GTK_SCROLL_HORIZONTAL_STEPS,
9284 Self::HorizontalPages => ffi::GTK_SCROLL_HORIZONTAL_PAGES,
9285 Self::HorizontalEnds => ffi::GTK_SCROLL_HORIZONTAL_ENDS,
9286 Self::__Unknown(value) => value,
9287 }
9288 }
9289}
9290
9291#[doc(hidden)]
9292impl FromGlib<ffi::GtkScrollStep> for ScrollStep {
9293 #[inline]
9294 unsafe fn from_glib(value: ffi::GtkScrollStep) -> Self {
9295 skip_assert_initialized!();
9296
9297 match value {
9298 ffi::GTK_SCROLL_STEPS => Self::Steps,
9299 ffi::GTK_SCROLL_PAGES => Self::Pages,
9300 ffi::GTK_SCROLL_ENDS => Self::Ends,
9301 ffi::GTK_SCROLL_HORIZONTAL_STEPS => Self::HorizontalSteps,
9302 ffi::GTK_SCROLL_HORIZONTAL_PAGES => Self::HorizontalPages,
9303 ffi::GTK_SCROLL_HORIZONTAL_ENDS => Self::HorizontalEnds,
9304 value => Self::__Unknown(value),
9305 }
9306 }
9307}
9308
9309impl StaticType for ScrollStep {
9310 #[inline]
9311 #[doc(alias = "gtk_scroll_step_get_type")]
9312 fn static_type() -> glib::Type {
9313 unsafe { from_glib(ffi::gtk_scroll_step_get_type()) }
9314 }
9315}
9316
9317impl glib::HasParamSpec for ScrollStep {
9318 type ParamSpec = glib::ParamSpecEnum;
9319 type SetValue = Self;
9320 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
9321
9322 fn param_spec_builder() -> Self::BuilderFn {
9323 Self::ParamSpec::builder_with_default
9324 }
9325}
9326
9327impl glib::value::ValueType for ScrollStep {
9328 type Type = Self;
9329}
9330
9331unsafe impl<'a> glib::value::FromValue<'a> for ScrollStep {
9332 type Checker = glib::value::GenericValueTypeChecker<Self>;
9333
9334 #[inline]
9335 unsafe fn from_value(value: &'a glib::Value) -> Self {
9336 skip_assert_initialized!();
9337 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
9338 }
9339}
9340
9341impl ToValue for ScrollStep {
9342 #[inline]
9343 fn to_value(&self) -> glib::Value {
9344 let mut value = glib::Value::for_value_type::<Self>();
9345 unsafe {
9346 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
9347 }
9348 value
9349 }
9350
9351 #[inline]
9352 fn value_type(&self) -> glib::Type {
9353 Self::static_type()
9354 }
9355}
9356
9357impl From<ScrollStep> for glib::Value {
9358 #[inline]
9359 fn from(v: ScrollStep) -> Self {
9360 skip_assert_initialized!();
9361 ToValue::to_value(&v)
9362 }
9363}
9364
9365#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
9366#[non_exhaustive]
9367#[doc(alias = "GtkScrollType")]
9368pub enum ScrollType {
9369 #[doc(alias = "GTK_SCROLL_NONE")]
9370 None,
9371 #[doc(alias = "GTK_SCROLL_JUMP")]
9372 Jump,
9373 #[doc(alias = "GTK_SCROLL_STEP_BACKWARD")]
9374 StepBackward,
9375 #[doc(alias = "GTK_SCROLL_STEP_FORWARD")]
9376 StepForward,
9377 #[doc(alias = "GTK_SCROLL_PAGE_BACKWARD")]
9378 PageBackward,
9379 #[doc(alias = "GTK_SCROLL_PAGE_FORWARD")]
9380 PageForward,
9381 #[doc(alias = "GTK_SCROLL_STEP_UP")]
9382 StepUp,
9383 #[doc(alias = "GTK_SCROLL_STEP_DOWN")]
9384 StepDown,
9385 #[doc(alias = "GTK_SCROLL_PAGE_UP")]
9386 PageUp,
9387 #[doc(alias = "GTK_SCROLL_PAGE_DOWN")]
9388 PageDown,
9389 #[doc(alias = "GTK_SCROLL_STEP_LEFT")]
9390 StepLeft,
9391 #[doc(alias = "GTK_SCROLL_STEP_RIGHT")]
9392 StepRight,
9393 #[doc(alias = "GTK_SCROLL_PAGE_LEFT")]
9394 PageLeft,
9395 #[doc(alias = "GTK_SCROLL_PAGE_RIGHT")]
9396 PageRight,
9397 #[doc(alias = "GTK_SCROLL_START")]
9398 Start,
9399 #[doc(alias = "GTK_SCROLL_END")]
9400 End,
9401 #[doc(hidden)]
9402 __Unknown(i32),
9403}
9404
9405#[doc(hidden)]
9406impl IntoGlib for ScrollType {
9407 type GlibType = ffi::GtkScrollType;
9408
9409 fn into_glib(self) -> ffi::GtkScrollType {
9410 match self {
9411 Self::None => ffi::GTK_SCROLL_NONE,
9412 Self::Jump => ffi::GTK_SCROLL_JUMP,
9413 Self::StepBackward => ffi::GTK_SCROLL_STEP_BACKWARD,
9414 Self::StepForward => ffi::GTK_SCROLL_STEP_FORWARD,
9415 Self::PageBackward => ffi::GTK_SCROLL_PAGE_BACKWARD,
9416 Self::PageForward => ffi::GTK_SCROLL_PAGE_FORWARD,
9417 Self::StepUp => ffi::GTK_SCROLL_STEP_UP,
9418 Self::StepDown => ffi::GTK_SCROLL_STEP_DOWN,
9419 Self::PageUp => ffi::GTK_SCROLL_PAGE_UP,
9420 Self::PageDown => ffi::GTK_SCROLL_PAGE_DOWN,
9421 Self::StepLeft => ffi::GTK_SCROLL_STEP_LEFT,
9422 Self::StepRight => ffi::GTK_SCROLL_STEP_RIGHT,
9423 Self::PageLeft => ffi::GTK_SCROLL_PAGE_LEFT,
9424 Self::PageRight => ffi::GTK_SCROLL_PAGE_RIGHT,
9425 Self::Start => ffi::GTK_SCROLL_START,
9426 Self::End => ffi::GTK_SCROLL_END,
9427 Self::__Unknown(value) => value,
9428 }
9429 }
9430}
9431
9432#[doc(hidden)]
9433impl FromGlib<ffi::GtkScrollType> for ScrollType {
9434 unsafe fn from_glib(value: ffi::GtkScrollType) -> Self {
9435 skip_assert_initialized!();
9436
9437 match value {
9438 ffi::GTK_SCROLL_NONE => Self::None,
9439 ffi::GTK_SCROLL_JUMP => Self::Jump,
9440 ffi::GTK_SCROLL_STEP_BACKWARD => Self::StepBackward,
9441 ffi::GTK_SCROLL_STEP_FORWARD => Self::StepForward,
9442 ffi::GTK_SCROLL_PAGE_BACKWARD => Self::PageBackward,
9443 ffi::GTK_SCROLL_PAGE_FORWARD => Self::PageForward,
9444 ffi::GTK_SCROLL_STEP_UP => Self::StepUp,
9445 ffi::GTK_SCROLL_STEP_DOWN => Self::StepDown,
9446 ffi::GTK_SCROLL_PAGE_UP => Self::PageUp,
9447 ffi::GTK_SCROLL_PAGE_DOWN => Self::PageDown,
9448 ffi::GTK_SCROLL_STEP_LEFT => Self::StepLeft,
9449 ffi::GTK_SCROLL_STEP_RIGHT => Self::StepRight,
9450 ffi::GTK_SCROLL_PAGE_LEFT => Self::PageLeft,
9451 ffi::GTK_SCROLL_PAGE_RIGHT => Self::PageRight,
9452 ffi::GTK_SCROLL_START => Self::Start,
9453 ffi::GTK_SCROLL_END => Self::End,
9454 value => Self::__Unknown(value),
9455 }
9456 }
9457}
9458
9459impl StaticType for ScrollType {
9460 #[inline]
9461 #[doc(alias = "gtk_scroll_type_get_type")]
9462 fn static_type() -> glib::Type {
9463 unsafe { from_glib(ffi::gtk_scroll_type_get_type()) }
9464 }
9465}
9466
9467impl glib::HasParamSpec for ScrollType {
9468 type ParamSpec = glib::ParamSpecEnum;
9469 type SetValue = Self;
9470 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
9471
9472 fn param_spec_builder() -> Self::BuilderFn {
9473 Self::ParamSpec::builder_with_default
9474 }
9475}
9476
9477impl glib::value::ValueType for ScrollType {
9478 type Type = Self;
9479}
9480
9481unsafe impl<'a> glib::value::FromValue<'a> for ScrollType {
9482 type Checker = glib::value::GenericValueTypeChecker<Self>;
9483
9484 #[inline]
9485 unsafe fn from_value(value: &'a glib::Value) -> Self {
9486 skip_assert_initialized!();
9487 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
9488 }
9489}
9490
9491impl ToValue for ScrollType {
9492 #[inline]
9493 fn to_value(&self) -> glib::Value {
9494 let mut value = glib::Value::for_value_type::<Self>();
9495 unsafe {
9496 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
9497 }
9498 value
9499 }
9500
9501 #[inline]
9502 fn value_type(&self) -> glib::Type {
9503 Self::static_type()
9504 }
9505}
9506
9507impl From<ScrollType> for glib::Value {
9508 #[inline]
9509 fn from(v: ScrollType) -> Self {
9510 skip_assert_initialized!();
9511 ToValue::to_value(&v)
9512 }
9513}
9514
9515#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
9516#[non_exhaustive]
9517#[doc(alias = "GtkScrollablePolicy")]
9518pub enum ScrollablePolicy {
9519 #[doc(alias = "GTK_SCROLL_MINIMUM")]
9520 Minimum,
9521 #[doc(alias = "GTK_SCROLL_NATURAL")]
9522 Natural,
9523 #[doc(hidden)]
9524 __Unknown(i32),
9525}
9526
9527#[doc(hidden)]
9528impl IntoGlib for ScrollablePolicy {
9529 type GlibType = ffi::GtkScrollablePolicy;
9530
9531 #[inline]
9532 fn into_glib(self) -> ffi::GtkScrollablePolicy {
9533 match self {
9534 Self::Minimum => ffi::GTK_SCROLL_MINIMUM,
9535 Self::Natural => ffi::GTK_SCROLL_NATURAL,
9536 Self::__Unknown(value) => value,
9537 }
9538 }
9539}
9540
9541#[doc(hidden)]
9542impl FromGlib<ffi::GtkScrollablePolicy> for ScrollablePolicy {
9543 #[inline]
9544 unsafe fn from_glib(value: ffi::GtkScrollablePolicy) -> Self {
9545 skip_assert_initialized!();
9546
9547 match value {
9548 ffi::GTK_SCROLL_MINIMUM => Self::Minimum,
9549 ffi::GTK_SCROLL_NATURAL => Self::Natural,
9550 value => Self::__Unknown(value),
9551 }
9552 }
9553}
9554
9555impl StaticType for ScrollablePolicy {
9556 #[inline]
9557 #[doc(alias = "gtk_scrollable_policy_get_type")]
9558 fn static_type() -> glib::Type {
9559 unsafe { from_glib(ffi::gtk_scrollable_policy_get_type()) }
9560 }
9561}
9562
9563impl glib::HasParamSpec for ScrollablePolicy {
9564 type ParamSpec = glib::ParamSpecEnum;
9565 type SetValue = Self;
9566 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
9567
9568 fn param_spec_builder() -> Self::BuilderFn {
9569 Self::ParamSpec::builder_with_default
9570 }
9571}
9572
9573impl glib::value::ValueType for ScrollablePolicy {
9574 type Type = Self;
9575}
9576
9577unsafe impl<'a> glib::value::FromValue<'a> for ScrollablePolicy {
9578 type Checker = glib::value::GenericValueTypeChecker<Self>;
9579
9580 #[inline]
9581 unsafe fn from_value(value: &'a glib::Value) -> Self {
9582 skip_assert_initialized!();
9583 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
9584 }
9585}
9586
9587impl ToValue for ScrollablePolicy {
9588 #[inline]
9589 fn to_value(&self) -> glib::Value {
9590 let mut value = glib::Value::for_value_type::<Self>();
9591 unsafe {
9592 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
9593 }
9594 value
9595 }
9596
9597 #[inline]
9598 fn value_type(&self) -> glib::Type {
9599 Self::static_type()
9600 }
9601}
9602
9603impl From<ScrollablePolicy> for glib::Value {
9604 #[inline]
9605 fn from(v: ScrollablePolicy) -> Self {
9606 skip_assert_initialized!();
9607 ToValue::to_value(&v)
9608 }
9609}
9610
9611#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
9612#[non_exhaustive]
9613#[doc(alias = "GtkSelectionMode")]
9614pub enum SelectionMode {
9615 #[doc(alias = "GTK_SELECTION_NONE")]
9616 None,
9617 #[doc(alias = "GTK_SELECTION_SINGLE")]
9618 Single,
9619 #[doc(alias = "GTK_SELECTION_BROWSE")]
9620 Browse,
9621 #[doc(alias = "GTK_SELECTION_MULTIPLE")]
9622 Multiple,
9623 #[doc(hidden)]
9624 __Unknown(i32),
9625}
9626
9627#[doc(hidden)]
9628impl IntoGlib for SelectionMode {
9629 type GlibType = ffi::GtkSelectionMode;
9630
9631 #[inline]
9632 fn into_glib(self) -> ffi::GtkSelectionMode {
9633 match self {
9634 Self::None => ffi::GTK_SELECTION_NONE,
9635 Self::Single => ffi::GTK_SELECTION_SINGLE,
9636 Self::Browse => ffi::GTK_SELECTION_BROWSE,
9637 Self::Multiple => ffi::GTK_SELECTION_MULTIPLE,
9638 Self::__Unknown(value) => value,
9639 }
9640 }
9641}
9642
9643#[doc(hidden)]
9644impl FromGlib<ffi::GtkSelectionMode> for SelectionMode {
9645 #[inline]
9646 unsafe fn from_glib(value: ffi::GtkSelectionMode) -> Self {
9647 skip_assert_initialized!();
9648
9649 match value {
9650 ffi::GTK_SELECTION_NONE => Self::None,
9651 ffi::GTK_SELECTION_SINGLE => Self::Single,
9652 ffi::GTK_SELECTION_BROWSE => Self::Browse,
9653 ffi::GTK_SELECTION_MULTIPLE => Self::Multiple,
9654 value => Self::__Unknown(value),
9655 }
9656 }
9657}
9658
9659impl StaticType for SelectionMode {
9660 #[inline]
9661 #[doc(alias = "gtk_selection_mode_get_type")]
9662 fn static_type() -> glib::Type {
9663 unsafe { from_glib(ffi::gtk_selection_mode_get_type()) }
9664 }
9665}
9666
9667impl glib::HasParamSpec for SelectionMode {
9668 type ParamSpec = glib::ParamSpecEnum;
9669 type SetValue = Self;
9670 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
9671
9672 fn param_spec_builder() -> Self::BuilderFn {
9673 Self::ParamSpec::builder_with_default
9674 }
9675}
9676
9677impl glib::value::ValueType for SelectionMode {
9678 type Type = Self;
9679}
9680
9681unsafe impl<'a> glib::value::FromValue<'a> for SelectionMode {
9682 type Checker = glib::value::GenericValueTypeChecker<Self>;
9683
9684 #[inline]
9685 unsafe fn from_value(value: &'a glib::Value) -> Self {
9686 skip_assert_initialized!();
9687 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
9688 }
9689}
9690
9691impl ToValue for SelectionMode {
9692 #[inline]
9693 fn to_value(&self) -> glib::Value {
9694 let mut value = glib::Value::for_value_type::<Self>();
9695 unsafe {
9696 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
9697 }
9698 value
9699 }
9700
9701 #[inline]
9702 fn value_type(&self) -> glib::Type {
9703 Self::static_type()
9704 }
9705}
9706
9707impl From<SelectionMode> for glib::Value {
9708 #[inline]
9709 fn from(v: SelectionMode) -> Self {
9710 skip_assert_initialized!();
9711 ToValue::to_value(&v)
9712 }
9713}
9714
9715#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
9716#[non_exhaustive]
9717#[doc(alias = "GtkSensitivityType")]
9718pub enum SensitivityType {
9719 #[doc(alias = "GTK_SENSITIVITY_AUTO")]
9720 Auto,
9721 #[doc(alias = "GTK_SENSITIVITY_ON")]
9722 On,
9723 #[doc(alias = "GTK_SENSITIVITY_OFF")]
9724 Off,
9725 #[doc(hidden)]
9726 __Unknown(i32),
9727}
9728
9729#[doc(hidden)]
9730impl IntoGlib for SensitivityType {
9731 type GlibType = ffi::GtkSensitivityType;
9732
9733 #[inline]
9734 fn into_glib(self) -> ffi::GtkSensitivityType {
9735 match self {
9736 Self::Auto => ffi::GTK_SENSITIVITY_AUTO,
9737 Self::On => ffi::GTK_SENSITIVITY_ON,
9738 Self::Off => ffi::GTK_SENSITIVITY_OFF,
9739 Self::__Unknown(value) => value,
9740 }
9741 }
9742}
9743
9744#[doc(hidden)]
9745impl FromGlib<ffi::GtkSensitivityType> for SensitivityType {
9746 #[inline]
9747 unsafe fn from_glib(value: ffi::GtkSensitivityType) -> Self {
9748 skip_assert_initialized!();
9749
9750 match value {
9751 ffi::GTK_SENSITIVITY_AUTO => Self::Auto,
9752 ffi::GTK_SENSITIVITY_ON => Self::On,
9753 ffi::GTK_SENSITIVITY_OFF => Self::Off,
9754 value => Self::__Unknown(value),
9755 }
9756 }
9757}
9758
9759impl StaticType for SensitivityType {
9760 #[inline]
9761 #[doc(alias = "gtk_sensitivity_type_get_type")]
9762 fn static_type() -> glib::Type {
9763 unsafe { from_glib(ffi::gtk_sensitivity_type_get_type()) }
9764 }
9765}
9766
9767impl glib::HasParamSpec for SensitivityType {
9768 type ParamSpec = glib::ParamSpecEnum;
9769 type SetValue = Self;
9770 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
9771
9772 fn param_spec_builder() -> Self::BuilderFn {
9773 Self::ParamSpec::builder_with_default
9774 }
9775}
9776
9777impl glib::value::ValueType for SensitivityType {
9778 type Type = Self;
9779}
9780
9781unsafe impl<'a> glib::value::FromValue<'a> for SensitivityType {
9782 type Checker = glib::value::GenericValueTypeChecker<Self>;
9783
9784 #[inline]
9785 unsafe fn from_value(value: &'a glib::Value) -> Self {
9786 skip_assert_initialized!();
9787 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
9788 }
9789}
9790
9791impl ToValue for SensitivityType {
9792 #[inline]
9793 fn to_value(&self) -> glib::Value {
9794 let mut value = glib::Value::for_value_type::<Self>();
9795 unsafe {
9796 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
9797 }
9798 value
9799 }
9800
9801 #[inline]
9802 fn value_type(&self) -> glib::Type {
9803 Self::static_type()
9804 }
9805}
9806
9807impl From<SensitivityType> for glib::Value {
9808 #[inline]
9809 fn from(v: SensitivityType) -> Self {
9810 skip_assert_initialized!();
9811 ToValue::to_value(&v)
9812 }
9813}
9814
9815#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
9816#[non_exhaustive]
9817#[doc(alias = "GtkShortcutScope")]
9818pub enum ShortcutScope {
9819 #[doc(alias = "GTK_SHORTCUT_SCOPE_LOCAL")]
9820 Local,
9821 #[doc(alias = "GTK_SHORTCUT_SCOPE_MANAGED")]
9822 Managed,
9823 #[doc(alias = "GTK_SHORTCUT_SCOPE_GLOBAL")]
9824 Global,
9825 #[doc(hidden)]
9826 __Unknown(i32),
9827}
9828
9829#[doc(hidden)]
9830impl IntoGlib for ShortcutScope {
9831 type GlibType = ffi::GtkShortcutScope;
9832
9833 #[inline]
9834 fn into_glib(self) -> ffi::GtkShortcutScope {
9835 match self {
9836 Self::Local => ffi::GTK_SHORTCUT_SCOPE_LOCAL,
9837 Self::Managed => ffi::GTK_SHORTCUT_SCOPE_MANAGED,
9838 Self::Global => ffi::GTK_SHORTCUT_SCOPE_GLOBAL,
9839 Self::__Unknown(value) => value,
9840 }
9841 }
9842}
9843
9844#[doc(hidden)]
9845impl FromGlib<ffi::GtkShortcutScope> for ShortcutScope {
9846 #[inline]
9847 unsafe fn from_glib(value: ffi::GtkShortcutScope) -> Self {
9848 skip_assert_initialized!();
9849
9850 match value {
9851 ffi::GTK_SHORTCUT_SCOPE_LOCAL => Self::Local,
9852 ffi::GTK_SHORTCUT_SCOPE_MANAGED => Self::Managed,
9853 ffi::GTK_SHORTCUT_SCOPE_GLOBAL => Self::Global,
9854 value => Self::__Unknown(value),
9855 }
9856 }
9857}
9858
9859impl StaticType for ShortcutScope {
9860 #[inline]
9861 #[doc(alias = "gtk_shortcut_scope_get_type")]
9862 fn static_type() -> glib::Type {
9863 unsafe { from_glib(ffi::gtk_shortcut_scope_get_type()) }
9864 }
9865}
9866
9867impl glib::HasParamSpec for ShortcutScope {
9868 type ParamSpec = glib::ParamSpecEnum;
9869 type SetValue = Self;
9870 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
9871
9872 fn param_spec_builder() -> Self::BuilderFn {
9873 Self::ParamSpec::builder_with_default
9874 }
9875}
9876
9877impl glib::value::ValueType for ShortcutScope {
9878 type Type = Self;
9879}
9880
9881unsafe impl<'a> glib::value::FromValue<'a> for ShortcutScope {
9882 type Checker = glib::value::GenericValueTypeChecker<Self>;
9883
9884 #[inline]
9885 unsafe fn from_value(value: &'a glib::Value) -> Self {
9886 skip_assert_initialized!();
9887 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
9888 }
9889}
9890
9891impl ToValue for ShortcutScope {
9892 #[inline]
9893 fn to_value(&self) -> glib::Value {
9894 let mut value = glib::Value::for_value_type::<Self>();
9895 unsafe {
9896 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
9897 }
9898 value
9899 }
9900
9901 #[inline]
9902 fn value_type(&self) -> glib::Type {
9903 Self::static_type()
9904 }
9905}
9906
9907impl From<ShortcutScope> for glib::Value {
9908 #[inline]
9909 fn from(v: ShortcutScope) -> Self {
9910 skip_assert_initialized!();
9911 ToValue::to_value(&v)
9912 }
9913}
9914
9915#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
9916#[non_exhaustive]
9917#[doc(alias = "GtkShortcutType")]
9918pub enum ShortcutType {
9919 #[doc(alias = "GTK_SHORTCUT_ACCELERATOR")]
9920 Accelerator,
9921 #[doc(alias = "GTK_SHORTCUT_GESTURE_PINCH")]
9922 GesturePinch,
9923 #[doc(alias = "GTK_SHORTCUT_GESTURE_STRETCH")]
9924 GestureStretch,
9925 #[doc(alias = "GTK_SHORTCUT_GESTURE_ROTATE_CLOCKWISE")]
9926 GestureRotateClockwise,
9927 #[doc(alias = "GTK_SHORTCUT_GESTURE_ROTATE_COUNTERCLOCKWISE")]
9928 GestureRotateCounterclockwise,
9929 #[doc(alias = "GTK_SHORTCUT_GESTURE_TWO_FINGER_SWIPE_LEFT")]
9930 GestureTwoFingerSwipeLeft,
9931 #[doc(alias = "GTK_SHORTCUT_GESTURE_TWO_FINGER_SWIPE_RIGHT")]
9932 GestureTwoFingerSwipeRight,
9933 #[doc(alias = "GTK_SHORTCUT_GESTURE")]
9934 Gesture,
9935 #[doc(alias = "GTK_SHORTCUT_GESTURE_SWIPE_LEFT")]
9936 GestureSwipeLeft,
9937 #[doc(alias = "GTK_SHORTCUT_GESTURE_SWIPE_RIGHT")]
9938 GestureSwipeRight,
9939 #[doc(hidden)]
9940 __Unknown(i32),
9941}
9942
9943#[doc(hidden)]
9944impl IntoGlib for ShortcutType {
9945 type GlibType = ffi::GtkShortcutType;
9946
9947 #[inline]
9948 fn into_glib(self) -> ffi::GtkShortcutType {
9949 match self {
9950 Self::Accelerator => ffi::GTK_SHORTCUT_ACCELERATOR,
9951 Self::GesturePinch => ffi::GTK_SHORTCUT_GESTURE_PINCH,
9952 Self::GestureStretch => ffi::GTK_SHORTCUT_GESTURE_STRETCH,
9953 Self::GestureRotateClockwise => ffi::GTK_SHORTCUT_GESTURE_ROTATE_CLOCKWISE,
9954 Self::GestureRotateCounterclockwise => {
9955 ffi::GTK_SHORTCUT_GESTURE_ROTATE_COUNTERCLOCKWISE
9956 }
9957 Self::GestureTwoFingerSwipeLeft => ffi::GTK_SHORTCUT_GESTURE_TWO_FINGER_SWIPE_LEFT,
9958 Self::GestureTwoFingerSwipeRight => ffi::GTK_SHORTCUT_GESTURE_TWO_FINGER_SWIPE_RIGHT,
9959 Self::Gesture => ffi::GTK_SHORTCUT_GESTURE,
9960 Self::GestureSwipeLeft => ffi::GTK_SHORTCUT_GESTURE_SWIPE_LEFT,
9961 Self::GestureSwipeRight => ffi::GTK_SHORTCUT_GESTURE_SWIPE_RIGHT,
9962 Self::__Unknown(value) => value,
9963 }
9964 }
9965}
9966
9967#[doc(hidden)]
9968impl FromGlib<ffi::GtkShortcutType> for ShortcutType {
9969 #[inline]
9970 unsafe fn from_glib(value: ffi::GtkShortcutType) -> Self {
9971 skip_assert_initialized!();
9972
9973 match value {
9974 ffi::GTK_SHORTCUT_ACCELERATOR => Self::Accelerator,
9975 ffi::GTK_SHORTCUT_GESTURE_PINCH => Self::GesturePinch,
9976 ffi::GTK_SHORTCUT_GESTURE_STRETCH => Self::GestureStretch,
9977 ffi::GTK_SHORTCUT_GESTURE_ROTATE_CLOCKWISE => Self::GestureRotateClockwise,
9978 ffi::GTK_SHORTCUT_GESTURE_ROTATE_COUNTERCLOCKWISE => {
9979 Self::GestureRotateCounterclockwise
9980 }
9981 ffi::GTK_SHORTCUT_GESTURE_TWO_FINGER_SWIPE_LEFT => Self::GestureTwoFingerSwipeLeft,
9982 ffi::GTK_SHORTCUT_GESTURE_TWO_FINGER_SWIPE_RIGHT => Self::GestureTwoFingerSwipeRight,
9983 ffi::GTK_SHORTCUT_GESTURE => Self::Gesture,
9984 ffi::GTK_SHORTCUT_GESTURE_SWIPE_LEFT => Self::GestureSwipeLeft,
9985 ffi::GTK_SHORTCUT_GESTURE_SWIPE_RIGHT => Self::GestureSwipeRight,
9986 value => Self::__Unknown(value),
9987 }
9988 }
9989}
9990
9991impl StaticType for ShortcutType {
9992 #[inline]
9993 #[doc(alias = "gtk_shortcut_type_get_type")]
9994 fn static_type() -> glib::Type {
9995 unsafe { from_glib(ffi::gtk_shortcut_type_get_type()) }
9996 }
9997}
9998
9999impl glib::HasParamSpec for ShortcutType {
10000 type ParamSpec = glib::ParamSpecEnum;
10001 type SetValue = Self;
10002 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
10003
10004 fn param_spec_builder() -> Self::BuilderFn {
10005 Self::ParamSpec::builder_with_default
10006 }
10007}
10008
10009impl glib::value::ValueType for ShortcutType {
10010 type Type = Self;
10011}
10012
10013unsafe impl<'a> glib::value::FromValue<'a> for ShortcutType {
10014 type Checker = glib::value::GenericValueTypeChecker<Self>;
10015
10016 #[inline]
10017 unsafe fn from_value(value: &'a glib::Value) -> Self {
10018 skip_assert_initialized!();
10019 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
10020 }
10021}
10022
10023impl ToValue for ShortcutType {
10024 #[inline]
10025 fn to_value(&self) -> glib::Value {
10026 let mut value = glib::Value::for_value_type::<Self>();
10027 unsafe {
10028 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
10029 }
10030 value
10031 }
10032
10033 #[inline]
10034 fn value_type(&self) -> glib::Type {
10035 Self::static_type()
10036 }
10037}
10038
10039impl From<ShortcutType> for glib::Value {
10040 #[inline]
10041 fn from(v: ShortcutType) -> Self {
10042 skip_assert_initialized!();
10043 ToValue::to_value(&v)
10044 }
10045}
10046
10047#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
10048#[non_exhaustive]
10049#[doc(alias = "GtkSizeGroupMode")]
10050pub enum SizeGroupMode {
10051 #[doc(alias = "GTK_SIZE_GROUP_NONE")]
10052 None,
10053 #[doc(alias = "GTK_SIZE_GROUP_HORIZONTAL")]
10054 Horizontal,
10055 #[doc(alias = "GTK_SIZE_GROUP_VERTICAL")]
10056 Vertical,
10057 #[doc(alias = "GTK_SIZE_GROUP_BOTH")]
10058 Both,
10059 #[doc(hidden)]
10060 __Unknown(i32),
10061}
10062
10063#[doc(hidden)]
10064impl IntoGlib for SizeGroupMode {
10065 type GlibType = ffi::GtkSizeGroupMode;
10066
10067 #[inline]
10068 fn into_glib(self) -> ffi::GtkSizeGroupMode {
10069 match self {
10070 Self::None => ffi::GTK_SIZE_GROUP_NONE,
10071 Self::Horizontal => ffi::GTK_SIZE_GROUP_HORIZONTAL,
10072 Self::Vertical => ffi::GTK_SIZE_GROUP_VERTICAL,
10073 Self::Both => ffi::GTK_SIZE_GROUP_BOTH,
10074 Self::__Unknown(value) => value,
10075 }
10076 }
10077}
10078
10079#[doc(hidden)]
10080impl FromGlib<ffi::GtkSizeGroupMode> for SizeGroupMode {
10081 #[inline]
10082 unsafe fn from_glib(value: ffi::GtkSizeGroupMode) -> Self {
10083 skip_assert_initialized!();
10084
10085 match value {
10086 ffi::GTK_SIZE_GROUP_NONE => Self::None,
10087 ffi::GTK_SIZE_GROUP_HORIZONTAL => Self::Horizontal,
10088 ffi::GTK_SIZE_GROUP_VERTICAL => Self::Vertical,
10089 ffi::GTK_SIZE_GROUP_BOTH => Self::Both,
10090 value => Self::__Unknown(value),
10091 }
10092 }
10093}
10094
10095impl StaticType for SizeGroupMode {
10096 #[inline]
10097 #[doc(alias = "gtk_size_group_mode_get_type")]
10098 fn static_type() -> glib::Type {
10099 unsafe { from_glib(ffi::gtk_size_group_mode_get_type()) }
10100 }
10101}
10102
10103impl glib::HasParamSpec for SizeGroupMode {
10104 type ParamSpec = glib::ParamSpecEnum;
10105 type SetValue = Self;
10106 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
10107
10108 fn param_spec_builder() -> Self::BuilderFn {
10109 Self::ParamSpec::builder_with_default
10110 }
10111}
10112
10113impl glib::value::ValueType for SizeGroupMode {
10114 type Type = Self;
10115}
10116
10117unsafe impl<'a> glib::value::FromValue<'a> for SizeGroupMode {
10118 type Checker = glib::value::GenericValueTypeChecker<Self>;
10119
10120 #[inline]
10121 unsafe fn from_value(value: &'a glib::Value) -> Self {
10122 skip_assert_initialized!();
10123 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
10124 }
10125}
10126
10127impl ToValue for SizeGroupMode {
10128 #[inline]
10129 fn to_value(&self) -> glib::Value {
10130 let mut value = glib::Value::for_value_type::<Self>();
10131 unsafe {
10132 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
10133 }
10134 value
10135 }
10136
10137 #[inline]
10138 fn value_type(&self) -> glib::Type {
10139 Self::static_type()
10140 }
10141}
10142
10143impl From<SizeGroupMode> for glib::Value {
10144 #[inline]
10145 fn from(v: SizeGroupMode) -> Self {
10146 skip_assert_initialized!();
10147 ToValue::to_value(&v)
10148 }
10149}
10150
10151#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
10152#[non_exhaustive]
10153#[doc(alias = "GtkSizeRequestMode")]
10154pub enum SizeRequestMode {
10155 #[doc(alias = "GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH")]
10156 HeightForWidth,
10157 #[doc(alias = "GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT")]
10158 WidthForHeight,
10159 #[doc(alias = "GTK_SIZE_REQUEST_CONSTANT_SIZE")]
10160 ConstantSize,
10161 #[doc(hidden)]
10162 __Unknown(i32),
10163}
10164
10165#[doc(hidden)]
10166impl IntoGlib for SizeRequestMode {
10167 type GlibType = ffi::GtkSizeRequestMode;
10168
10169 #[inline]
10170 fn into_glib(self) -> ffi::GtkSizeRequestMode {
10171 match self {
10172 Self::HeightForWidth => ffi::GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH,
10173 Self::WidthForHeight => ffi::GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT,
10174 Self::ConstantSize => ffi::GTK_SIZE_REQUEST_CONSTANT_SIZE,
10175 Self::__Unknown(value) => value,
10176 }
10177 }
10178}
10179
10180#[doc(hidden)]
10181impl FromGlib<ffi::GtkSizeRequestMode> for SizeRequestMode {
10182 #[inline]
10183 unsafe fn from_glib(value: ffi::GtkSizeRequestMode) -> Self {
10184 skip_assert_initialized!();
10185
10186 match value {
10187 ffi::GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH => Self::HeightForWidth,
10188 ffi::GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT => Self::WidthForHeight,
10189 ffi::GTK_SIZE_REQUEST_CONSTANT_SIZE => Self::ConstantSize,
10190 value => Self::__Unknown(value),
10191 }
10192 }
10193}
10194
10195impl StaticType for SizeRequestMode {
10196 #[inline]
10197 #[doc(alias = "gtk_size_request_mode_get_type")]
10198 fn static_type() -> glib::Type {
10199 unsafe { from_glib(ffi::gtk_size_request_mode_get_type()) }
10200 }
10201}
10202
10203impl glib::HasParamSpec for SizeRequestMode {
10204 type ParamSpec = glib::ParamSpecEnum;
10205 type SetValue = Self;
10206 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
10207
10208 fn param_spec_builder() -> Self::BuilderFn {
10209 Self::ParamSpec::builder_with_default
10210 }
10211}
10212
10213impl glib::value::ValueType for SizeRequestMode {
10214 type Type = Self;
10215}
10216
10217unsafe impl<'a> glib::value::FromValue<'a> for SizeRequestMode {
10218 type Checker = glib::value::GenericValueTypeChecker<Self>;
10219
10220 #[inline]
10221 unsafe fn from_value(value: &'a glib::Value) -> Self {
10222 skip_assert_initialized!();
10223 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
10224 }
10225}
10226
10227impl ToValue for SizeRequestMode {
10228 #[inline]
10229 fn to_value(&self) -> glib::Value {
10230 let mut value = glib::Value::for_value_type::<Self>();
10231 unsafe {
10232 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
10233 }
10234 value
10235 }
10236
10237 #[inline]
10238 fn value_type(&self) -> glib::Type {
10239 Self::static_type()
10240 }
10241}
10242
10243impl From<SizeRequestMode> for glib::Value {
10244 #[inline]
10245 fn from(v: SizeRequestMode) -> Self {
10246 skip_assert_initialized!();
10247 ToValue::to_value(&v)
10248 }
10249}
10250
10251#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
10252#[non_exhaustive]
10253#[doc(alias = "GtkSortType")]
10254pub enum SortType {
10255 #[doc(alias = "GTK_SORT_ASCENDING")]
10256 Ascending,
10257 #[doc(alias = "GTK_SORT_DESCENDING")]
10258 Descending,
10259 #[doc(hidden)]
10260 __Unknown(i32),
10261}
10262
10263#[doc(hidden)]
10264impl IntoGlib for SortType {
10265 type GlibType = ffi::GtkSortType;
10266
10267 #[inline]
10268 fn into_glib(self) -> ffi::GtkSortType {
10269 match self {
10270 Self::Ascending => ffi::GTK_SORT_ASCENDING,
10271 Self::Descending => ffi::GTK_SORT_DESCENDING,
10272 Self::__Unknown(value) => value,
10273 }
10274 }
10275}
10276
10277#[doc(hidden)]
10278impl FromGlib<ffi::GtkSortType> for SortType {
10279 #[inline]
10280 unsafe fn from_glib(value: ffi::GtkSortType) -> Self {
10281 skip_assert_initialized!();
10282
10283 match value {
10284 ffi::GTK_SORT_ASCENDING => Self::Ascending,
10285 ffi::GTK_SORT_DESCENDING => Self::Descending,
10286 value => Self::__Unknown(value),
10287 }
10288 }
10289}
10290
10291impl StaticType for SortType {
10292 #[inline]
10293 #[doc(alias = "gtk_sort_type_get_type")]
10294 fn static_type() -> glib::Type {
10295 unsafe { from_glib(ffi::gtk_sort_type_get_type()) }
10296 }
10297}
10298
10299impl glib::HasParamSpec for SortType {
10300 type ParamSpec = glib::ParamSpecEnum;
10301 type SetValue = Self;
10302 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
10303
10304 fn param_spec_builder() -> Self::BuilderFn {
10305 Self::ParamSpec::builder_with_default
10306 }
10307}
10308
10309impl glib::value::ValueType for SortType {
10310 type Type = Self;
10311}
10312
10313unsafe impl<'a> glib::value::FromValue<'a> for SortType {
10314 type Checker = glib::value::GenericValueTypeChecker<Self>;
10315
10316 #[inline]
10317 unsafe fn from_value(value: &'a glib::Value) -> Self {
10318 skip_assert_initialized!();
10319 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
10320 }
10321}
10322
10323impl ToValue for SortType {
10324 #[inline]
10325 fn to_value(&self) -> glib::Value {
10326 let mut value = glib::Value::for_value_type::<Self>();
10327 unsafe {
10328 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
10329 }
10330 value
10331 }
10332
10333 #[inline]
10334 fn value_type(&self) -> glib::Type {
10335 Self::static_type()
10336 }
10337}
10338
10339impl From<SortType> for glib::Value {
10340 #[inline]
10341 fn from(v: SortType) -> Self {
10342 skip_assert_initialized!();
10343 ToValue::to_value(&v)
10344 }
10345}
10346
10347#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
10348#[non_exhaustive]
10349#[doc(alias = "GtkSorterChange")]
10350pub enum SorterChange {
10351 #[doc(alias = "GTK_SORTER_CHANGE_DIFFERENT")]
10352 Different,
10353 #[doc(alias = "GTK_SORTER_CHANGE_INVERTED")]
10354 Inverted,
10355 #[doc(alias = "GTK_SORTER_CHANGE_LESS_STRICT")]
10356 LessStrict,
10357 #[doc(alias = "GTK_SORTER_CHANGE_MORE_STRICT")]
10358 MoreStrict,
10359 #[doc(hidden)]
10360 __Unknown(i32),
10361}
10362
10363#[doc(hidden)]
10364impl IntoGlib for SorterChange {
10365 type GlibType = ffi::GtkSorterChange;
10366
10367 #[inline]
10368 fn into_glib(self) -> ffi::GtkSorterChange {
10369 match self {
10370 Self::Different => ffi::GTK_SORTER_CHANGE_DIFFERENT,
10371 Self::Inverted => ffi::GTK_SORTER_CHANGE_INVERTED,
10372 Self::LessStrict => ffi::GTK_SORTER_CHANGE_LESS_STRICT,
10373 Self::MoreStrict => ffi::GTK_SORTER_CHANGE_MORE_STRICT,
10374 Self::__Unknown(value) => value,
10375 }
10376 }
10377}
10378
10379#[doc(hidden)]
10380impl FromGlib<ffi::GtkSorterChange> for SorterChange {
10381 #[inline]
10382 unsafe fn from_glib(value: ffi::GtkSorterChange) -> Self {
10383 skip_assert_initialized!();
10384
10385 match value {
10386 ffi::GTK_SORTER_CHANGE_DIFFERENT => Self::Different,
10387 ffi::GTK_SORTER_CHANGE_INVERTED => Self::Inverted,
10388 ffi::GTK_SORTER_CHANGE_LESS_STRICT => Self::LessStrict,
10389 ffi::GTK_SORTER_CHANGE_MORE_STRICT => Self::MoreStrict,
10390 value => Self::__Unknown(value),
10391 }
10392 }
10393}
10394
10395impl StaticType for SorterChange {
10396 #[inline]
10397 #[doc(alias = "gtk_sorter_change_get_type")]
10398 fn static_type() -> glib::Type {
10399 unsafe { from_glib(ffi::gtk_sorter_change_get_type()) }
10400 }
10401}
10402
10403impl glib::HasParamSpec for SorterChange {
10404 type ParamSpec = glib::ParamSpecEnum;
10405 type SetValue = Self;
10406 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
10407
10408 fn param_spec_builder() -> Self::BuilderFn {
10409 Self::ParamSpec::builder_with_default
10410 }
10411}
10412
10413impl glib::value::ValueType for SorterChange {
10414 type Type = Self;
10415}
10416
10417unsafe impl<'a> glib::value::FromValue<'a> for SorterChange {
10418 type Checker = glib::value::GenericValueTypeChecker<Self>;
10419
10420 #[inline]
10421 unsafe fn from_value(value: &'a glib::Value) -> Self {
10422 skip_assert_initialized!();
10423 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
10424 }
10425}
10426
10427impl ToValue for SorterChange {
10428 #[inline]
10429 fn to_value(&self) -> glib::Value {
10430 let mut value = glib::Value::for_value_type::<Self>();
10431 unsafe {
10432 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
10433 }
10434 value
10435 }
10436
10437 #[inline]
10438 fn value_type(&self) -> glib::Type {
10439 Self::static_type()
10440 }
10441}
10442
10443impl From<SorterChange> for glib::Value {
10444 #[inline]
10445 fn from(v: SorterChange) -> Self {
10446 skip_assert_initialized!();
10447 ToValue::to_value(&v)
10448 }
10449}
10450
10451#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
10452#[non_exhaustive]
10453#[doc(alias = "GtkSorterOrder")]
10454pub enum SorterOrder {
10455 #[doc(alias = "GTK_SORTER_ORDER_PARTIAL")]
10456 Partial,
10457 #[doc(alias = "GTK_SORTER_ORDER_NONE")]
10458 None,
10459 #[doc(alias = "GTK_SORTER_ORDER_TOTAL")]
10460 Total,
10461 #[doc(hidden)]
10462 __Unknown(i32),
10463}
10464
10465#[doc(hidden)]
10466impl IntoGlib for SorterOrder {
10467 type GlibType = ffi::GtkSorterOrder;
10468
10469 #[inline]
10470 fn into_glib(self) -> ffi::GtkSorterOrder {
10471 match self {
10472 Self::Partial => ffi::GTK_SORTER_ORDER_PARTIAL,
10473 Self::None => ffi::GTK_SORTER_ORDER_NONE,
10474 Self::Total => ffi::GTK_SORTER_ORDER_TOTAL,
10475 Self::__Unknown(value) => value,
10476 }
10477 }
10478}
10479
10480#[doc(hidden)]
10481impl FromGlib<ffi::GtkSorterOrder> for SorterOrder {
10482 #[inline]
10483 unsafe fn from_glib(value: ffi::GtkSorterOrder) -> Self {
10484 skip_assert_initialized!();
10485
10486 match value {
10487 ffi::GTK_SORTER_ORDER_PARTIAL => Self::Partial,
10488 ffi::GTK_SORTER_ORDER_NONE => Self::None,
10489 ffi::GTK_SORTER_ORDER_TOTAL => Self::Total,
10490 value => Self::__Unknown(value),
10491 }
10492 }
10493}
10494
10495impl StaticType for SorterOrder {
10496 #[inline]
10497 #[doc(alias = "gtk_sorter_order_get_type")]
10498 fn static_type() -> glib::Type {
10499 unsafe { from_glib(ffi::gtk_sorter_order_get_type()) }
10500 }
10501}
10502
10503impl glib::HasParamSpec for SorterOrder {
10504 type ParamSpec = glib::ParamSpecEnum;
10505 type SetValue = Self;
10506 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
10507
10508 fn param_spec_builder() -> Self::BuilderFn {
10509 Self::ParamSpec::builder_with_default
10510 }
10511}
10512
10513impl glib::value::ValueType for SorterOrder {
10514 type Type = Self;
10515}
10516
10517unsafe impl<'a> glib::value::FromValue<'a> for SorterOrder {
10518 type Checker = glib::value::GenericValueTypeChecker<Self>;
10519
10520 #[inline]
10521 unsafe fn from_value(value: &'a glib::Value) -> Self {
10522 skip_assert_initialized!();
10523 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
10524 }
10525}
10526
10527impl ToValue for SorterOrder {
10528 #[inline]
10529 fn to_value(&self) -> glib::Value {
10530 let mut value = glib::Value::for_value_type::<Self>();
10531 unsafe {
10532 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
10533 }
10534 value
10535 }
10536
10537 #[inline]
10538 fn value_type(&self) -> glib::Type {
10539 Self::static_type()
10540 }
10541}
10542
10543impl From<SorterOrder> for glib::Value {
10544 #[inline]
10545 fn from(v: SorterOrder) -> Self {
10546 skip_assert_initialized!();
10547 ToValue::to_value(&v)
10548 }
10549}
10550
10551#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
10552#[non_exhaustive]
10553#[doc(alias = "GtkSpinButtonUpdatePolicy")]
10554pub enum SpinButtonUpdatePolicy {
10555 #[doc(alias = "GTK_UPDATE_ALWAYS")]
10556 Always,
10557 #[doc(alias = "GTK_UPDATE_IF_VALID")]
10558 IfValid,
10559 #[doc(hidden)]
10560 __Unknown(i32),
10561}
10562
10563#[doc(hidden)]
10564impl IntoGlib for SpinButtonUpdatePolicy {
10565 type GlibType = ffi::GtkSpinButtonUpdatePolicy;
10566
10567 #[inline]
10568 fn into_glib(self) -> ffi::GtkSpinButtonUpdatePolicy {
10569 match self {
10570 Self::Always => ffi::GTK_UPDATE_ALWAYS,
10571 Self::IfValid => ffi::GTK_UPDATE_IF_VALID,
10572 Self::__Unknown(value) => value,
10573 }
10574 }
10575}
10576
10577#[doc(hidden)]
10578impl FromGlib<ffi::GtkSpinButtonUpdatePolicy> for SpinButtonUpdatePolicy {
10579 #[inline]
10580 unsafe fn from_glib(value: ffi::GtkSpinButtonUpdatePolicy) -> Self {
10581 skip_assert_initialized!();
10582
10583 match value {
10584 ffi::GTK_UPDATE_ALWAYS => Self::Always,
10585 ffi::GTK_UPDATE_IF_VALID => Self::IfValid,
10586 value => Self::__Unknown(value),
10587 }
10588 }
10589}
10590
10591impl StaticType for SpinButtonUpdatePolicy {
10592 #[inline]
10593 #[doc(alias = "gtk_spin_button_update_policy_get_type")]
10594 fn static_type() -> glib::Type {
10595 unsafe { from_glib(ffi::gtk_spin_button_update_policy_get_type()) }
10596 }
10597}
10598
10599impl glib::HasParamSpec for SpinButtonUpdatePolicy {
10600 type ParamSpec = glib::ParamSpecEnum;
10601 type SetValue = Self;
10602 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
10603
10604 fn param_spec_builder() -> Self::BuilderFn {
10605 Self::ParamSpec::builder_with_default
10606 }
10607}
10608
10609impl glib::value::ValueType for SpinButtonUpdatePolicy {
10610 type Type = Self;
10611}
10612
10613unsafe impl<'a> glib::value::FromValue<'a> for SpinButtonUpdatePolicy {
10614 type Checker = glib::value::GenericValueTypeChecker<Self>;
10615
10616 #[inline]
10617 unsafe fn from_value(value: &'a glib::Value) -> Self {
10618 skip_assert_initialized!();
10619 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
10620 }
10621}
10622
10623impl ToValue for SpinButtonUpdatePolicy {
10624 #[inline]
10625 fn to_value(&self) -> glib::Value {
10626 let mut value = glib::Value::for_value_type::<Self>();
10627 unsafe {
10628 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
10629 }
10630 value
10631 }
10632
10633 #[inline]
10634 fn value_type(&self) -> glib::Type {
10635 Self::static_type()
10636 }
10637}
10638
10639impl From<SpinButtonUpdatePolicy> for glib::Value {
10640 #[inline]
10641 fn from(v: SpinButtonUpdatePolicy) -> Self {
10642 skip_assert_initialized!();
10643 ToValue::to_value(&v)
10644 }
10645}
10646
10647#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
10648#[non_exhaustive]
10649#[doc(alias = "GtkSpinType")]
10650pub enum SpinType {
10651 #[doc(alias = "GTK_SPIN_STEP_FORWARD")]
10652 StepForward,
10653 #[doc(alias = "GTK_SPIN_STEP_BACKWARD")]
10654 StepBackward,
10655 #[doc(alias = "GTK_SPIN_PAGE_FORWARD")]
10656 PageForward,
10657 #[doc(alias = "GTK_SPIN_PAGE_BACKWARD")]
10658 PageBackward,
10659 #[doc(alias = "GTK_SPIN_HOME")]
10660 Home,
10661 #[doc(alias = "GTK_SPIN_END")]
10662 End,
10663 #[doc(alias = "GTK_SPIN_USER_DEFINED")]
10664 UserDefined,
10665 #[doc(hidden)]
10666 __Unknown(i32),
10667}
10668
10669#[doc(hidden)]
10670impl IntoGlib for SpinType {
10671 type GlibType = ffi::GtkSpinType;
10672
10673 #[inline]
10674 fn into_glib(self) -> ffi::GtkSpinType {
10675 match self {
10676 Self::StepForward => ffi::GTK_SPIN_STEP_FORWARD,
10677 Self::StepBackward => ffi::GTK_SPIN_STEP_BACKWARD,
10678 Self::PageForward => ffi::GTK_SPIN_PAGE_FORWARD,
10679 Self::PageBackward => ffi::GTK_SPIN_PAGE_BACKWARD,
10680 Self::Home => ffi::GTK_SPIN_HOME,
10681 Self::End => ffi::GTK_SPIN_END,
10682 Self::UserDefined => ffi::GTK_SPIN_USER_DEFINED,
10683 Self::__Unknown(value) => value,
10684 }
10685 }
10686}
10687
10688#[doc(hidden)]
10689impl FromGlib<ffi::GtkSpinType> for SpinType {
10690 #[inline]
10691 unsafe fn from_glib(value: ffi::GtkSpinType) -> Self {
10692 skip_assert_initialized!();
10693
10694 match value {
10695 ffi::GTK_SPIN_STEP_FORWARD => Self::StepForward,
10696 ffi::GTK_SPIN_STEP_BACKWARD => Self::StepBackward,
10697 ffi::GTK_SPIN_PAGE_FORWARD => Self::PageForward,
10698 ffi::GTK_SPIN_PAGE_BACKWARD => Self::PageBackward,
10699 ffi::GTK_SPIN_HOME => Self::Home,
10700 ffi::GTK_SPIN_END => Self::End,
10701 ffi::GTK_SPIN_USER_DEFINED => Self::UserDefined,
10702 value => Self::__Unknown(value),
10703 }
10704 }
10705}
10706
10707impl StaticType for SpinType {
10708 #[inline]
10709 #[doc(alias = "gtk_spin_type_get_type")]
10710 fn static_type() -> glib::Type {
10711 unsafe { from_glib(ffi::gtk_spin_type_get_type()) }
10712 }
10713}
10714
10715impl glib::HasParamSpec for SpinType {
10716 type ParamSpec = glib::ParamSpecEnum;
10717 type SetValue = Self;
10718 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
10719
10720 fn param_spec_builder() -> Self::BuilderFn {
10721 Self::ParamSpec::builder_with_default
10722 }
10723}
10724
10725impl glib::value::ValueType for SpinType {
10726 type Type = Self;
10727}
10728
10729unsafe impl<'a> glib::value::FromValue<'a> for SpinType {
10730 type Checker = glib::value::GenericValueTypeChecker<Self>;
10731
10732 #[inline]
10733 unsafe fn from_value(value: &'a glib::Value) -> Self {
10734 skip_assert_initialized!();
10735 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
10736 }
10737}
10738
10739impl ToValue for SpinType {
10740 #[inline]
10741 fn to_value(&self) -> glib::Value {
10742 let mut value = glib::Value::for_value_type::<Self>();
10743 unsafe {
10744 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
10745 }
10746 value
10747 }
10748
10749 #[inline]
10750 fn value_type(&self) -> glib::Type {
10751 Self::static_type()
10752 }
10753}
10754
10755impl From<SpinType> for glib::Value {
10756 #[inline]
10757 fn from(v: SpinType) -> Self {
10758 skip_assert_initialized!();
10759 ToValue::to_value(&v)
10760 }
10761}
10762
10763#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
10764#[non_exhaustive]
10765#[doc(alias = "GtkStackTransitionType")]
10766pub enum StackTransitionType {
10767 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_NONE")]
10768 None,
10769 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_CROSSFADE")]
10770 Crossfade,
10771 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_SLIDE_RIGHT")]
10772 SlideRight,
10773 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT")]
10774 SlideLeft,
10775 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_SLIDE_UP")]
10776 SlideUp,
10777 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_SLIDE_DOWN")]
10778 SlideDown,
10779 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT_RIGHT")]
10780 SlideLeftRight,
10781 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_SLIDE_UP_DOWN")]
10782 SlideUpDown,
10783 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_OVER_UP")]
10784 OverUp,
10785 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_OVER_DOWN")]
10786 OverDown,
10787 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_OVER_LEFT")]
10788 OverLeft,
10789 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_OVER_RIGHT")]
10790 OverRight,
10791 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_UNDER_UP")]
10792 UnderUp,
10793 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_UNDER_DOWN")]
10794 UnderDown,
10795 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_UNDER_LEFT")]
10796 UnderLeft,
10797 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_UNDER_RIGHT")]
10798 UnderRight,
10799 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_OVER_UP_DOWN")]
10800 OverUpDown,
10801 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_OVER_DOWN_UP")]
10802 OverDownUp,
10803 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_OVER_LEFT_RIGHT")]
10804 OverLeftRight,
10805 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_OVER_RIGHT_LEFT")]
10806 OverRightLeft,
10807 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_ROTATE_LEFT")]
10808 RotateLeft,
10809 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_ROTATE_RIGHT")]
10810 RotateRight,
10811 #[doc(alias = "GTK_STACK_TRANSITION_TYPE_ROTATE_LEFT_RIGHT")]
10812 RotateLeftRight,
10813 #[doc(hidden)]
10814 __Unknown(i32),
10815}
10816
10817#[doc(hidden)]
10818impl IntoGlib for StackTransitionType {
10819 type GlibType = ffi::GtkStackTransitionType;
10820
10821 fn into_glib(self) -> ffi::GtkStackTransitionType {
10822 match self {
10823 Self::None => ffi::GTK_STACK_TRANSITION_TYPE_NONE,
10824 Self::Crossfade => ffi::GTK_STACK_TRANSITION_TYPE_CROSSFADE,
10825 Self::SlideRight => ffi::GTK_STACK_TRANSITION_TYPE_SLIDE_RIGHT,
10826 Self::SlideLeft => ffi::GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT,
10827 Self::SlideUp => ffi::GTK_STACK_TRANSITION_TYPE_SLIDE_UP,
10828 Self::SlideDown => ffi::GTK_STACK_TRANSITION_TYPE_SLIDE_DOWN,
10829 Self::SlideLeftRight => ffi::GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT_RIGHT,
10830 Self::SlideUpDown => ffi::GTK_STACK_TRANSITION_TYPE_SLIDE_UP_DOWN,
10831 Self::OverUp => ffi::GTK_STACK_TRANSITION_TYPE_OVER_UP,
10832 Self::OverDown => ffi::GTK_STACK_TRANSITION_TYPE_OVER_DOWN,
10833 Self::OverLeft => ffi::GTK_STACK_TRANSITION_TYPE_OVER_LEFT,
10834 Self::OverRight => ffi::GTK_STACK_TRANSITION_TYPE_OVER_RIGHT,
10835 Self::UnderUp => ffi::GTK_STACK_TRANSITION_TYPE_UNDER_UP,
10836 Self::UnderDown => ffi::GTK_STACK_TRANSITION_TYPE_UNDER_DOWN,
10837 Self::UnderLeft => ffi::GTK_STACK_TRANSITION_TYPE_UNDER_LEFT,
10838 Self::UnderRight => ffi::GTK_STACK_TRANSITION_TYPE_UNDER_RIGHT,
10839 Self::OverUpDown => ffi::GTK_STACK_TRANSITION_TYPE_OVER_UP_DOWN,
10840 Self::OverDownUp => ffi::GTK_STACK_TRANSITION_TYPE_OVER_DOWN_UP,
10841 Self::OverLeftRight => ffi::GTK_STACK_TRANSITION_TYPE_OVER_LEFT_RIGHT,
10842 Self::OverRightLeft => ffi::GTK_STACK_TRANSITION_TYPE_OVER_RIGHT_LEFT,
10843 Self::RotateLeft => ffi::GTK_STACK_TRANSITION_TYPE_ROTATE_LEFT,
10844 Self::RotateRight => ffi::GTK_STACK_TRANSITION_TYPE_ROTATE_RIGHT,
10845 Self::RotateLeftRight => ffi::GTK_STACK_TRANSITION_TYPE_ROTATE_LEFT_RIGHT,
10846 Self::__Unknown(value) => value,
10847 }
10848 }
10849}
10850
10851#[doc(hidden)]
10852impl FromGlib<ffi::GtkStackTransitionType> for StackTransitionType {
10853 unsafe fn from_glib(value: ffi::GtkStackTransitionType) -> Self {
10854 skip_assert_initialized!();
10855
10856 match value {
10857 ffi::GTK_STACK_TRANSITION_TYPE_NONE => Self::None,
10858 ffi::GTK_STACK_TRANSITION_TYPE_CROSSFADE => Self::Crossfade,
10859 ffi::GTK_STACK_TRANSITION_TYPE_SLIDE_RIGHT => Self::SlideRight,
10860 ffi::GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT => Self::SlideLeft,
10861 ffi::GTK_STACK_TRANSITION_TYPE_SLIDE_UP => Self::SlideUp,
10862 ffi::GTK_STACK_TRANSITION_TYPE_SLIDE_DOWN => Self::SlideDown,
10863 ffi::GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT_RIGHT => Self::SlideLeftRight,
10864 ffi::GTK_STACK_TRANSITION_TYPE_SLIDE_UP_DOWN => Self::SlideUpDown,
10865 ffi::GTK_STACK_TRANSITION_TYPE_OVER_UP => Self::OverUp,
10866 ffi::GTK_STACK_TRANSITION_TYPE_OVER_DOWN => Self::OverDown,
10867 ffi::GTK_STACK_TRANSITION_TYPE_OVER_LEFT => Self::OverLeft,
10868 ffi::GTK_STACK_TRANSITION_TYPE_OVER_RIGHT => Self::OverRight,
10869 ffi::GTK_STACK_TRANSITION_TYPE_UNDER_UP => Self::UnderUp,
10870 ffi::GTK_STACK_TRANSITION_TYPE_UNDER_DOWN => Self::UnderDown,
10871 ffi::GTK_STACK_TRANSITION_TYPE_UNDER_LEFT => Self::UnderLeft,
10872 ffi::GTK_STACK_TRANSITION_TYPE_UNDER_RIGHT => Self::UnderRight,
10873 ffi::GTK_STACK_TRANSITION_TYPE_OVER_UP_DOWN => Self::OverUpDown,
10874 ffi::GTK_STACK_TRANSITION_TYPE_OVER_DOWN_UP => Self::OverDownUp,
10875 ffi::GTK_STACK_TRANSITION_TYPE_OVER_LEFT_RIGHT => Self::OverLeftRight,
10876 ffi::GTK_STACK_TRANSITION_TYPE_OVER_RIGHT_LEFT => Self::OverRightLeft,
10877 ffi::GTK_STACK_TRANSITION_TYPE_ROTATE_LEFT => Self::RotateLeft,
10878 ffi::GTK_STACK_TRANSITION_TYPE_ROTATE_RIGHT => Self::RotateRight,
10879 ffi::GTK_STACK_TRANSITION_TYPE_ROTATE_LEFT_RIGHT => Self::RotateLeftRight,
10880 value => Self::__Unknown(value),
10881 }
10882 }
10883}
10884
10885impl StaticType for StackTransitionType {
10886 #[inline]
10887 #[doc(alias = "gtk_stack_transition_type_get_type")]
10888 fn static_type() -> glib::Type {
10889 unsafe { from_glib(ffi::gtk_stack_transition_type_get_type()) }
10890 }
10891}
10892
10893impl glib::HasParamSpec for StackTransitionType {
10894 type ParamSpec = glib::ParamSpecEnum;
10895 type SetValue = Self;
10896 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
10897
10898 fn param_spec_builder() -> Self::BuilderFn {
10899 Self::ParamSpec::builder_with_default
10900 }
10901}
10902
10903impl glib::value::ValueType for StackTransitionType {
10904 type Type = Self;
10905}
10906
10907unsafe impl<'a> glib::value::FromValue<'a> for StackTransitionType {
10908 type Checker = glib::value::GenericValueTypeChecker<Self>;
10909
10910 #[inline]
10911 unsafe fn from_value(value: &'a glib::Value) -> Self {
10912 skip_assert_initialized!();
10913 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
10914 }
10915}
10916
10917impl ToValue for StackTransitionType {
10918 #[inline]
10919 fn to_value(&self) -> glib::Value {
10920 let mut value = glib::Value::for_value_type::<Self>();
10921 unsafe {
10922 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
10923 }
10924 value
10925 }
10926
10927 #[inline]
10928 fn value_type(&self) -> glib::Type {
10929 Self::static_type()
10930 }
10931}
10932
10933impl From<StackTransitionType> for glib::Value {
10934 #[inline]
10935 fn from(v: StackTransitionType) -> Self {
10936 skip_assert_initialized!();
10937 ToValue::to_value(&v)
10938 }
10939}
10940
10941#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
10942#[non_exhaustive]
10943#[doc(alias = "GtkStringFilterMatchMode")]
10944pub enum StringFilterMatchMode {
10945 #[doc(alias = "GTK_STRING_FILTER_MATCH_MODE_EXACT")]
10946 Exact,
10947 #[doc(alias = "GTK_STRING_FILTER_MATCH_MODE_SUBSTRING")]
10948 Substring,
10949 #[doc(alias = "GTK_STRING_FILTER_MATCH_MODE_PREFIX")]
10950 Prefix,
10951 #[doc(hidden)]
10952 __Unknown(i32),
10953}
10954
10955#[doc(hidden)]
10956impl IntoGlib for StringFilterMatchMode {
10957 type GlibType = ffi::GtkStringFilterMatchMode;
10958
10959 #[inline]
10960 fn into_glib(self) -> ffi::GtkStringFilterMatchMode {
10961 match self {
10962 Self::Exact => ffi::GTK_STRING_FILTER_MATCH_MODE_EXACT,
10963 Self::Substring => ffi::GTK_STRING_FILTER_MATCH_MODE_SUBSTRING,
10964 Self::Prefix => ffi::GTK_STRING_FILTER_MATCH_MODE_PREFIX,
10965 Self::__Unknown(value) => value,
10966 }
10967 }
10968}
10969
10970#[doc(hidden)]
10971impl FromGlib<ffi::GtkStringFilterMatchMode> for StringFilterMatchMode {
10972 #[inline]
10973 unsafe fn from_glib(value: ffi::GtkStringFilterMatchMode) -> Self {
10974 skip_assert_initialized!();
10975
10976 match value {
10977 ffi::GTK_STRING_FILTER_MATCH_MODE_EXACT => Self::Exact,
10978 ffi::GTK_STRING_FILTER_MATCH_MODE_SUBSTRING => Self::Substring,
10979 ffi::GTK_STRING_FILTER_MATCH_MODE_PREFIX => Self::Prefix,
10980 value => Self::__Unknown(value),
10981 }
10982 }
10983}
10984
10985impl StaticType for StringFilterMatchMode {
10986 #[inline]
10987 #[doc(alias = "gtk_string_filter_match_mode_get_type")]
10988 fn static_type() -> glib::Type {
10989 unsafe { from_glib(ffi::gtk_string_filter_match_mode_get_type()) }
10990 }
10991}
10992
10993impl glib::HasParamSpec for StringFilterMatchMode {
10994 type ParamSpec = glib::ParamSpecEnum;
10995 type SetValue = Self;
10996 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
10997
10998 fn param_spec_builder() -> Self::BuilderFn {
10999 Self::ParamSpec::builder_with_default
11000 }
11001}
11002
11003impl glib::value::ValueType for StringFilterMatchMode {
11004 type Type = Self;
11005}
11006
11007unsafe impl<'a> glib::value::FromValue<'a> for StringFilterMatchMode {
11008 type Checker = glib::value::GenericValueTypeChecker<Self>;
11009
11010 #[inline]
11011 unsafe fn from_value(value: &'a glib::Value) -> Self {
11012 skip_assert_initialized!();
11013 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
11014 }
11015}
11016
11017impl ToValue for StringFilterMatchMode {
11018 #[inline]
11019 fn to_value(&self) -> glib::Value {
11020 let mut value = glib::Value::for_value_type::<Self>();
11021 unsafe {
11022 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
11023 }
11024 value
11025 }
11026
11027 #[inline]
11028 fn value_type(&self) -> glib::Type {
11029 Self::static_type()
11030 }
11031}
11032
11033impl From<StringFilterMatchMode> for glib::Value {
11034 #[inline]
11035 fn from(v: StringFilterMatchMode) -> Self {
11036 skip_assert_initialized!();
11037 ToValue::to_value(&v)
11038 }
11039}
11040
11041#[cfg(feature = "v4_6")]
11042#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
11043#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
11044#[non_exhaustive]
11045#[doc(alias = "GtkSymbolicColor")]
11046pub enum SymbolicColor {
11047 #[doc(alias = "GTK_SYMBOLIC_COLOR_FOREGROUND")]
11048 Foreground,
11049 #[doc(alias = "GTK_SYMBOLIC_COLOR_ERROR")]
11050 Error,
11051 #[doc(alias = "GTK_SYMBOLIC_COLOR_WARNING")]
11052 Warning,
11053 #[doc(alias = "GTK_SYMBOLIC_COLOR_SUCCESS")]
11054 Success,
11055 #[doc(hidden)]
11056 __Unknown(i32),
11057}
11058
11059#[cfg(feature = "v4_6")]
11060#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
11061#[doc(hidden)]
11062impl IntoGlib for SymbolicColor {
11063 type GlibType = ffi::GtkSymbolicColor;
11064
11065 #[inline]
11066 fn into_glib(self) -> ffi::GtkSymbolicColor {
11067 match self {
11068 Self::Foreground => ffi::GTK_SYMBOLIC_COLOR_FOREGROUND,
11069 Self::Error => ffi::GTK_SYMBOLIC_COLOR_ERROR,
11070 Self::Warning => ffi::GTK_SYMBOLIC_COLOR_WARNING,
11071 Self::Success => ffi::GTK_SYMBOLIC_COLOR_SUCCESS,
11072 Self::__Unknown(value) => value,
11073 }
11074 }
11075}
11076
11077#[cfg(feature = "v4_6")]
11078#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
11079#[doc(hidden)]
11080impl FromGlib<ffi::GtkSymbolicColor> for SymbolicColor {
11081 #[inline]
11082 unsafe fn from_glib(value: ffi::GtkSymbolicColor) -> Self {
11083 skip_assert_initialized!();
11084
11085 match value {
11086 ffi::GTK_SYMBOLIC_COLOR_FOREGROUND => Self::Foreground,
11087 ffi::GTK_SYMBOLIC_COLOR_ERROR => Self::Error,
11088 ffi::GTK_SYMBOLIC_COLOR_WARNING => Self::Warning,
11089 ffi::GTK_SYMBOLIC_COLOR_SUCCESS => Self::Success,
11090 value => Self::__Unknown(value),
11091 }
11092 }
11093}
11094
11095#[cfg(feature = "v4_6")]
11096#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
11097impl StaticType for SymbolicColor {
11098 #[inline]
11099 #[doc(alias = "gtk_symbolic_color_get_type")]
11100 fn static_type() -> glib::Type {
11101 unsafe { from_glib(ffi::gtk_symbolic_color_get_type()) }
11102 }
11103}
11104
11105#[cfg(feature = "v4_6")]
11106#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
11107impl glib::HasParamSpec for SymbolicColor {
11108 type ParamSpec = glib::ParamSpecEnum;
11109 type SetValue = Self;
11110 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
11111
11112 fn param_spec_builder() -> Self::BuilderFn {
11113 Self::ParamSpec::builder_with_default
11114 }
11115}
11116
11117#[cfg(feature = "v4_6")]
11118#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
11119impl glib::value::ValueType for SymbolicColor {
11120 type Type = Self;
11121}
11122
11123#[cfg(feature = "v4_6")]
11124#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
11125unsafe impl<'a> glib::value::FromValue<'a> for SymbolicColor {
11126 type Checker = glib::value::GenericValueTypeChecker<Self>;
11127
11128 #[inline]
11129 unsafe fn from_value(value: &'a glib::Value) -> Self {
11130 skip_assert_initialized!();
11131 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
11132 }
11133}
11134
11135#[cfg(feature = "v4_6")]
11136#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
11137impl ToValue for SymbolicColor {
11138 #[inline]
11139 fn to_value(&self) -> glib::Value {
11140 let mut value = glib::Value::for_value_type::<Self>();
11141 unsafe {
11142 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
11143 }
11144 value
11145 }
11146
11147 #[inline]
11148 fn value_type(&self) -> glib::Type {
11149 Self::static_type()
11150 }
11151}
11152
11153#[cfg(feature = "v4_6")]
11154#[cfg_attr(docsrs, doc(cfg(feature = "v4_6")))]
11155impl From<SymbolicColor> for glib::Value {
11156 #[inline]
11157 fn from(v: SymbolicColor) -> Self {
11158 skip_assert_initialized!();
11159 ToValue::to_value(&v)
11160 }
11161}
11162
11163#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
11164#[non_exhaustive]
11165#[doc(alias = "GtkSystemSetting")]
11166pub enum SystemSetting {
11167 #[doc(alias = "GTK_SYSTEM_SETTING_DPI")]
11168 Dpi,
11169 #[doc(alias = "GTK_SYSTEM_SETTING_FONT_NAME")]
11170 FontName,
11171 #[doc(alias = "GTK_SYSTEM_SETTING_FONT_CONFIG")]
11172 FontConfig,
11173 #[doc(alias = "GTK_SYSTEM_SETTING_DISPLAY")]
11174 Display,
11175 #[doc(alias = "GTK_SYSTEM_SETTING_ICON_THEME")]
11176 IconTheme,
11177 #[doc(hidden)]
11178 __Unknown(i32),
11179}
11180
11181#[doc(hidden)]
11182impl IntoGlib for SystemSetting {
11183 type GlibType = ffi::GtkSystemSetting;
11184
11185 #[inline]
11186 fn into_glib(self) -> ffi::GtkSystemSetting {
11187 match self {
11188 Self::Dpi => ffi::GTK_SYSTEM_SETTING_DPI,
11189 Self::FontName => ffi::GTK_SYSTEM_SETTING_FONT_NAME,
11190 Self::FontConfig => ffi::GTK_SYSTEM_SETTING_FONT_CONFIG,
11191 Self::Display => ffi::GTK_SYSTEM_SETTING_DISPLAY,
11192 Self::IconTheme => ffi::GTK_SYSTEM_SETTING_ICON_THEME,
11193 Self::__Unknown(value) => value,
11194 }
11195 }
11196}
11197
11198#[doc(hidden)]
11199impl FromGlib<ffi::GtkSystemSetting> for SystemSetting {
11200 #[inline]
11201 unsafe fn from_glib(value: ffi::GtkSystemSetting) -> Self {
11202 skip_assert_initialized!();
11203
11204 match value {
11205 ffi::GTK_SYSTEM_SETTING_DPI => Self::Dpi,
11206 ffi::GTK_SYSTEM_SETTING_FONT_NAME => Self::FontName,
11207 ffi::GTK_SYSTEM_SETTING_FONT_CONFIG => Self::FontConfig,
11208 ffi::GTK_SYSTEM_SETTING_DISPLAY => Self::Display,
11209 ffi::GTK_SYSTEM_SETTING_ICON_THEME => Self::IconTheme,
11210 value => Self::__Unknown(value),
11211 }
11212 }
11213}
11214
11215impl StaticType for SystemSetting {
11216 #[inline]
11217 #[doc(alias = "gtk_system_setting_get_type")]
11218 fn static_type() -> glib::Type {
11219 unsafe { from_glib(ffi::gtk_system_setting_get_type()) }
11220 }
11221}
11222
11223impl glib::HasParamSpec for SystemSetting {
11224 type ParamSpec = glib::ParamSpecEnum;
11225 type SetValue = Self;
11226 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
11227
11228 fn param_spec_builder() -> Self::BuilderFn {
11229 Self::ParamSpec::builder_with_default
11230 }
11231}
11232
11233impl glib::value::ValueType for SystemSetting {
11234 type Type = Self;
11235}
11236
11237unsafe impl<'a> glib::value::FromValue<'a> for SystemSetting {
11238 type Checker = glib::value::GenericValueTypeChecker<Self>;
11239
11240 #[inline]
11241 unsafe fn from_value(value: &'a glib::Value) -> Self {
11242 skip_assert_initialized!();
11243 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
11244 }
11245}
11246
11247impl ToValue for SystemSetting {
11248 #[inline]
11249 fn to_value(&self) -> glib::Value {
11250 let mut value = glib::Value::for_value_type::<Self>();
11251 unsafe {
11252 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
11253 }
11254 value
11255 }
11256
11257 #[inline]
11258 fn value_type(&self) -> glib::Type {
11259 Self::static_type()
11260 }
11261}
11262
11263impl From<SystemSetting> for glib::Value {
11264 #[inline]
11265 fn from(v: SystemSetting) -> Self {
11266 skip_assert_initialized!();
11267 ToValue::to_value(&v)
11268 }
11269}
11270
11271#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
11272#[non_exhaustive]
11273#[doc(alias = "GtkTextDirection")]
11274pub enum TextDirection {
11275 #[doc(alias = "GTK_TEXT_DIR_NONE")]
11276 None,
11277 #[doc(alias = "GTK_TEXT_DIR_LTR")]
11278 Ltr,
11279 #[doc(alias = "GTK_TEXT_DIR_RTL")]
11280 Rtl,
11281 #[doc(hidden)]
11282 __Unknown(i32),
11283}
11284
11285#[doc(hidden)]
11286impl IntoGlib for TextDirection {
11287 type GlibType = ffi::GtkTextDirection;
11288
11289 #[inline]
11290 fn into_glib(self) -> ffi::GtkTextDirection {
11291 match self {
11292 Self::None => ffi::GTK_TEXT_DIR_NONE,
11293 Self::Ltr => ffi::GTK_TEXT_DIR_LTR,
11294 Self::Rtl => ffi::GTK_TEXT_DIR_RTL,
11295 Self::__Unknown(value) => value,
11296 }
11297 }
11298}
11299
11300#[doc(hidden)]
11301impl FromGlib<ffi::GtkTextDirection> for TextDirection {
11302 #[inline]
11303 unsafe fn from_glib(value: ffi::GtkTextDirection) -> Self {
11304 skip_assert_initialized!();
11305
11306 match value {
11307 ffi::GTK_TEXT_DIR_NONE => Self::None,
11308 ffi::GTK_TEXT_DIR_LTR => Self::Ltr,
11309 ffi::GTK_TEXT_DIR_RTL => Self::Rtl,
11310 value => Self::__Unknown(value),
11311 }
11312 }
11313}
11314
11315impl StaticType for TextDirection {
11316 #[inline]
11317 #[doc(alias = "gtk_text_direction_get_type")]
11318 fn static_type() -> glib::Type {
11319 unsafe { from_glib(ffi::gtk_text_direction_get_type()) }
11320 }
11321}
11322
11323impl glib::HasParamSpec for TextDirection {
11324 type ParamSpec = glib::ParamSpecEnum;
11325 type SetValue = Self;
11326 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
11327
11328 fn param_spec_builder() -> Self::BuilderFn {
11329 Self::ParamSpec::builder_with_default
11330 }
11331}
11332
11333impl glib::value::ValueType for TextDirection {
11334 type Type = Self;
11335}
11336
11337unsafe impl<'a> glib::value::FromValue<'a> for TextDirection {
11338 type Checker = glib::value::GenericValueTypeChecker<Self>;
11339
11340 #[inline]
11341 unsafe fn from_value(value: &'a glib::Value) -> Self {
11342 skip_assert_initialized!();
11343 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
11344 }
11345}
11346
11347impl ToValue for TextDirection {
11348 #[inline]
11349 fn to_value(&self) -> glib::Value {
11350 let mut value = glib::Value::for_value_type::<Self>();
11351 unsafe {
11352 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
11353 }
11354 value
11355 }
11356
11357 #[inline]
11358 fn value_type(&self) -> glib::Type {
11359 Self::static_type()
11360 }
11361}
11362
11363impl From<TextDirection> for glib::Value {
11364 #[inline]
11365 fn from(v: TextDirection) -> Self {
11366 skip_assert_initialized!();
11367 ToValue::to_value(&v)
11368 }
11369}
11370
11371#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
11372#[non_exhaustive]
11373#[doc(alias = "GtkTextExtendSelection")]
11374pub enum TextExtendSelection {
11375 #[doc(alias = "GTK_TEXT_EXTEND_SELECTION_WORD")]
11376 Word,
11377 #[doc(alias = "GTK_TEXT_EXTEND_SELECTION_LINE")]
11378 Line,
11379 #[doc(hidden)]
11380 __Unknown(i32),
11381}
11382
11383#[doc(hidden)]
11384impl IntoGlib for TextExtendSelection {
11385 type GlibType = ffi::GtkTextExtendSelection;
11386
11387 #[inline]
11388 fn into_glib(self) -> ffi::GtkTextExtendSelection {
11389 match self {
11390 Self::Word => ffi::GTK_TEXT_EXTEND_SELECTION_WORD,
11391 Self::Line => ffi::GTK_TEXT_EXTEND_SELECTION_LINE,
11392 Self::__Unknown(value) => value,
11393 }
11394 }
11395}
11396
11397#[doc(hidden)]
11398impl FromGlib<ffi::GtkTextExtendSelection> for TextExtendSelection {
11399 #[inline]
11400 unsafe fn from_glib(value: ffi::GtkTextExtendSelection) -> Self {
11401 skip_assert_initialized!();
11402
11403 match value {
11404 ffi::GTK_TEXT_EXTEND_SELECTION_WORD => Self::Word,
11405 ffi::GTK_TEXT_EXTEND_SELECTION_LINE => Self::Line,
11406 value => Self::__Unknown(value),
11407 }
11408 }
11409}
11410
11411impl StaticType for TextExtendSelection {
11412 #[inline]
11413 #[doc(alias = "gtk_text_extend_selection_get_type")]
11414 fn static_type() -> glib::Type {
11415 unsafe { from_glib(ffi::gtk_text_extend_selection_get_type()) }
11416 }
11417}
11418
11419impl glib::HasParamSpec for TextExtendSelection {
11420 type ParamSpec = glib::ParamSpecEnum;
11421 type SetValue = Self;
11422 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
11423
11424 fn param_spec_builder() -> Self::BuilderFn {
11425 Self::ParamSpec::builder_with_default
11426 }
11427}
11428
11429impl glib::value::ValueType for TextExtendSelection {
11430 type Type = Self;
11431}
11432
11433unsafe impl<'a> glib::value::FromValue<'a> for TextExtendSelection {
11434 type Checker = glib::value::GenericValueTypeChecker<Self>;
11435
11436 #[inline]
11437 unsafe fn from_value(value: &'a glib::Value) -> Self {
11438 skip_assert_initialized!();
11439 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
11440 }
11441}
11442
11443impl ToValue for TextExtendSelection {
11444 #[inline]
11445 fn to_value(&self) -> glib::Value {
11446 let mut value = glib::Value::for_value_type::<Self>();
11447 unsafe {
11448 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
11449 }
11450 value
11451 }
11452
11453 #[inline]
11454 fn value_type(&self) -> glib::Type {
11455 Self::static_type()
11456 }
11457}
11458
11459impl From<TextExtendSelection> for glib::Value {
11460 #[inline]
11461 fn from(v: TextExtendSelection) -> Self {
11462 skip_assert_initialized!();
11463 ToValue::to_value(&v)
11464 }
11465}
11466
11467#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
11468#[non_exhaustive]
11469#[doc(alias = "GtkTextViewLayer")]
11470pub enum TextViewLayer {
11471 #[doc(alias = "GTK_TEXT_VIEW_LAYER_BELOW_TEXT")]
11472 BelowText,
11473 #[doc(alias = "GTK_TEXT_VIEW_LAYER_ABOVE_TEXT")]
11474 AboveText,
11475 #[doc(hidden)]
11476 __Unknown(i32),
11477}
11478
11479#[doc(hidden)]
11480impl IntoGlib for TextViewLayer {
11481 type GlibType = ffi::GtkTextViewLayer;
11482
11483 #[inline]
11484 fn into_glib(self) -> ffi::GtkTextViewLayer {
11485 match self {
11486 Self::BelowText => ffi::GTK_TEXT_VIEW_LAYER_BELOW_TEXT,
11487 Self::AboveText => ffi::GTK_TEXT_VIEW_LAYER_ABOVE_TEXT,
11488 Self::__Unknown(value) => value,
11489 }
11490 }
11491}
11492
11493#[doc(hidden)]
11494impl FromGlib<ffi::GtkTextViewLayer> for TextViewLayer {
11495 #[inline]
11496 unsafe fn from_glib(value: ffi::GtkTextViewLayer) -> Self {
11497 skip_assert_initialized!();
11498
11499 match value {
11500 ffi::GTK_TEXT_VIEW_LAYER_BELOW_TEXT => Self::BelowText,
11501 ffi::GTK_TEXT_VIEW_LAYER_ABOVE_TEXT => Self::AboveText,
11502 value => Self::__Unknown(value),
11503 }
11504 }
11505}
11506
11507impl StaticType for TextViewLayer {
11508 #[inline]
11509 #[doc(alias = "gtk_text_view_layer_get_type")]
11510 fn static_type() -> glib::Type {
11511 unsafe { from_glib(ffi::gtk_text_view_layer_get_type()) }
11512 }
11513}
11514
11515impl glib::HasParamSpec for TextViewLayer {
11516 type ParamSpec = glib::ParamSpecEnum;
11517 type SetValue = Self;
11518 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
11519
11520 fn param_spec_builder() -> Self::BuilderFn {
11521 Self::ParamSpec::builder_with_default
11522 }
11523}
11524
11525impl glib::value::ValueType for TextViewLayer {
11526 type Type = Self;
11527}
11528
11529unsafe impl<'a> glib::value::FromValue<'a> for TextViewLayer {
11530 type Checker = glib::value::GenericValueTypeChecker<Self>;
11531
11532 #[inline]
11533 unsafe fn from_value(value: &'a glib::Value) -> Self {
11534 skip_assert_initialized!();
11535 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
11536 }
11537}
11538
11539impl ToValue for TextViewLayer {
11540 #[inline]
11541 fn to_value(&self) -> glib::Value {
11542 let mut value = glib::Value::for_value_type::<Self>();
11543 unsafe {
11544 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
11545 }
11546 value
11547 }
11548
11549 #[inline]
11550 fn value_type(&self) -> glib::Type {
11551 Self::static_type()
11552 }
11553}
11554
11555impl From<TextViewLayer> for glib::Value {
11556 #[inline]
11557 fn from(v: TextViewLayer) -> Self {
11558 skip_assert_initialized!();
11559 ToValue::to_value(&v)
11560 }
11561}
11562
11563#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
11564#[non_exhaustive]
11565#[doc(alias = "GtkTextWindowType")]
11566pub enum TextWindowType {
11567 #[doc(alias = "GTK_TEXT_WINDOW_WIDGET")]
11568 Widget,
11569 #[doc(alias = "GTK_TEXT_WINDOW_TEXT")]
11570 Text,
11571 #[doc(alias = "GTK_TEXT_WINDOW_LEFT")]
11572 Left,
11573 #[doc(alias = "GTK_TEXT_WINDOW_RIGHT")]
11574 Right,
11575 #[doc(alias = "GTK_TEXT_WINDOW_TOP")]
11576 Top,
11577 #[doc(alias = "GTK_TEXT_WINDOW_BOTTOM")]
11578 Bottom,
11579 #[doc(hidden)]
11580 __Unknown(i32),
11581}
11582
11583#[doc(hidden)]
11584impl IntoGlib for TextWindowType {
11585 type GlibType = ffi::GtkTextWindowType;
11586
11587 #[inline]
11588 fn into_glib(self) -> ffi::GtkTextWindowType {
11589 match self {
11590 Self::Widget => ffi::GTK_TEXT_WINDOW_WIDGET,
11591 Self::Text => ffi::GTK_TEXT_WINDOW_TEXT,
11592 Self::Left => ffi::GTK_TEXT_WINDOW_LEFT,
11593 Self::Right => ffi::GTK_TEXT_WINDOW_RIGHT,
11594 Self::Top => ffi::GTK_TEXT_WINDOW_TOP,
11595 Self::Bottom => ffi::GTK_TEXT_WINDOW_BOTTOM,
11596 Self::__Unknown(value) => value,
11597 }
11598 }
11599}
11600
11601#[doc(hidden)]
11602impl FromGlib<ffi::GtkTextWindowType> for TextWindowType {
11603 #[inline]
11604 unsafe fn from_glib(value: ffi::GtkTextWindowType) -> Self {
11605 skip_assert_initialized!();
11606
11607 match value {
11608 ffi::GTK_TEXT_WINDOW_WIDGET => Self::Widget,
11609 ffi::GTK_TEXT_WINDOW_TEXT => Self::Text,
11610 ffi::GTK_TEXT_WINDOW_LEFT => Self::Left,
11611 ffi::GTK_TEXT_WINDOW_RIGHT => Self::Right,
11612 ffi::GTK_TEXT_WINDOW_TOP => Self::Top,
11613 ffi::GTK_TEXT_WINDOW_BOTTOM => Self::Bottom,
11614 value => Self::__Unknown(value),
11615 }
11616 }
11617}
11618
11619impl StaticType for TextWindowType {
11620 #[inline]
11621 #[doc(alias = "gtk_text_window_type_get_type")]
11622 fn static_type() -> glib::Type {
11623 unsafe { from_glib(ffi::gtk_text_window_type_get_type()) }
11624 }
11625}
11626
11627impl glib::HasParamSpec for TextWindowType {
11628 type ParamSpec = glib::ParamSpecEnum;
11629 type SetValue = Self;
11630 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
11631
11632 fn param_spec_builder() -> Self::BuilderFn {
11633 Self::ParamSpec::builder_with_default
11634 }
11635}
11636
11637impl glib::value::ValueType for TextWindowType {
11638 type Type = Self;
11639}
11640
11641unsafe impl<'a> glib::value::FromValue<'a> for TextWindowType {
11642 type Checker = glib::value::GenericValueTypeChecker<Self>;
11643
11644 #[inline]
11645 unsafe fn from_value(value: &'a glib::Value) -> Self {
11646 skip_assert_initialized!();
11647 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
11648 }
11649}
11650
11651impl ToValue for TextWindowType {
11652 #[inline]
11653 fn to_value(&self) -> glib::Value {
11654 let mut value = glib::Value::for_value_type::<Self>();
11655 unsafe {
11656 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
11657 }
11658 value
11659 }
11660
11661 #[inline]
11662 fn value_type(&self) -> glib::Type {
11663 Self::static_type()
11664 }
11665}
11666
11667impl From<TextWindowType> for glib::Value {
11668 #[inline]
11669 fn from(v: TextWindowType) -> Self {
11670 skip_assert_initialized!();
11671 ToValue::to_value(&v)
11672 }
11673}
11674
11675#[cfg_attr(feature = "v4_20", deprecated = "Since 4.20")]
11676#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
11677#[non_exhaustive]
11678#[doc(alias = "GtkTreeViewColumnSizing")]
11679pub enum TreeViewColumnSizing {
11680 #[doc(alias = "GTK_TREE_VIEW_COLUMN_GROW_ONLY")]
11681 GrowOnly,
11682 #[doc(alias = "GTK_TREE_VIEW_COLUMN_AUTOSIZE")]
11683 Autosize,
11684 #[doc(alias = "GTK_TREE_VIEW_COLUMN_FIXED")]
11685 Fixed,
11686 #[doc(hidden)]
11687 __Unknown(i32),
11688}
11689
11690#[allow(deprecated)]
11691#[doc(hidden)]
11692impl IntoGlib for TreeViewColumnSizing {
11693 type GlibType = ffi::GtkTreeViewColumnSizing;
11694
11695 #[inline]
11696 fn into_glib(self) -> ffi::GtkTreeViewColumnSizing {
11697 match self {
11698 Self::GrowOnly => ffi::GTK_TREE_VIEW_COLUMN_GROW_ONLY,
11699 Self::Autosize => ffi::GTK_TREE_VIEW_COLUMN_AUTOSIZE,
11700 Self::Fixed => ffi::GTK_TREE_VIEW_COLUMN_FIXED,
11701 Self::__Unknown(value) => value,
11702 }
11703 }
11704}
11705
11706#[allow(deprecated)]
11707#[doc(hidden)]
11708impl FromGlib<ffi::GtkTreeViewColumnSizing> for TreeViewColumnSizing {
11709 #[inline]
11710 unsafe fn from_glib(value: ffi::GtkTreeViewColumnSizing) -> Self {
11711 skip_assert_initialized!();
11712
11713 match value {
11714 ffi::GTK_TREE_VIEW_COLUMN_GROW_ONLY => Self::GrowOnly,
11715 ffi::GTK_TREE_VIEW_COLUMN_AUTOSIZE => Self::Autosize,
11716 ffi::GTK_TREE_VIEW_COLUMN_FIXED => Self::Fixed,
11717 value => Self::__Unknown(value),
11718 }
11719 }
11720}
11721
11722#[allow(deprecated)]
11723impl StaticType for TreeViewColumnSizing {
11724 #[inline]
11725 #[doc(alias = "gtk_tree_view_column_sizing_get_type")]
11726 fn static_type() -> glib::Type {
11727 unsafe { from_glib(ffi::gtk_tree_view_column_sizing_get_type()) }
11728 }
11729}
11730
11731#[allow(deprecated)]
11732impl glib::HasParamSpec for TreeViewColumnSizing {
11733 type ParamSpec = glib::ParamSpecEnum;
11734 type SetValue = Self;
11735 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
11736
11737 fn param_spec_builder() -> Self::BuilderFn {
11738 Self::ParamSpec::builder_with_default
11739 }
11740}
11741
11742#[allow(deprecated)]
11743impl glib::value::ValueType for TreeViewColumnSizing {
11744 type Type = Self;
11745}
11746
11747#[allow(deprecated)]
11748unsafe impl<'a> glib::value::FromValue<'a> for TreeViewColumnSizing {
11749 type Checker = glib::value::GenericValueTypeChecker<Self>;
11750
11751 #[inline]
11752 unsafe fn from_value(value: &'a glib::Value) -> Self {
11753 skip_assert_initialized!();
11754 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
11755 }
11756}
11757
11758#[allow(deprecated)]
11759impl ToValue for TreeViewColumnSizing {
11760 #[inline]
11761 fn to_value(&self) -> glib::Value {
11762 let mut value = glib::Value::for_value_type::<Self>();
11763 unsafe {
11764 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
11765 }
11766 value
11767 }
11768
11769 #[inline]
11770 fn value_type(&self) -> glib::Type {
11771 Self::static_type()
11772 }
11773}
11774
11775#[allow(deprecated)]
11776impl From<TreeViewColumnSizing> for glib::Value {
11777 #[inline]
11778 fn from(v: TreeViewColumnSizing) -> Self {
11779 skip_assert_initialized!();
11780 ToValue::to_value(&v)
11781 }
11782}
11783
11784#[cfg_attr(feature = "v4_20", deprecated = "Since 4.20")]
11785#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
11786#[non_exhaustive]
11787#[doc(alias = "GtkTreeViewDropPosition")]
11788pub enum TreeViewDropPosition {
11789 #[doc(alias = "GTK_TREE_VIEW_DROP_BEFORE")]
11790 Before,
11791 #[doc(alias = "GTK_TREE_VIEW_DROP_AFTER")]
11792 After,
11793 #[doc(alias = "GTK_TREE_VIEW_DROP_INTO_OR_BEFORE")]
11794 IntoOrBefore,
11795 #[doc(alias = "GTK_TREE_VIEW_DROP_INTO_OR_AFTER")]
11796 IntoOrAfter,
11797 #[doc(hidden)]
11798 __Unknown(i32),
11799}
11800
11801#[allow(deprecated)]
11802#[doc(hidden)]
11803impl IntoGlib for TreeViewDropPosition {
11804 type GlibType = ffi::GtkTreeViewDropPosition;
11805
11806 #[inline]
11807 fn into_glib(self) -> ffi::GtkTreeViewDropPosition {
11808 match self {
11809 Self::Before => ffi::GTK_TREE_VIEW_DROP_BEFORE,
11810 Self::After => ffi::GTK_TREE_VIEW_DROP_AFTER,
11811 Self::IntoOrBefore => ffi::GTK_TREE_VIEW_DROP_INTO_OR_BEFORE,
11812 Self::IntoOrAfter => ffi::GTK_TREE_VIEW_DROP_INTO_OR_AFTER,
11813 Self::__Unknown(value) => value,
11814 }
11815 }
11816}
11817
11818#[allow(deprecated)]
11819#[doc(hidden)]
11820impl FromGlib<ffi::GtkTreeViewDropPosition> for TreeViewDropPosition {
11821 #[inline]
11822 unsafe fn from_glib(value: ffi::GtkTreeViewDropPosition) -> Self {
11823 skip_assert_initialized!();
11824
11825 match value {
11826 ffi::GTK_TREE_VIEW_DROP_BEFORE => Self::Before,
11827 ffi::GTK_TREE_VIEW_DROP_AFTER => Self::After,
11828 ffi::GTK_TREE_VIEW_DROP_INTO_OR_BEFORE => Self::IntoOrBefore,
11829 ffi::GTK_TREE_VIEW_DROP_INTO_OR_AFTER => Self::IntoOrAfter,
11830 value => Self::__Unknown(value),
11831 }
11832 }
11833}
11834
11835#[allow(deprecated)]
11836impl StaticType for TreeViewDropPosition {
11837 #[inline]
11838 #[doc(alias = "gtk_tree_view_drop_position_get_type")]
11839 fn static_type() -> glib::Type {
11840 unsafe { from_glib(ffi::gtk_tree_view_drop_position_get_type()) }
11841 }
11842}
11843
11844#[allow(deprecated)]
11845impl glib::HasParamSpec for TreeViewDropPosition {
11846 type ParamSpec = glib::ParamSpecEnum;
11847 type SetValue = Self;
11848 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
11849
11850 fn param_spec_builder() -> Self::BuilderFn {
11851 Self::ParamSpec::builder_with_default
11852 }
11853}
11854
11855#[allow(deprecated)]
11856impl glib::value::ValueType for TreeViewDropPosition {
11857 type Type = Self;
11858}
11859
11860#[allow(deprecated)]
11861unsafe impl<'a> glib::value::FromValue<'a> for TreeViewDropPosition {
11862 type Checker = glib::value::GenericValueTypeChecker<Self>;
11863
11864 #[inline]
11865 unsafe fn from_value(value: &'a glib::Value) -> Self {
11866 skip_assert_initialized!();
11867 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
11868 }
11869}
11870
11871#[allow(deprecated)]
11872impl ToValue for TreeViewDropPosition {
11873 #[inline]
11874 fn to_value(&self) -> glib::Value {
11875 let mut value = glib::Value::for_value_type::<Self>();
11876 unsafe {
11877 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
11878 }
11879 value
11880 }
11881
11882 #[inline]
11883 fn value_type(&self) -> glib::Type {
11884 Self::static_type()
11885 }
11886}
11887
11888#[allow(deprecated)]
11889impl From<TreeViewDropPosition> for glib::Value {
11890 #[inline]
11891 fn from(v: TreeViewDropPosition) -> Self {
11892 skip_assert_initialized!();
11893 ToValue::to_value(&v)
11894 }
11895}
11896
11897#[cfg_attr(feature = "v4_20", deprecated = "Since 4.20")]
11898#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
11899#[non_exhaustive]
11900#[doc(alias = "GtkTreeViewGridLines")]
11901pub enum TreeViewGridLines {
11902 #[doc(alias = "GTK_TREE_VIEW_GRID_LINES_NONE")]
11903 None,
11904 #[doc(alias = "GTK_TREE_VIEW_GRID_LINES_HORIZONTAL")]
11905 Horizontal,
11906 #[doc(alias = "GTK_TREE_VIEW_GRID_LINES_VERTICAL")]
11907 Vertical,
11908 #[doc(alias = "GTK_TREE_VIEW_GRID_LINES_BOTH")]
11909 Both,
11910 #[doc(hidden)]
11911 __Unknown(i32),
11912}
11913
11914#[allow(deprecated)]
11915#[doc(hidden)]
11916impl IntoGlib for TreeViewGridLines {
11917 type GlibType = ffi::GtkTreeViewGridLines;
11918
11919 #[inline]
11920 fn into_glib(self) -> ffi::GtkTreeViewGridLines {
11921 match self {
11922 Self::None => ffi::GTK_TREE_VIEW_GRID_LINES_NONE,
11923 Self::Horizontal => ffi::GTK_TREE_VIEW_GRID_LINES_HORIZONTAL,
11924 Self::Vertical => ffi::GTK_TREE_VIEW_GRID_LINES_VERTICAL,
11925 Self::Both => ffi::GTK_TREE_VIEW_GRID_LINES_BOTH,
11926 Self::__Unknown(value) => value,
11927 }
11928 }
11929}
11930
11931#[allow(deprecated)]
11932#[doc(hidden)]
11933impl FromGlib<ffi::GtkTreeViewGridLines> for TreeViewGridLines {
11934 #[inline]
11935 unsafe fn from_glib(value: ffi::GtkTreeViewGridLines) -> Self {
11936 skip_assert_initialized!();
11937
11938 match value {
11939 ffi::GTK_TREE_VIEW_GRID_LINES_NONE => Self::None,
11940 ffi::GTK_TREE_VIEW_GRID_LINES_HORIZONTAL => Self::Horizontal,
11941 ffi::GTK_TREE_VIEW_GRID_LINES_VERTICAL => Self::Vertical,
11942 ffi::GTK_TREE_VIEW_GRID_LINES_BOTH => Self::Both,
11943 value => Self::__Unknown(value),
11944 }
11945 }
11946}
11947
11948#[allow(deprecated)]
11949impl StaticType for TreeViewGridLines {
11950 #[inline]
11951 #[doc(alias = "gtk_tree_view_grid_lines_get_type")]
11952 fn static_type() -> glib::Type {
11953 unsafe { from_glib(ffi::gtk_tree_view_grid_lines_get_type()) }
11954 }
11955}
11956
11957#[allow(deprecated)]
11958impl glib::HasParamSpec for TreeViewGridLines {
11959 type ParamSpec = glib::ParamSpecEnum;
11960 type SetValue = Self;
11961 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
11962
11963 fn param_spec_builder() -> Self::BuilderFn {
11964 Self::ParamSpec::builder_with_default
11965 }
11966}
11967
11968#[allow(deprecated)]
11969impl glib::value::ValueType for TreeViewGridLines {
11970 type Type = Self;
11971}
11972
11973#[allow(deprecated)]
11974unsafe impl<'a> glib::value::FromValue<'a> for TreeViewGridLines {
11975 type Checker = glib::value::GenericValueTypeChecker<Self>;
11976
11977 #[inline]
11978 unsafe fn from_value(value: &'a glib::Value) -> Self {
11979 skip_assert_initialized!();
11980 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
11981 }
11982}
11983
11984#[allow(deprecated)]
11985impl ToValue for TreeViewGridLines {
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
12001#[allow(deprecated)]
12002impl From<TreeViewGridLines> for glib::Value {
12003 #[inline]
12004 fn from(v: TreeViewGridLines) -> Self {
12005 skip_assert_initialized!();
12006 ToValue::to_value(&v)
12007 }
12008}
12009
12010#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
12011#[non_exhaustive]
12012#[doc(alias = "GtkUnit")]
12013pub enum Unit {
12014 #[doc(alias = "GTK_UNIT_NONE")]
12015 None,
12016 #[doc(alias = "GTK_UNIT_POINTS")]
12017 Points,
12018 #[doc(alias = "GTK_UNIT_INCH")]
12019 Inch,
12020 #[doc(alias = "GTK_UNIT_MM")]
12021 Mm,
12022 #[doc(hidden)]
12023 __Unknown(i32),
12024}
12025
12026#[doc(hidden)]
12027impl IntoGlib for Unit {
12028 type GlibType = ffi::GtkUnit;
12029
12030 #[inline]
12031 fn into_glib(self) -> ffi::GtkUnit {
12032 match self {
12033 Self::None => ffi::GTK_UNIT_NONE,
12034 Self::Points => ffi::GTK_UNIT_POINTS,
12035 Self::Inch => ffi::GTK_UNIT_INCH,
12036 Self::Mm => ffi::GTK_UNIT_MM,
12037 Self::__Unknown(value) => value,
12038 }
12039 }
12040}
12041
12042#[doc(hidden)]
12043impl FromGlib<ffi::GtkUnit> for Unit {
12044 #[inline]
12045 unsafe fn from_glib(value: ffi::GtkUnit) -> Self {
12046 skip_assert_initialized!();
12047
12048 match value {
12049 ffi::GTK_UNIT_NONE => Self::None,
12050 ffi::GTK_UNIT_POINTS => Self::Points,
12051 ffi::GTK_UNIT_INCH => Self::Inch,
12052 ffi::GTK_UNIT_MM => Self::Mm,
12053 value => Self::__Unknown(value),
12054 }
12055 }
12056}
12057
12058impl StaticType for Unit {
12059 #[inline]
12060 #[doc(alias = "gtk_unit_get_type")]
12061 fn static_type() -> glib::Type {
12062 unsafe { from_glib(ffi::gtk_unit_get_type()) }
12063 }
12064}
12065
12066impl glib::HasParamSpec for Unit {
12067 type ParamSpec = glib::ParamSpecEnum;
12068 type SetValue = Self;
12069 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
12070
12071 fn param_spec_builder() -> Self::BuilderFn {
12072 Self::ParamSpec::builder_with_default
12073 }
12074}
12075
12076impl glib::value::ValueType for Unit {
12077 type Type = Self;
12078}
12079
12080unsafe impl<'a> glib::value::FromValue<'a> for Unit {
12081 type Checker = glib::value::GenericValueTypeChecker<Self>;
12082
12083 #[inline]
12084 unsafe fn from_value(value: &'a glib::Value) -> Self {
12085 skip_assert_initialized!();
12086 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
12087 }
12088}
12089
12090impl ToValue for Unit {
12091 #[inline]
12092 fn to_value(&self) -> glib::Value {
12093 let mut value = glib::Value::for_value_type::<Self>();
12094 unsafe {
12095 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
12096 }
12097 value
12098 }
12099
12100 #[inline]
12101 fn value_type(&self) -> glib::Type {
12102 Self::static_type()
12103 }
12104}
12105
12106impl From<Unit> for glib::Value {
12107 #[inline]
12108 fn from(v: Unit) -> Self {
12109 skip_assert_initialized!();
12110 ToValue::to_value(&v)
12111 }
12112}
12113
12114#[cfg(feature = "v4_20")]
12115#[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
12116#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
12117#[non_exhaustive]
12118#[doc(alias = "GtkWindowGravity")]
12119pub enum WindowGravity {
12120 #[doc(alias = "GTK_WINDOW_GRAVITY_TOP_LEFT")]
12121 TopLeft,
12122 #[doc(alias = "GTK_WINDOW_GRAVITY_TOP")]
12123 Top,
12124 #[doc(alias = "GTK_WINDOW_GRAVITY_TOP_RIGHT")]
12125 TopRight,
12126 #[doc(alias = "GTK_WINDOW_GRAVITY_LEFT")]
12127 Left,
12128 #[doc(alias = "GTK_WINDOW_GRAVITY_CENTER")]
12129 Center,
12130 #[doc(alias = "GTK_WINDOW_GRAVITY_RIGHT")]
12131 Right,
12132 #[doc(alias = "GTK_WINDOW_GRAVITY_BOTTOM_LEFT")]
12133 BottomLeft,
12134 #[doc(alias = "GTK_WINDOW_GRAVITY_BOTTOM")]
12135 Bottom,
12136 #[doc(alias = "GTK_WINDOW_GRAVITY_BOTTOM_RIGHT")]
12137 BottomRight,
12138 #[doc(alias = "GTK_WINDOW_GRAVITY_TOP_START")]
12139 TopStart,
12140 #[doc(alias = "GTK_WINDOW_GRAVITY_TOP_END")]
12141 TopEnd,
12142 #[doc(alias = "GTK_WINDOW_GRAVITY_START")]
12143 Start,
12144 #[doc(alias = "GTK_WINDOW_GRAVITY_END")]
12145 End,
12146 #[doc(alias = "GTK_WINDOW_GRAVITY_BOTTOM_START")]
12147 BottomStart,
12148 #[doc(alias = "GTK_WINDOW_GRAVITY_BOTTOM_END")]
12149 BottomEnd,
12150 #[doc(hidden)]
12151 __Unknown(i32),
12152}
12153
12154#[cfg(feature = "v4_20")]
12155#[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
12156#[doc(hidden)]
12157impl IntoGlib for WindowGravity {
12158 type GlibType = ffi::GtkWindowGravity;
12159
12160 fn into_glib(self) -> ffi::GtkWindowGravity {
12161 match self {
12162 Self::TopLeft => ffi::GTK_WINDOW_GRAVITY_TOP_LEFT,
12163 Self::Top => ffi::GTK_WINDOW_GRAVITY_TOP,
12164 Self::TopRight => ffi::GTK_WINDOW_GRAVITY_TOP_RIGHT,
12165 Self::Left => ffi::GTK_WINDOW_GRAVITY_LEFT,
12166 Self::Center => ffi::GTK_WINDOW_GRAVITY_CENTER,
12167 Self::Right => ffi::GTK_WINDOW_GRAVITY_RIGHT,
12168 Self::BottomLeft => ffi::GTK_WINDOW_GRAVITY_BOTTOM_LEFT,
12169 Self::Bottom => ffi::GTK_WINDOW_GRAVITY_BOTTOM,
12170 Self::BottomRight => ffi::GTK_WINDOW_GRAVITY_BOTTOM_RIGHT,
12171 Self::TopStart => ffi::GTK_WINDOW_GRAVITY_TOP_START,
12172 Self::TopEnd => ffi::GTK_WINDOW_GRAVITY_TOP_END,
12173 Self::Start => ffi::GTK_WINDOW_GRAVITY_START,
12174 Self::End => ffi::GTK_WINDOW_GRAVITY_END,
12175 Self::BottomStart => ffi::GTK_WINDOW_GRAVITY_BOTTOM_START,
12176 Self::BottomEnd => ffi::GTK_WINDOW_GRAVITY_BOTTOM_END,
12177 Self::__Unknown(value) => value,
12178 }
12179 }
12180}
12181
12182#[cfg(feature = "v4_20")]
12183#[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
12184#[doc(hidden)]
12185impl FromGlib<ffi::GtkWindowGravity> for WindowGravity {
12186 unsafe fn from_glib(value: ffi::GtkWindowGravity) -> Self {
12187 skip_assert_initialized!();
12188
12189 match value {
12190 ffi::GTK_WINDOW_GRAVITY_TOP_LEFT => Self::TopLeft,
12191 ffi::GTK_WINDOW_GRAVITY_TOP => Self::Top,
12192 ffi::GTK_WINDOW_GRAVITY_TOP_RIGHT => Self::TopRight,
12193 ffi::GTK_WINDOW_GRAVITY_LEFT => Self::Left,
12194 ffi::GTK_WINDOW_GRAVITY_CENTER => Self::Center,
12195 ffi::GTK_WINDOW_GRAVITY_RIGHT => Self::Right,
12196 ffi::GTK_WINDOW_GRAVITY_BOTTOM_LEFT => Self::BottomLeft,
12197 ffi::GTK_WINDOW_GRAVITY_BOTTOM => Self::Bottom,
12198 ffi::GTK_WINDOW_GRAVITY_BOTTOM_RIGHT => Self::BottomRight,
12199 ffi::GTK_WINDOW_GRAVITY_TOP_START => Self::TopStart,
12200 ffi::GTK_WINDOW_GRAVITY_TOP_END => Self::TopEnd,
12201 ffi::GTK_WINDOW_GRAVITY_START => Self::Start,
12202 ffi::GTK_WINDOW_GRAVITY_END => Self::End,
12203 ffi::GTK_WINDOW_GRAVITY_BOTTOM_START => Self::BottomStart,
12204 ffi::GTK_WINDOW_GRAVITY_BOTTOM_END => Self::BottomEnd,
12205 value => Self::__Unknown(value),
12206 }
12207 }
12208}
12209
12210#[cfg(feature = "v4_20")]
12211#[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
12212impl StaticType for WindowGravity {
12213 #[inline]
12214 #[doc(alias = "gtk_window_gravity_get_type")]
12215 fn static_type() -> glib::Type {
12216 unsafe { from_glib(ffi::gtk_window_gravity_get_type()) }
12217 }
12218}
12219
12220#[cfg(feature = "v4_20")]
12221#[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
12222impl glib::HasParamSpec for WindowGravity {
12223 type ParamSpec = glib::ParamSpecEnum;
12224 type SetValue = Self;
12225 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
12226
12227 fn param_spec_builder() -> Self::BuilderFn {
12228 Self::ParamSpec::builder_with_default
12229 }
12230}
12231
12232#[cfg(feature = "v4_20")]
12233#[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
12234impl glib::value::ValueType for WindowGravity {
12235 type Type = Self;
12236}
12237
12238#[cfg(feature = "v4_20")]
12239#[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
12240unsafe impl<'a> glib::value::FromValue<'a> for WindowGravity {
12241 type Checker = glib::value::GenericValueTypeChecker<Self>;
12242
12243 #[inline]
12244 unsafe fn from_value(value: &'a glib::Value) -> Self {
12245 skip_assert_initialized!();
12246 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
12247 }
12248}
12249
12250#[cfg(feature = "v4_20")]
12251#[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
12252impl ToValue for WindowGravity {
12253 #[inline]
12254 fn to_value(&self) -> glib::Value {
12255 let mut value = glib::Value::for_value_type::<Self>();
12256 unsafe {
12257 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
12258 }
12259 value
12260 }
12261
12262 #[inline]
12263 fn value_type(&self) -> glib::Type {
12264 Self::static_type()
12265 }
12266}
12267
12268#[cfg(feature = "v4_20")]
12269#[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
12270impl From<WindowGravity> for glib::Value {
12271 #[inline]
12272 fn from(v: WindowGravity) -> Self {
12273 skip_assert_initialized!();
12274 ToValue::to_value(&v)
12275 }
12276}
12277
12278#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
12279#[non_exhaustive]
12280#[doc(alias = "GtkWrapMode")]
12281pub enum WrapMode {
12282 #[doc(alias = "GTK_WRAP_NONE")]
12283 None,
12284 #[doc(alias = "GTK_WRAP_CHAR")]
12285 Char,
12286 #[doc(alias = "GTK_WRAP_WORD")]
12287 Word,
12288 #[doc(alias = "GTK_WRAP_WORD_CHAR")]
12289 WordChar,
12290 #[doc(hidden)]
12291 __Unknown(i32),
12292}
12293
12294#[doc(hidden)]
12295impl IntoGlib for WrapMode {
12296 type GlibType = ffi::GtkWrapMode;
12297
12298 #[inline]
12299 fn into_glib(self) -> ffi::GtkWrapMode {
12300 match self {
12301 Self::None => ffi::GTK_WRAP_NONE,
12302 Self::Char => ffi::GTK_WRAP_CHAR,
12303 Self::Word => ffi::GTK_WRAP_WORD,
12304 Self::WordChar => ffi::GTK_WRAP_WORD_CHAR,
12305 Self::__Unknown(value) => value,
12306 }
12307 }
12308}
12309
12310#[doc(hidden)]
12311impl FromGlib<ffi::GtkWrapMode> for WrapMode {
12312 #[inline]
12313 unsafe fn from_glib(value: ffi::GtkWrapMode) -> Self {
12314 skip_assert_initialized!();
12315
12316 match value {
12317 ffi::GTK_WRAP_NONE => Self::None,
12318 ffi::GTK_WRAP_CHAR => Self::Char,
12319 ffi::GTK_WRAP_WORD => Self::Word,
12320 ffi::GTK_WRAP_WORD_CHAR => Self::WordChar,
12321 value => Self::__Unknown(value),
12322 }
12323 }
12324}
12325
12326impl StaticType for WrapMode {
12327 #[inline]
12328 #[doc(alias = "gtk_wrap_mode_get_type")]
12329 fn static_type() -> glib::Type {
12330 unsafe { from_glib(ffi::gtk_wrap_mode_get_type()) }
12331 }
12332}
12333
12334impl glib::HasParamSpec for WrapMode {
12335 type ParamSpec = glib::ParamSpecEnum;
12336 type SetValue = Self;
12337 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
12338
12339 fn param_spec_builder() -> Self::BuilderFn {
12340 Self::ParamSpec::builder_with_default
12341 }
12342}
12343
12344impl glib::value::ValueType for WrapMode {
12345 type Type = Self;
12346}
12347
12348unsafe impl<'a> glib::value::FromValue<'a> for WrapMode {
12349 type Checker = glib::value::GenericValueTypeChecker<Self>;
12350
12351 #[inline]
12352 unsafe fn from_value(value: &'a glib::Value) -> Self {
12353 skip_assert_initialized!();
12354 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
12355 }
12356}
12357
12358impl ToValue for WrapMode {
12359 #[inline]
12360 fn to_value(&self) -> glib::Value {
12361 let mut value = glib::Value::for_value_type::<Self>();
12362 unsafe {
12363 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
12364 }
12365 value
12366 }
12367
12368 #[inline]
12369 fn value_type(&self) -> glib::Type {
12370 Self::static_type()
12371 }
12372}
12373
12374impl From<WrapMode> for glib::Value {
12375 #[inline]
12376 fn from(v: WrapMode) -> Self {
12377 skip_assert_initialized!();
12378 ToValue::to_value(&v)
12379 }
12380}