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